diff --git a/gl-matrix/gl-matrix-typed-tests.ts b/gl-matrix/gl-matrix-typed-tests.ts
new file mode 100644
index 0000000000..7364ec0a83
--- /dev/null
+++ b/gl-matrix/gl-matrix-typed-tests.ts
@@ -0,0 +1,346 @@
+/// <reference path="gl-matrix-typed.d.ts" />
+
+// common
+import {vec2, mat2, mat3, mat4, vec3, vec4, glMatrix, mat2d, quat} from "./gl-matrix-typed";
+var result: number = glMatrix.toRadian(180);
+
+var outVal: number;
+var outBool: boolean;
+var outStr: string;
+
+let vecArray = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+
+let vec2A = vec2.fromValues(1, 2);
+let vec2B = vec2.fromValues(3, 4);
+let vec3A = vec3.fromValues(1, 2, 3);
+let vec3B = vec3.fromValues(3, 4, 5);
+let vec4A = vec4.fromValues(1, 2, 3, 4);
+let vec4B = vec4.fromValues(3, 4, 5, 6);
+let mat2A = mat2.fromValues(1, 2, 3, 4);
+let mat2B = mat2.fromValues(1, 2, 3, 4);
+let mat2dA = mat2d.fromValues(1, 2, 3, 4, 5, 6);
+let mat2dB = mat2d.fromValues(1, 2, 3, 4, 5, 6);
+let mat3A = mat3.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
+let mat3B = mat3.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
+let mat4A = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+let mat4B = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+let quatA = quat.fromValues(1, 2, 3, 4);
+let quatB = quat.fromValues(5, 6, 7, 8);
+
+let outVec2 = vec2.create();
+let outVec3 = vec3.create();
+let outVec4 = vec4.create();
+let outMat2 = mat2.create();
+let outMat2d = mat2d.create();
+let outMat3 = mat3.create();
+let outMat4 = mat4.create();
+let outQuat = quat.create();
+
+// vec2
+outVec2 = vec2.create();
+outVec2 = vec2.clone(vec2A);
+outVec2 = vec2.fromValues(1, 2);
+outVec2 = vec2.copy(outVec2, vec2A);
+outVec2 = vec2.set(outVec2, 1, 2);
+outVec2 = vec2.add(outVec2, vec2A, vec2B);
+outVec2 = vec2.subtract(outVec2, vec2A, vec2B);
+outVec2 = vec2.sub(outVec2, vec2A, vec2B);
+outVec2 = vec2.multiply(outVec2, vec2A, vec2B);
+outVec2 = vec2.mul(outVec2, vec2A, vec2B);
+outVec2 = vec2.divide(outVec2, vec2A, vec2B);
+outVec2 = vec2.div(outVec2, vec2A, vec2B);
+outVec2 = vec2.ceil(outVec2, vec2A);
+outVec2 = vec2.floor(outVec2, vec2A);
+outVec2 = vec2.min(outVec2, vec2A, vec2B);
+outVec2 = vec2.max(outVec2, vec2A, vec2B);
+outVec2 = vec2.round(outVec2, vec2A);
+outVec2 = vec2.scale(outVec2, vec2A, 2);
+outVec2 = vec2.scaleAndAdd(outVec2, vec2A, vec2B, 0.5);
+outVal = vec2.distance(vec2A, vec2B);
+outVal = vec2.dist(vec2A, vec2B);
+outVal = vec2.squaredDistance(vec2A, vec2B);
+outVal = vec2.sqrDist(vec2A, vec2B);
+outVal = vec2.length(vec2A);
+outVal = vec2.len(vec2A);
+outVal = vec2.squaredLength(vec2A);
+outVal = vec2.sqrLen(vec2A);
+outVec2 = vec2.negate(outVec2, vec2A);
+outVec2 = vec2.inverse(outVec2, vec2A);
+outVec2 = vec2.normalize(outVec2, vec2A);
+outVal = vec2.dot(vec2A, vec2B);
+outVec2 = vec2.cross(outVec2, vec2A, vec2B);
+outVec2 = vec2.lerp(outVec2, vec2A, vec2B, 0.5);
+outVec2 = vec2.random(outVec2);
+outVec2 = vec2.random(outVec2, 5.0);
+outVec2 = vec2.transformMat2(outVec2, vec2A, mat2A);
+outVec2 = vec2.transformMat2d(outVec2, vec2A, mat2dA);
+outVec2 = vec2.transformMat3(outVec2, vec2A, mat3A);
+outVec2 = vec2.transformMat4(outVec2, vec2A, mat4A);
+vecArray = vec2.forEach(vecArray, 0, 0, 0, vec2.normalize);
+outStr = vec2.str(vec2A);
+outBool = vec2.exactEquals(vec2A, vec2B);
+outBool = vec2.equals(vec2A, vec2B);
+
+// vec3
+outVec3 = vec3.create();
+outVec3 = vec3.clone(vec3A);
+outVec3 = vec3.fromValues(1, 2, 3);
+outVec3 = vec3.copy(outVec3, vec3A);
+outVec3 = vec3.set(outVec3, 1, 2, 3);
+outVec3 = vec3.add(outVec3, vec3A, vec3B);
+outVec3 = vec3.subtract(outVec3, vec3A, vec3B);
+outVec3 = vec3.sub(outVec3, vec3A, vec3B);
+outVec3 = vec3.multiply(outVec3, vec3A, vec3B);
+outVec3 = vec3.mul(outVec3, vec3A, vec3B);
+outVec3 = vec3.divide(outVec3, vec3A, vec3B);
+outVec3 = vec3.div(outVec3, vec3A, vec3B);
+outVec3 = vec3.ceil(outVec3, vec3A);
+outVec3 = vec3.floor(outVec3, vec3A);
+outVec3 = vec3.min(outVec3, vec3A, vec3B);
+outVec3 = vec3.max(outVec3, vec3A, vec3B);
+outVec3 = vec3.round(outVec3, vec3A);
+outVec3 = vec3.scale(outVec3, vec3A, 2);
+outVec3 = vec3.scaleAndAdd(outVec3, vec3A, vec3B, 0.5);
+outVal = vec3.distance(vec3A, vec3B);
+outVal = vec3.dist(vec3A, vec3B);
+outVal = vec3.squaredDistance(vec3A, vec3B);
+outVal = vec3.sqrDist(vec3A, vec3B);
+outVal = vec3.length(vec3A);
+outVal = vec3.len(vec3A);
+outVal = vec3.squaredLength(vec3A);
+outVal = vec3.sqrLen(vec3A);
+outVec3 = vec3.negate(outVec3, vec3A);
+outVec3 = vec3.inverse(outVec3, vec3A);
+outVec3 = vec3.normalize(outVec3, vec3A);
+outVal = vec3.dot(vec3A, vec3B);
+outVec3 = vec3.cross(outVec3, vec3A, vec3B);
+outVec3 = vec3.lerp(outVec3, vec3A, vec3B, 0.5);
+outVec3 = vec3.hermite(outVec3, vec3A, vec3B, vec3A, vec3B, 0.5);
+outVec3 = vec3.bezier(outVec3, vec3A, vec3B, vec3A, vec3B, 0.5);
+outVec3 = vec3.random(outVec3);
+outVec3 = vec3.random(outVec3, 5.0);
+outVec3 = vec3.transformMat3(outVec3, vec3A, mat3A);
+outVec3 = vec3.transformMat4(outVec3, vec3A, mat4A);
+outVec3 = vec3.transformQuat(outVec3, vec3A, quatA);
+outVec3 = vec3.rotateX(outVec3, vec3A, vec3B, Math.PI);
+outVec3 = vec3.rotateY(outVec3, vec3A, vec3B, Math.PI);
+outVec3 = vec3.rotateZ(outVec3, vec3A, vec3B, Math.PI);
+vecArray = vec3.forEach(vecArray, 0, 0, 0, vec3.normalize);
+outVal = vec3.angle(vec3A, vec3B);
+outStr = vec3.str(vec3A);
+outBool = vec3.exactEquals(vec3A, vec3B);
+outBool = vec3.equals(vec3A, vec3B);
+
+// vec4
+outVec4 = vec4.create();
+outVec4 = vec4.clone(vec4A);
+outVec4 = vec4.fromValues(1, 2, 3, 4);
+outVec4 = vec4.copy(outVec4, vec4A);
+outVec4 = vec4.set(outVec4, 1, 2, 3, 4);
+outVec4 = vec4.add(outVec4, vec4A, vec4B);
+outVec4 = vec4.subtract(outVec4, vec4A, vec4B);
+outVec4 = vec4.sub(outVec4, vec4A, vec4B);
+outVec4 = vec4.multiply(outVec4, vec4A, vec4B);
+outVec4 = vec4.mul(outVec4, vec4A, vec4B);
+outVec4 = vec4.divide(outVec4, vec4A, vec4B);
+outVec4 = vec4.div(outVec4, vec4A, vec4B);
+outVec4 = vec4.ceil(outVec4, vec4A);
+outVec4 = vec4.floor(outVec4, vec4A);
+outVec4 = vec4.min(outVec4, vec4A, vec4B);
+outVec4 = vec4.max(outVec4, vec4A, vec4B);
+outVec4 = vec4.scale(outVec4, vec4A, 2);
+outVec4 = vec4.scaleAndAdd(outVec4, vec4A, vec4B, 0.5);
+outVal = vec4.distance(vec4A, vec4B);
+outVal = vec4.dist(vec4A, vec4B);
+outVal = vec4.squaredDistance(vec4A, vec4B);
+outVal = vec4.sqrDist(vec4A, vec4B);
+outVal = vec4.length(vec4A);
+outVal = vec4.len(vec4A);
+outVal = vec4.squaredLength(vec4A);
+outVal = vec4.sqrLen(vec4A);
+outVec4 = vec4.negate(outVec4, vec4A);
+outVec4 = vec4.inverse(outVec4, vec4A);
+outVec4 = vec4.normalize(outVec4, vec4A);
+outVal = vec4.dot(vec4A, vec4B);
+outVec4 = vec4.lerp(outVec4, vec4A, vec4B, 0.5);
+outVec4 = vec4.random(outVec4);
+outVec4 = vec4.random(outVec4, 5.0);
+outVec4 = vec4.transformMat4(outVec4, vec4A, mat4A);
+outVec4 = vec4.transformQuat(outVec4, vec4A, quatA);
+vecArray = vec4.forEach(vecArray, 0, 0, 0, vec4.normalize);
+outStr = vec4.str(vec4A);
+outBool = vec4.exactEquals(vec4A, vec4B);
+outBool = vec4.equals(vec4A, vec4B);
+
+// mat2
+outMat2 = mat2.create();
+outMat2 = mat2.clone(mat2A);
+outMat2 = mat2.copy(outMat2, mat2A);
+outMat2 = mat2.identity(outMat2);
+outMat2 = mat2.fromValues(1, 2, 3, 4);
+outMat2 = mat2.set(outMat2, 1, 2, 3, 4);
+outMat2 = mat2.transpose(outMat2, mat2A);
+outMat2 = mat2.invert(outMat2, mat2A);
+outMat2 = mat2.adjoint(outMat2, mat2A);
+outVal = mat2.determinant(mat2A);
+outMat2 = mat2.multiply(outMat2, mat2A, mat2B);
+outMat2 = mat2.mul(outMat2, mat2A, mat2B);
+outMat2 = mat2.rotate(outMat2, mat2A, Math.PI * 0.5);
+outMat2 = mat2.scale(outMat2, mat2A, vec2A);
+outMat2 = mat2.fromRotation(outMat2, 0.5);
+outMat2 = mat2.fromScaling(outMat2, vec2A);
+outStr = mat2.str(mat2A);
+outVal = mat2.frob(mat2A);
+var L = mat2.create();
+var D = mat2.create();
+var U = mat2.create();
+outMat2 = mat2.LDU(L, D, U, mat2A);
+outMat2 = mat2.add(outMat2, mat2A, mat2B);
+outMat2 = mat2.subtract(outMat2, mat2A, mat2B);
+outMat2 = mat2.sub(outMat2, mat2A, mat2B);
+outBool = mat2.exactEquals(mat2A, mat2B);
+outBool = mat2.equals(mat2A, mat2B);
+outMat2 = mat2.multiplyScalar (outMat2, mat2A, 2);
+outMat2 = mat2.multiplyScalarAndAdd (outMat2, mat2A, mat2B, 2);
+
+// mat2d
+outMat2d = mat2d.create();
+outMat2d = mat2d.clone(mat2dA);
+outMat2d = mat2d.copy(outMat2d, mat2dA);
+outMat2d = mat2d.identity(outMat2d);
+outMat2d = mat2d.fromValues(1, 2, 3, 4, 5, 6);
+outMat2d = mat2d.set(outMat2d, 1, 2, 3, 4, 5, 6);
+outMat2d = mat2d.invert(outMat2d, mat2dA);
+outVal = mat2d.determinant(mat2dA);
+outMat2d = mat2d.multiply(outMat2d, mat2dA, mat2dB);
+outMat2d = mat2d.mul(outMat2d, mat2dA, mat2dB);
+outMat2d = mat2d.rotate(outMat2d, mat2dA, Math.PI * 0.5);
+outMat2d = mat2d.scale(outMat2d, mat2dA, vec2A);
+outMat2d = mat2d.translate(outMat2d, mat2dA, vec2A);
+outMat2d = mat2d.fromRotation(outMat2d, 0.5);
+outMat2d = mat2d.fromScaling(outMat2d, vec2A);
+outMat2d = mat2d.fromTranslation(outMat2d, vec2A);
+outStr = mat2d.str(mat2dA);
+outVal = mat2d.frob(mat2dA);
+outMat2d = mat2d.add(outMat2d, mat2dA, mat2dB);
+outMat2d = mat2d.subtract(outMat2d, mat2dA, mat2dB);
+outMat2d = mat2d.sub(outMat2d, mat2dA, mat2dB);
+outMat2d = mat2d.multiplyScalar (outMat2d, mat2dA, 2);
+outMat2d = mat2d.multiplyScalarAndAdd (outMat2d, mat2dA, mat2dB, 2);
+outBool = mat2d.exactEquals(mat2dA, mat2dB);
+outBool = mat2d.equals(mat2dA, mat2dB);
+
+
+// mat3
+outMat3 = mat3.create();
+outMat3 = mat3.fromMat4(outMat3, mat4A);
+outMat3 = mat3.clone(mat3A);
+outMat3 = mat3.copy(outMat3, mat3A);
+outMat3 = mat3.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9);
+outMat3 = mat3.set(outMat3, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+outMat3 = mat3.identity(outMat3);
+outMat3 = mat3.transpose(outMat3, mat3A);
+outMat3 = mat3.invert(outMat3, mat3A);
+outMat3 = mat3.adjoint(outMat3, mat3A);
+outVal = mat3.determinant(mat3A);
+outMat3 = mat3.multiply(outMat3, mat3A, mat3B);
+outMat3 = mat3.mul(outMat3, mat3A, mat3B);
+outMat3 = mat3.translate(outMat3, mat3A, vec3A);
+outMat3 = mat3.rotate(outMat3, mat3A, Math.PI/2);
+outMat3 = mat3.scale(outMat3, mat3A, vec2A);
+outMat3 = mat3.fromTranslation(outMat3, vec2A);
+outMat3 = mat3.fromRotation(outMat3, Math.PI);
+outMat3 = mat3.fromScaling(outMat3, vec2A);
+outMat3 = mat3.fromMat2d(outMat3, mat2dA);
+outMat3 = mat3.fromQuat(outMat3, quatA);
+outMat3 = mat3.normalFromMat4(outMat3, mat4A);
+outStr = mat3.str(mat3A);
+outVal = mat3.frob(mat3A);
+outMat3 = mat3.add(outMat3, mat3A, mat3B);
+outMat3 = mat3.subtract(outMat3, mat3A, mat3B);
+outMat3 = mat3.sub(outMat3, mat3A, mat3B);
+outMat3 = mat3.multiplyScalar (outMat3, mat3A, 2);
+outMat3 = mat3.multiplyScalarAndAdd (outMat3, mat3A, mat3B, 2);
+outBool = mat3.exactEquals(mat3A, mat3B);
+outBool = mat3.equals(mat3A, mat3B);
+
+//mat4
+outMat4 = mat4.create();
+outMat4 = mat4.clone(mat4A);
+outMat4 = mat4.copy(outMat4, mat4A);
+outMat4 = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+outMat4 = mat4.set(outMat4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+outMat4 = mat4.identity(outMat4);
+outMat4 = mat4.transpose(outMat4, mat4A);
+outMat4 = mat4.invert(outMat4, mat4A);
+outMat4 = mat4.adjoint(outMat4, mat4A);
+outVal = mat4.determinant(mat4A);
+outMat4 = mat4.multiply(outMat4, mat4A, mat4B);
+outMat4 = mat4.mul(outMat4, mat4A, mat4B);
+outMat4 = mat4.translate(outMat4, mat4A, vec3A);
+outMat4 = mat4.scale(outMat4, mat4A, vec3A);
+outMat4 = mat4.rotate(outMat4, mat4A, Math.PI, vec3A);
+outMat4 = mat4.rotateX(outMat4, mat4A, Math.PI);
+outMat4 = mat4.rotateY(outMat4, mat4A, Math.PI);
+outMat4 = mat4.rotateZ(outMat4, mat4A, Math.PI);
+outMat4 = mat4.fromTranslation(outMat4, vec3A);
+outMat4 = mat4.fromRotation(outMat4, Math.PI, vec3A);
+outMat4 = mat4.fromScaling(outMat4, vec3A);
+outMat4 = mat4.fromXRotation(outMat4, Math.PI);
+outMat4 = mat4.fromYRotation(outMat4, Math.PI);
+outMat4 = mat4.fromZRotation(outMat4, Math.PI);
+outMat4 = mat4.fromRotationTranslation(outMat4, quatA, vec3A);
+outVec3 = mat4.getTranslation(outVec3, mat4A)
+outQuat = mat4.getRotation(outQuat, mat4A)
+outMat4 = mat4.fromRotationTranslationScale(outMat4, quatA, vec3A, vec3B);
+outMat4 = mat4.fromRotationTranslationScaleOrigin(outMat4, quatA, vec3A, vec3B, vec3A);
+outMat4 = mat4.fromQuat(outMat4, quatB);
+outMat4 = mat4.frustum(outMat4, -1, 1, -1, 1, -1, 1);
+outMat4 = mat4.perspective(outMat4, Math.PI, 1, 0, 1);
+outMat4 = mat4.perspectiveFromFieldOfView(outMat4, {upDegrees:Math.PI, downDegrees:-Math.PI, leftDegrees:-Math.PI, rightDegrees:Math.PI}, 1, 0);
+outMat4 = mat4.ortho(outMat4, -1, 1, -1, 1, -1, 1);
+outMat4 = mat4.lookAt(outMat4, vec3A, vec3B, vec3A);
+outStr = mat4.str(mat4A);
+outVal = mat4.frob(mat4A);
+outMat4 = mat4.add(outMat4, mat4A, mat4B);
+outMat4 = mat4.subtract(outMat4, mat4A, mat4B);
+outMat4 = mat4.sub(outMat4, mat4A, mat4B);
+outMat4 = mat4.multiplyScalar (outMat4, mat4A, 2);
+outMat4 = mat4.multiplyScalarAndAdd (outMat4, mat4A, mat4B, 2);
+outBool = mat4.exactEquals(mat4A, mat4B);
+outBool = mat4.equals(mat4A, mat4B);
+
+// quat
+var deg90 = Math.PI / 2;
+outQuat = quat.create();
+outQuat = quat.clone(quatA);
+outQuat = quat.fromValues(1, 2, 3, 4);
+outQuat = quat.copy(outQuat, quatA);
+outQuat = quat.set(outQuat, 1, 2, 3, 4);
+outQuat = quat.identity(outQuat);
+outQuat = quat.rotationTo(outQuat, vec3A, vec3B);
+outQuat = quat.setAxes(outQuat, vec3A, vec3B, vec3A);
+outQuat = quat.setAxisAngle(outQuat, vec3A, Math.PI * 0.5);
+outVal = quat.getAxisAngle (outVec3, quatA);
+outQuat = quat.add(outQuat, quatA, quatB);
+outQuat = quat.multiply(outQuat, quatA, quatB);
+outQuat = quat.mul(outQuat, quatA, quatB);
+outQuat = quat.scale(outQuat, quatA, 2);
+outVal = quat.length(quatA);
+outVal = quat.len(quatA);
+outVal = quat.squaredLength(quatA);
+outVal = quat.sqrLen(quatA);
+outQuat = quat.normalize(outQuat, quatA);
+outVal = quat.dot(quatA, quatB);
+outQuat = quat.lerp(outQuat, quatA, quatB, 0.5);
+outQuat = quat.slerp(outQuat, quatA, quatB, 0.5);
+outQuat = quat.invert(outQuat, quatA);
+outQuat = quat.conjugate(outQuat, quatA);
+outStr = quat.str(quatA);
+outQuat = quat.rotateX(outQuat, quatA, deg90);
+outQuat = quat.rotateY(outQuat, quatA, deg90);
+outQuat = quat.rotateZ(outQuat, quatA, deg90);
+outQuat = quat.fromMat3(outQuat, mat3A);
+outQuat = quat.calculateW(outQuat, quatA);
+outBool = quat.exactEquals(quatA, quatB);
+outBool = quat.equals(quatA, quatB);
\ No newline at end of file
diff --git a/gl-matrix/gl-matrix-typed.d.ts b/gl-matrix/gl-matrix-typed.d.ts
index f64225c6f7..e172074fec 100644
--- a/gl-matrix/gl-matrix-typed.d.ts
+++ b/gl-matrix/gl-matrix-typed.d.ts
@@ -1,16 +1,16 @@
 // Type definitions for gl-matrix 2.2.2
 // Project: https://github.com/toji/gl-matrix
-// Definitions by: Tat <https://github.com/tatchx>
+// Definitions by: Mattijs Kneppers <https://github.com/mattijskneppers>, based on definitions by Tat <https://github.com/tatchx>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 // Common
-declare namespace glMatrix {
+export class glMatrix {
     /**
-    * Convert Degree To Radian
-    *
-    * @param a Angle in Degrees
-    */
-    export function toRadian(a: number): number;
+     * Convert Degree To Radian
+     *
+     * @param a Angle in Degrees
+     */
+    public static toRadian(a: number): number;
 }
 
 // vec2
@@ -396,8 +396,8 @@ export class vec2 extends Float32Array {
      * @param arg additional argument to pass to fn
      * @returns a
      */
-    public static forEach(a: vec2, stride: number, offset: number, count: number,
-        fn: (a: vec2, b: vec2, arg: any) => void, arg: any): vec2;
+    public static forEach(a: Float32Array, stride: number, offset: number, count: number,
+                          fn: (a: vec2, b: vec2, arg: any) => void, arg: any): Float32Array;
 
     /**
      * Perform some operation over an array of vec2s.
@@ -409,8 +409,8 @@ export class vec2 extends Float32Array {
      * @param fn Function to call for each vector in the array
      * @returns a
      */
-    public static forEach(a: vec2, stride: number, offset: number, count: number,
-        fn: (a: vec2, b: vec2) => void): vec2;
+    public static forEach(a: Float32Array, stride: number, offset: number, count: number,
+                          fn: (a: vec2, b: vec2) => void): Float32Array;
 
     /**
      * Returns a string representation of a vector
@@ -868,8 +868,8 @@ export class vec3 extends Float32Array {
      * @returns a
      * @function
      */
-    public static forEach(a: vec3, stride: number, offset: number, count: number,
-        fn: (a: vec3, b: vec3, arg: any) => void, arg: any): vec3;
+    public static forEach(a: Float32Array, stride: number, offset: number, count: number,
+                          fn: (a: vec3, b: vec3, arg: any) => void, arg: any): Float32Array;
 
     /**
      * Perform some operation over an array of vec3s.
@@ -882,8 +882,8 @@ export class vec3 extends Float32Array {
      * @returns a
      * @function
      */
-    public static forEach(a: vec3, stride: number, offset: number, count: number,
-        fn: (a: vec3, b: vec3) => void): vec3;
+    public static forEach(a: Float32Array, stride: number, offset: number, count: number,
+                          fn: (a: vec3, b: vec3) => void): Float32Array;
 
     /**
      * Get the angle between two 3D vectors
@@ -908,7 +908,7 @@ export class vec3 extends Float32Array {
      * @param {vec3} b The second vector.
      * @returns {boolean} True if the vectors are equal, false otherwise.
      */
-    public static exactEquals (a, b): boolean
+    public static exactEquals (a:vec3, b:vec3): boolean
 
     /**
      * Returns whether or not the vectors have approximately the same elements in the same position.
@@ -917,7 +917,7 @@ export class vec3 extends Float32Array {
      * @param {vec3} b The second vector.
      * @returns {boolean} True if the vectors are equal, false otherwise.
      */
-    public static equals (a, b) : boolean
+    public static equals (a:vec3, b:vec3) : boolean
 }
 
 // vec4
@@ -1274,8 +1274,8 @@ export class vec4 extends Float32Array {
      * @returns a
      * @function
      */
-    public static forEach(a: vec4, stride: number, offset: number, count: number,
-        fn: (a: vec4, b: vec4, arg: any) => void, arg: any): vec4;
+    public static forEach(a: Float32Array, stride: number, offset: number, count: number,
+                          fn: (a: vec4, b: vec4, arg: any) => void, arg: any): Float32Array;
 
     /**
      * Perform some operation over an array of vec4s.
@@ -1288,8 +1288,8 @@ export class vec4 extends Float32Array {
      * @returns a
      * @function
      */
-    public static forEach(a: vec4, stride: number, offset: number, count: number,
-        fn: (a: vec4, b: vec4) => void): vec4;
+    public static forEach(a: Float32Array, stride: number, offset: number, count: number,
+                          fn: (a: vec4, b: vec4) => void): Float32Array;
 
     /**
      * Returns a string representation of a vector
@@ -1476,7 +1476,7 @@ export class mat2 extends Float32Array {
      * @param {vec2} v Scaling vector
      * @returns {mat2} out
      */
-    public static fromScaling(out:mat2, v:vec2);
+    public static fromScaling(out:mat2, v:vec2):mat2;
 
     /**
      * Returns a string representation of a mat2
@@ -1623,7 +1623,7 @@ export class mat2d extends Float32Array {
      * @param {number} ty Component TY (index 5)
      * @returns {mat2d} A new mat2d
      */
-     public static fromValues (a:number, b:number, c:number, d:number, tx:number, ty:number) : mat2d
+    public static fromValues (a:number, b:number, c:number, d:number, tx:number, ty:number) : mat2d
 
 
     /**
@@ -1800,7 +1800,7 @@ export class mat2d extends Float32Array {
      * @param {number} b amount to scale the matrix's elements by
      * @returns {mat2d} out
      */
-    public static multiplyScalar (out: mat2d, a: mat2d, b: mat2d): mat2d;
+    public static multiplyScalar (out: mat2d, a: mat2d, b: number): mat2d;
 
     /**
      * Adds two mat2d's after multiplying each element of the second operand by a scalar value.
@@ -1883,7 +1883,7 @@ export class mat3 extends Float32Array {
      * @param {number} m22 Component in column 2, row 2 position (index 8)
      * @returns {mat3} A new mat3
      */
-    public static fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22):mat3;
+    public static fromValues(m00:number, m01:number, m02:number, m10:number, m11:number, m12:number, m20:number, m21:number, m22:number):mat3;
 
 
     /**
@@ -2045,15 +2045,6 @@ export class mat3 extends Float32Array {
      **/
     public static fromMat2d(out:mat3, a:mat2d):mat3;
 
-    /**
-     * Copies the upper-left 3x3 values into the given mat3.
-     *
-     * @param out the receiving 3x3 matrix
-     * @param a   the source 4x4 matrix
-     * @returns out
-     */
-    public static fromMat4(out:mat3, a:mat4):mat3;
-
     /**
      * Calculates a 3x3 matrix from the given quaternion
      *
@@ -2072,7 +2063,7 @@ export class mat3 extends Float32Array {
      *
      * @returns out
      */
-    public static normalFromMat4(out:mat3, a:mat3):mat3;
+    public static normalFromMat4(out:mat3, a:mat4):mat3;
 
     /**
      * Returns a string representation of a mat3
@@ -2210,7 +2201,7 @@ export class mat4 extends Float32Array {
      * @param {number} m33 Component in column 3, row 3 position (index 15)
      * @returns {mat4} A new mat4
      */
-    public static fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33):mat4;
+    public static fromValues(m00:number, m01:number, m02:number, m03:number, m10:number, m11:number, m12:number, m13:number, m20:number, m21:number, m22:number, m23:number, m30:number, m31:number, m32:number, m33:number):mat4;
 
     /**
      * Set the components of a mat4 to the given values
@@ -2234,7 +2225,7 @@ export class mat4 extends Float32Array {
      * @param {number} m33 Component in column 3, row 3 position (index 15)
      * @returns {mat4} out
      */
-    public static set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33):mat4;
+    public static set(out:mat4, m00:number, m01:number, m02:number, m03:number, m10:number, m11:number, m12:number, m13:number, m20:number, m21:number, m22:number, m23:number, m30:number, m31:number, m32:number, m33:number):mat4;
 
     /**
      * Set a mat4 to the identity matrix
@@ -2571,7 +2562,7 @@ export class mat4 extends Float32Array {
      */
     public static perspectiveFromFieldOfView(out:mat4,
                                              fov:{upDegrees:number, downDegrees:number, leftDegrees:number, rightDegrees:number},
-                                             near, far):mat4
+                                             near:number, far:number):mat4
 
     /**
      * Generates a orthogonal projection matrix with the given bounds
@@ -2653,7 +2644,7 @@ export class mat4 extends Float32Array {
      * @param {number} b amount to scale the matrix's elements by
      * @returns {mat4} out
      */
-    public static multiplyScalar(out:mat4, a:mat4, b:mat4):mat4
+    public static multiplyScalar(out:mat4, a:mat4, b:number):mat4
 
     /**
      * Adds two mat4's after multiplying each element of the second operand by a scalar value.
@@ -3059,5 +3050,5 @@ export class quat extends Float32Array {
      * @param {quat} b The second vector.
      * @returns {boolean} True if the quaternions are equal, false otherwise.
      */
-    public static equals (a:quat, b:quat) : boolean;    
+    public static equals (a:quat, b:quat) : boolean;
 }