Corrected return values, added file exports

types/gl-vec4/add.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Adds two vec4's.
+ */
+declare function add(out: number[], a: number[], b: number[]): number[];
+
+export default add;

types/gl-vec4/clone.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a new vec4 initialized with values from an existing vector.
+ */
+declare function clone(a: number[]): number[];
+
+export default clone;

types/gl-vec4/copy.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copy the values from one vec4 to another.
+ */
+declare function copy(out: number[], a: number[]): number[];
+
+export default copy;

types/gl-vec4/create.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a new, empty vec4.
+ */
+declare function create(): number[];
+
+export default create;

types/gl-vec4/distance.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the euclidian distance between two vec4's.
+ */
+declare function distance(a: number[], b: number[]): number;
+
+export default distance;

types/gl-vec4/divide.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Divides two vec4's.
+ */
+declare function divide(out: number[], a: number[], b: number[]): number[];
+
+export default divide;

types/gl-vec4/dot.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the dot product of two vec4's.
+ */
+declare function dot(a: number[], b: number[]): number;
+
+export default dot;

types/gl-vec4/fromValues.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a new vec4 initialized with the given values.
+ */
+declare function fromValues(x: number, y: number, z: number, w: number): number[];
+
+export default fromValues;

types/gl-vec4/gl-vec4-tests.ts

@@ -1,27 +1,102 @@
 import * as glVec from "gl-vec4";
 
+import glVecAdd from "gl-vec4/add";
+import glVecClone from "gl-vec4/clone";
+import glVecCopy from "gl-vec4/copy";
+import glVecCreate from "gl-vec4/create";
+import glVecDistance from "gl-vec4/distance";
+import glVecDivide from "gl-vec4/divide";
+import glVecDot from "gl-vec4/dot";
+import glVecFromValues from "gl-vec4/fromValues";
+import glVecInverse from "gl-vec4/inverse";
+import glVecLength from "gl-vec4/length";
+import glVecLerp from "gl-vec4/lerp";
+import glVecMax from "gl-vec4/max";
+import glVecMin from "gl-vec4/min";
+import glVecMultiply from "gl-vec4/multiply";
+import glVecNegate from "gl-vec4/negate";
+import glVecNormalize from "gl-vec4/normalize";
+import glVecRandom from "gl-vec4/random";
+import glVecScale from "gl-vec4/scale";
+import glVecScaleAndAdd from "gl-vec4/scaleAndAdd";
+import glVecSet from "gl-vec4/set";
+import glVecSqrdDistance from "gl-vec4/squaredDistance";
+import glVecSqrdLength from "gl-vec4/squaredLength";
+import glVecSubtract from "gl-vec4/subtract";
+import glVecTransformMat4 from "gl-vec4/transformMat4";
+import glVecTransformQuat from "gl-vec4/transformQuat";
+
 glVec.add([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVecAdd([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
 glVec.clone([1, 2, 3]);
+glVecClone([1, 2, 3]);
+
 glVec.copy([1, 2, 3], [1, 2, 3]);
+glVecCopy([1, 2, 3], [1, 2, 3]);
+
 glVec.create();
+glVecCreate();
+
 glVec.distance([1, 2, 3], [1, 2, 3]);
+glVecDistance([1, 2, 3], [1, 2, 3]);
+
 glVec.divide([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVecDivide([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
 glVec.dot([1, 2, 3], [1, 2, 3]);
-glVec.fromValues(6, 6, 6, 6);
+glVecDot([1, 2, 3], [1, 2, 3]);
+
+glVec.fromValues(1, 2, 4, 5);
+glVecFromValues(1, 2, 4, 5);
+
 glVec.inverse([1, 2, 3], [1, 2, 3]);
+glVecInverse([1, 2, 3], [1, 2, 3]);
+
 glVec.length([1, 2, 3]);
+glVecLength([1, 2, 3]);
+
 glVec.lerp([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+glVecLerp([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+
 glVec.max([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVecMax([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
 glVec.min([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVecMin([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
 glVec.multiply([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVecMultiply([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
 glVec.negate([1, 2, 3], [1, 2, 3]);
+glVecNegate([1, 2, 3], [1, 2, 3]);
+
 glVec.normalize([1, 2, 3], [1, 2, 3]);
+glVecNormalize([1, 2, 3], [1, 2, 3]);
+
 glVec.random([1, 2, 3], 6);
+glVecRandom([1, 2, 3], 6);
+
 glVec.scale([1, 2, 3], [1, 2, 3], 6);
+glVecScale([1, 2, 3], [1, 2, 3], 6);
+
 glVec.scaleAndAdd([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+glVecScaleAndAdd([1, 2, 3], [1, 2, 3], [1, 2, 3], 6);
+
 glVec.set([1, 2, 3], [1, 2, 3], [1, 2, 3], 6, 6);
+glVecSet([1, 2, 3], [1, 2, 3], [1, 2, 3], 6, 6);
+
 glVec.squaredDistance([1, 2, 3], [1, 2, 3]);
+glVecSqrdDistance([1, 2, 3], [1, 2, 3]);
+
 glVec.squaredLength([1, 2, 3]);
+glVecSqrdLength([1, 2, 3]);
+
 glVec.subtract([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVecSubtract([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
 glVec.transformMat4([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVecTransformMat4([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+
 glVec.transformQuat([1, 2, 3], [1, 2, 3], [1, 2, 3]);
+glVecTransformQuat([1, 2, 3], [1, 2, 3], [1, 2, 3]);

types/gl-vec4/index.d.ts

@@ -2,7 +2,6 @@
 // Project: https://github.com/stackgl/gl-vec4
 // Definitions by:  Adam Zerella <https://github.com/adamzerella>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 3.3
 
 /**
  * Adds two vec4's.
@@ -27,7 +26,7 @@ export function create(): number[];
 /**
  * Calculates the euclidian distance between two vec4's.
  */
-export function distance(a: number[], b: number[]): number[];
+export function distance(a: number[], b: number[]): number;
 
 /**
  * Divides two vec4's.
@@ -37,7 +36,7 @@ export function divide(out: number[], a: number[], b: number[]): number[];
 /**
  * Calculates the dot product of two vec4's.
  */
-export function dot(a: number[], b: number[]): number[];
+export function dot(a: number[], b: number[]): number;
 
 /**
  * Creates a new vec4 initialized with the given values.
@@ -52,7 +51,7 @@ export function inverse(out: number[], a: number[]): number[];
 /**
  * Calculates the length of a vec4.
  */
-export function length(a: number[]): number[];
+export function length(a: number[]): number;
 
 /**
  * Performs a linear interpolation between two vec4's.
@@ -107,12 +106,12 @@ export function set(out: number[], x: number[], y: number[], z: number, w: numbe
 /**
  * Calculates the squared euclidian distance between two vec4's.
  */
-export function squaredDistance(a: number[], b: number[]): number[];
+export function squaredDistance(a: number[], b: number[]): number;
 
 /**
  * Calculates the squared length of a vec4.
  */
-export function squaredLength(a: number[]): number[];
+export function squaredLength(a: number[]): number;
 
 /**
  * Subtracts vector b from vector a.

types/gl-vec4/inverse.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the inverse of the components of a vec4.
+ */
+declare function inverse(out: number[], a: number[]): number[];
+
+export default inverse;

types/gl-vec4/length.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the length of a vec4.
+ */
+declare function length(a: number[]): number;
+
+export default length;

types/gl-vec4/lerp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Performs a linear interpolation between two vec4's.
+ */
+declare function lerp(out: number[], a: number[], b: number[], t: number): number[];
+
+export default lerp;

types/gl-vec4/max.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the maximum of two vec4's.
+ */
+declare function max(out: number[], a: number[], b: number[]): number[];
+
+export default max;

types/gl-vec4/min.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the minimum of two vec4's.
+ */
+declare function min(out: number[], a: number[], b: number[]): number[];
+
+export default min;

types/gl-vec4/multiply.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Multiplies two vec4's.
+ */
+declare function multiply(out: number[], a: number[], b: number[]): number[];
+
+export default multiply;

types/gl-vec4/negate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Negates the components of a vec4.
+ */
+declare function negate(out: number[], a: number[]): number[];
+
+export default negate;

types/gl-vec4/normalize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Normalize a vec4.
+ */
+declare function normalize(out: number[], a: number[]): number[];
+
+export default normalize;

types/gl-vec4/random.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a random vector with the given scale.
+ */
+declare function random(out: number[], scale: number): number[];
+
+export default random;

types/gl-vec4/scale.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Scales a vec4 by a scalar number.
+ */
+declare function scale(out: number[], a: number[], b: number): number[];
+
+export default scale;

types/gl-vec4/scaleAndAdd.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Adds two vec4's after scaling the second operand by a scalar value.
+ */
+declare function scaleAndAdd(out: number[], a: number[], b: number[], scale: number): number[];
+
+export default scaleAndAdd;

types/gl-vec4/set.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Set the components of a vec4 to the given values.
+ */
+declare function set(out: number[], x: number[], y: number[], z: number, w: number): number[];
+
+export default set;

types/gl-vec4/squaredDistance.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the squared euclidian distance between two vec4's.
+ */
+declare function squaredDistance(a: number[], b: number[]): number;
+
+export default squaredDistance;

types/gl-vec4/squaredLength.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Calculates the squared length of a vec4.
+ */
+declare function squaredLength(a: number[]): number;
+
+export default squaredLength;

types/gl-vec4/subtract.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Subtracts vector b from vector a.
+ */
+declare function subtract(out: number[], a: number[], b: number[]): number[];
+
+export default subtract;

types/gl-vec4/transformMat4.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transforms the vec4 with a mat4..
+ */
+declare function transformMat4(out: number[], a: number[], m: number[]): number[];
+
+export default transformMat4;

types/gl-vec4/transformQuat.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transforms the vec4 with a quat.
+ */
+declare function transformQuat(out: number[], a: number[], q: number[]): number[];
+
+export default transformQuat;

types/gl-vec4/tsconfig.json

@@ -20,6 +20,31 @@
     },
     "files": [
       "index.d.ts",
+      "add.d.ts",
+      "clone.d.ts",
+      "copy.d.ts",
+      "create.d.ts",
+      "distance.d.ts",
+      "divide.d.ts",
+      "dot.d.ts",
+      "fromValues.d.ts",
+      "inverse.d.ts",
+      "length.d.ts",
+      "lerp.d.ts",
+      "max.d.ts",
+      "min.d.ts",
+      "multiply.d.ts",
+      "negate.d.ts",
+      "normalize.d.ts",
+      "random.d.ts",
+      "scale.d.ts",
+      "scaleAndAdd.d.ts",
+      "set.d.ts",
+      "squaredDistance.d.ts",
+      "squaredLength.d.ts",
+      "subtract.d.ts",
+      "transformMat4.d.ts",
+      "transformQuat.d.ts",
       "gl-vec4-tests.ts"
     ]
 }