diff --git a/docs/types/index.d.ts b/docs/types/index.d.ts
index 7410fca9..dd16ba0d 100644
--- a/docs/types/index.d.ts
+++ b/docs/types/index.d.ts
@@ -255,6 +255,13 @@ import isRelativePath = require( './../../is-relative-path' );
 import isRelativeURI = require( './../../is-relative-uri' );
 import isSafeInteger = require( './../../is-safe-integer' );
 import isSafeIntegerArray = require( './../../is-safe-integer-array' );
+import isSameArray = require( './../../is-same-array' );
+import isSameComplex64 = require( './../../is-same-complex64' );
+import isSameComplex64Array = require( './../../is-same-complex64array' );
+import isSameComplex128 = require( './../../is-same-complex128' );
+import isSameComplex128Array = require( './../../is-same-complex128array' );
+import isSameFloat32Array = require( './../../is-same-float32array' );
+import isSameFloat64Array = require( './../../is-same-float64array' );
 import isSameNativeClass = require( './../../is-same-native-class' );
 import isSameType = require( './../../is-same-type' );
 import isSameValue = require( './../../is-same-value' );
@@ -5655,6 +5662,219 @@ interface Namespace {
 	*/
 	isSafeIntegerArray: typeof isSafeIntegerArray;
 
+	/**
+	* Tests if two arguments are both generic arrays and have the same values.
+	*
+	* ## Notes
+	*
+	* -   The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same.
+	*
+	* @param v1 - first input value
+	* @param v2 - second input value
+	* @returns boolean indicating whether two arguments are the same
+	*
+	* @example
+	* var x = [ 1.0, 2.0, 3.0 ];
+	* var y = [ 1.0, 2.0, 3.0 ];
+	*
+	* var out = ns.isSameArray( x, y );
+	* // returns true
+	*
+	* @example
+	* var x = [ 1.0, 2.0, 3.0 ];
+	* var y = [ 1.0, 2.0, 4.0 ];
+	*
+	* var out = ns.isSameArray( x, y );
+	* // returns false
+	*/
+	isSameArray: typeof isSameArray;
+
+	/**
+	* Tests if two arguments are both single-precision complex floating-point numbers and have the same value.
+	*
+	* ## Notes
+	*
+	* -   The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same.
+	*
+	* @param v1 - first input value
+	* @param v2 - second input value
+	* @returns boolean indicating whether two arguments are the same
+	*
+	* @example
+	* var Complex64 = require( '@stdlib/complex/float32' );
+	*
+	* var x = new Complex64( 1.0, 2.0 );
+	* var y = new Complex64( 1.0, 2.0 );
+	*
+	* var out = ns.isSameComplex64( x, y );
+	* // returns true
+	*
+	* @example
+	* var Complex64 = require( '@stdlib/complex/float32' );
+	*
+	* var x = new Complex64( 1.0, 2.0 );
+	* var y = new Complex64( -1.0, -2.0 );
+	*
+	* var out = ns.isSameComplex64( x, y );
+	* // returns false
+	*/
+	isSameComplex64: typeof isSameComplex64;
+
+	/**
+	* Tests if two arguments are both Complex64Arrays and have the same values.
+	*
+	* ## Notes
+	*
+	* -   The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same.
+	*
+	* @param v1 - first input value
+	* @param v2 - second input value
+	* @returns boolean indicating whether two arguments are the same
+	*
+	* @example
+	* var Complex64Array = require( '@stdlib/array/complex64' );
+	*
+	* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	* var y = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	*
+	* var out = ns.isSameComplex64Array( x, y );
+	* // returns true
+	*
+	* @example
+	* var Complex64Array = require( '@stdlib/array/complex64' );
+	*
+	* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	* var y = new Complex64Array( [ 1.0, 2.0, 4.0, 4.0 ] );
+	*
+	* var out = ns.isSameComplex64Array( x, y );
+	* // returns false
+	*/
+	isSameComplex64Array: typeof isSameComplex64Array;
+
+	/**
+	* Tests if two arguments are both double-precision complex floating-point numbers and have the same value.
+	*
+	* ## Notes
+	*
+	* -   The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same.
+	*
+	* @param v1 - first input value
+	* @param v2 - second input value
+	* @returns boolean indicating whether two arguments are the same
+	*
+	* @example
+	* var Complex128 = require( '@stdlib/complex/float64' );
+	*
+	* var x = new Complex128( 1.0, 2.0 );
+	* var y = new Complex128( 1.0, 2.0 );
+	*
+	* var out = ns.isSameComplex128( x, y );
+	* // returns true
+	*
+	* @example
+	* var Complex128 = require( '@stdlib/complex/float64' );
+	*
+	* var x = new Complex128( 1.0, 2.0 );
+	* var y = new Complex128( -1.0, -2.0 );
+	*
+	* var out = ns.isSameComplex128( x, y );
+	* // returns false
+	*/
+	isSameComplex128: typeof isSameComplex128;
+
+	/**
+	* Tests if two arguments are both Complex128Arrays and have the same values.
+	*
+	* ## Notes
+	*
+	* -   The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same.
+	*
+	* @param v1 - first input value
+	* @param v2 - second input value
+	* @returns boolean indicating whether two arguments are the same
+	*
+	* @example
+	* var Complex128Array = require( '@stdlib/array/complex128' );
+	*
+	* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	*
+	* var out = ns.isSameComplex128Array( x, y );
+	* // returns true
+	*
+	* @example
+	* var Complex128Array = require( '@stdlib/array/complex128' );
+	*
+	* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	* var y = new Complex128Array( [ 1.0, 2.0, 4.0, 4.0 ] );
+	*
+	* var out = ns.isSameComplex128Array( x, y );
+	* // returns false
+	*/
+	isSameComplex128Array: typeof isSameComplex128Array;
+
+	/**
+	* Tests if two arguments are both Float32Arrays and have the same values.
+	*
+	* ## Notes
+	*
+	* -   The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same.
+	*
+	* @param v1 - first input value
+	* @param v2 - second input value
+	* @returns boolean indicating whether two arguments are the same
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array/float32' );
+	*
+	* var x = new Float32Array( [ 1.0, 2.0, 3.0 ] );
+	* var y = new Float32Array( [ 1.0, 2.0, 3.0 ] );
+	*
+	* var out = ns.isSameFloat32Array( x, y );
+	* // returns true
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array/float32' );
+	*
+	* var x = new Float32Array( [ 1.0, 2.0, 3.0 ] );
+	* var y = new Float32Array( [ 1.0, 2.0, 4.0 ] );
+	*
+	* var out = ns.isSameFloat32Array( x, y );
+	* // returns false
+	*/
+	isSameFloat32Array: typeof isSameFloat32Array;
+
+	/**
+	* Tests if two arguments are both Float64Arrays and have the same values.
+	*
+	* ## Notes
+	*
+	* -   The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same.
+	*
+	* @param v1 - first input value
+	* @param v2 - second input value
+	* @returns boolean indicating whether two arguments are the same
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	*
+	* var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
+	* var y = new Float64Array( [ 1.0, 2.0, 3.0 ] );
+	*
+	* var out = ns.isSameFloat64Array( x, y );
+	* // returns true
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	*
+	* var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
+	* var y = new Float64Array( [ 1.0, 2.0, 4.0 ] );
+	*
+	* var out = ns.isSameFloat64Array( x, y );
+	* // returns false
+	*/
+	isSameFloat64Array: typeof isSameFloat64Array;
+
 	/**
 	* Tests if two arguments have the same native class.
 	*