@tsonic/dotnet 10.0.40 → 10.0.42

package/System.Runtime.Intrinsics/internal/index.d.ts

@@ -2,11 +2,9 @@
 // Namespace: System.Runtime.Intrinsics
 // Assembly: System.Private.CoreLib
 
-// Primitive type aliases from @tsonic/core
-import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';
+// Core type aliases from @tsonic/core
+import type { fnptr, ptr, sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';
 
-// Import support types from @tsonic/core
-import type { ptr } from "@tsonic/core/types.js";
 
 // Import types from other namespaces
 import * as System_Numerics_Internal from "../../System.Numerics/internal/index.js";
@@ -14,7 +12,7 @@ import type { IAdditionOperators_3, IBitwiseOperators_3, IDivisionOperators_3, I
 import * as System_Internal from "../../System/internal/index.js";
 import type { Boolean as ClrBoolean, Byte, Double, IEquatable_1, Int16, Int32, Int64, IntPtr, MidpointRounding, Object as ClrObject, ReadOnlySpan_1, SByte, Single, Span_1, String as ClrString, Type, UInt16, UInt32, UInt64, UIntPtr, ValueTuple_2, ValueType, Void } from "../../System/internal/index.js";
 
-export interface Vector128_1$instance<T> extends IAdditionOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IBitwiseOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IDivisionOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IEqualityOperators_3<Vector128_1<T>, Vector128_1<T>, System_Internal.Boolean>, IMultiplyOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IShiftOperators_3<Vector128_1<T>, System_Internal.Int32, Vector128_1<T>>, ISubtractionOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IUnaryNegationOperators_2<Vector128_1<T>, Vector128_1<T>>, IUnaryPlusOperators_2<Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IAdditionOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector128_1<T>, Vector128_1<T>, System_Internal.Boolean>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector128_1<T>, System_Internal.Int32, Vector128_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector128_1<T>, Vector128_1<T>> {
+export interface Vector128_1$instance<T extends unknown> extends IAdditionOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IBitwiseOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IDivisionOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IEqualityOperators_3<Vector128_1<T>, Vector128_1<T>, System_Internal.Boolean>, IMultiplyOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IShiftOperators_3<Vector128_1<T>, System_Internal.Int32, Vector128_1<T>>, ISubtractionOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IUnaryNegationOperators_2<Vector128_1<T>, Vector128_1<T>>, IUnaryPlusOperators_2<Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IAdditionOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector128_1<T>, Vector128_1<T>, System_Internal.Boolean>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector128_1<T>, System_Internal.Int32, Vector128_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector128_1<T>, Vector128_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector128_1<T>, Vector128_1<T>> {
     readonly __tsonic_type_System_Runtime_Intrinsics_Vector128_1: never;
 
     readonly __tsonic_iface_System_IEquatable_1: never;
@@ -28,7 +26,7 @@ export interface Vector128_1$instance<T> extends IAdditionOperators_3<Vector128_
     readonly __tsonic_iface_System_Numerics_IUnaryNegationOperators_2: never;
     readonly __tsonic_iface_System_Numerics_IUnaryPlusOperators_2: never;
 
-    Equals(obj: unknown): boolean;
+    Equals(obj: unknown | null): boolean;
     Equals(other: Vector128_1<T>): boolean;
     GetHashCode(): int;
     ToString(): string;
@@ -36,27 +34,27 @@ export interface Vector128_1$instance<T> extends IAdditionOperators_3<Vector128_
 
 
 export const Vector128_1: {
-    new<T>(): Vector128_1<T>;
-    readonly AllBitsSet: unknown;
+    new<T extends unknown>(): Vector128_1<T>;
+    readonly AllBitsSet: <T extends unknown>() => Vector128_1<T>;
     readonly Count: int;
-    readonly Indices: unknown;
+    readonly Indices: <T extends unknown>() => Vector128_1<T>;
     readonly IsSupported: boolean;
-    readonly One: unknown;
-    readonly Zero: unknown;
+    readonly One: <T extends unknown>() => Vector128_1<T>;
+    readonly Zero: <T extends unknown>() => Vector128_1<T>;
 };
 
 
-export interface __Vector128_1$views<T> {
+export interface __Vector128_1$views<T extends unknown> {
     As_IEquatable_1(): System_Internal.IEquatable_1$instance<Vector128_1<T>>;
 
     // Structural method bridges for numeric interface constraints
     Equals(other: Vector128_1<T>): boolean;
 }
 
-export type Vector128_1<T> = Vector128_1$instance<T> & __Vector128_1$views<T> & { readonly [index: number]: T; };
+export type Vector128_1<T extends unknown> = Vector128_1$instance<T> & __Vector128_1$views<T> & { readonly [index: number]: T; };
 
 
-export interface Vector256_1$instance<T> extends IAdditionOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IBitwiseOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IDivisionOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IEqualityOperators_3<Vector256_1<T>, Vector256_1<T>, System_Internal.Boolean>, IMultiplyOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IShiftOperators_3<Vector256_1<T>, System_Internal.Int32, Vector256_1<T>>, ISubtractionOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IUnaryNegationOperators_2<Vector256_1<T>, Vector256_1<T>>, IUnaryPlusOperators_2<Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IAdditionOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector256_1<T>, Vector256_1<T>, System_Internal.Boolean>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector256_1<T>, System_Internal.Int32, Vector256_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector256_1<T>, Vector256_1<T>> {
+export interface Vector256_1$instance<T extends unknown> extends IAdditionOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IBitwiseOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IDivisionOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IEqualityOperators_3<Vector256_1<T>, Vector256_1<T>, System_Internal.Boolean>, IMultiplyOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IShiftOperators_3<Vector256_1<T>, System_Internal.Int32, Vector256_1<T>>, ISubtractionOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IUnaryNegationOperators_2<Vector256_1<T>, Vector256_1<T>>, IUnaryPlusOperators_2<Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IAdditionOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector256_1<T>, Vector256_1<T>, System_Internal.Boolean>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector256_1<T>, System_Internal.Int32, Vector256_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector256_1<T>, Vector256_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector256_1<T>, Vector256_1<T>> {
     readonly __tsonic_type_System_Runtime_Intrinsics_Vector256_1: never;
 
     readonly __tsonic_iface_System_IEquatable_1: never;
@@ -70,7 +68,7 @@ export interface Vector256_1$instance<T> extends IAdditionOperators_3<Vector256_
     readonly __tsonic_iface_System_Numerics_IUnaryNegationOperators_2: never;
     readonly __tsonic_iface_System_Numerics_IUnaryPlusOperators_2: never;
 
-    Equals(obj: unknown): boolean;
+    Equals(obj: unknown | null): boolean;
     Equals(other: Vector256_1<T>): boolean;
     GetHashCode(): int;
     ToString(): string;
@@ -78,27 +76,27 @@ export interface Vector256_1$instance<T> extends IAdditionOperators_3<Vector256_
 
 
 export const Vector256_1: {
-    new<T>(): Vector256_1<T>;
-    readonly AllBitsSet: unknown;
+    new<T extends unknown>(): Vector256_1<T>;
+    readonly AllBitsSet: <T extends unknown>() => Vector256_1<T>;
     readonly Count: int;
-    readonly Indices: unknown;
+    readonly Indices: <T extends unknown>() => Vector256_1<T>;
     readonly IsSupported: boolean;
-    readonly One: unknown;
-    readonly Zero: unknown;
+    readonly One: <T extends unknown>() => Vector256_1<T>;
+    readonly Zero: <T extends unknown>() => Vector256_1<T>;
 };
 
 
-export interface __Vector256_1$views<T> {
+export interface __Vector256_1$views<T extends unknown> {
     As_IEquatable_1(): System_Internal.IEquatable_1$instance<Vector256_1<T>>;
 
     // Structural method bridges for numeric interface constraints
     Equals(other: Vector256_1<T>): boolean;
 }
 
-export type Vector256_1<T> = Vector256_1$instance<T> & __Vector256_1$views<T> & { readonly [index: number]: T; };
+export type Vector256_1<T extends unknown> = Vector256_1$instance<T> & __Vector256_1$views<T> & { readonly [index: number]: T; };
 
 
-export interface Vector512_1$instance<T> extends IAdditionOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IBitwiseOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IDivisionOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IEqualityOperators_3<Vector512_1<T>, Vector512_1<T>, System_Internal.Boolean>, IMultiplyOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IShiftOperators_3<Vector512_1<T>, System_Internal.Int32, Vector512_1<T>>, ISubtractionOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IUnaryNegationOperators_2<Vector512_1<T>, Vector512_1<T>>, IUnaryPlusOperators_2<Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IAdditionOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector512_1<T>, Vector512_1<T>, System_Internal.Boolean>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector512_1<T>, System_Internal.Int32, Vector512_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector512_1<T>, Vector512_1<T>> {
+export interface Vector512_1$instance<T extends unknown> extends IAdditionOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IBitwiseOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IDivisionOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IEqualityOperators_3<Vector512_1<T>, Vector512_1<T>, System_Internal.Boolean>, IMultiplyOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IShiftOperators_3<Vector512_1<T>, System_Internal.Int32, Vector512_1<T>>, ISubtractionOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IUnaryNegationOperators_2<Vector512_1<T>, Vector512_1<T>>, IUnaryPlusOperators_2<Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IAdditionOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector512_1<T>, Vector512_1<T>, System_Internal.Boolean>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector512_1<T>, System_Internal.Int32, Vector512_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector512_1<T>, Vector512_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector512_1<T>, Vector512_1<T>> {
     readonly __tsonic_type_System_Runtime_Intrinsics_Vector512_1: never;
 
     readonly __tsonic_iface_System_IEquatable_1: never;
@@ -112,7 +110,7 @@ export interface Vector512_1$instance<T> extends IAdditionOperators_3<Vector512_
     readonly __tsonic_iface_System_Numerics_IUnaryNegationOperators_2: never;
     readonly __tsonic_iface_System_Numerics_IUnaryPlusOperators_2: never;
 
-    Equals(obj: unknown): boolean;
+    Equals(obj: unknown | null): boolean;
     Equals(other: Vector512_1<T>): boolean;
     GetHashCode(): int;
     ToString(): string;
@@ -120,27 +118,27 @@ export interface Vector512_1$instance<T> extends IAdditionOperators_3<Vector512_
 
 
 export const Vector512_1: {
-    new<T>(): Vector512_1<T>;
-    readonly AllBitsSet: unknown;
+    new<T extends unknown>(): Vector512_1<T>;
+    readonly AllBitsSet: <T extends unknown>() => Vector512_1<T>;
     readonly Count: int;
-    readonly Indices: unknown;
+    readonly Indices: <T extends unknown>() => Vector512_1<T>;
     readonly IsSupported: boolean;
-    readonly One: unknown;
-    readonly Zero: unknown;
+    readonly One: <T extends unknown>() => Vector512_1<T>;
+    readonly Zero: <T extends unknown>() => Vector512_1<T>;
 };
 
 
-export interface __Vector512_1$views<T> {
+export interface __Vector512_1$views<T extends unknown> {
     As_IEquatable_1(): System_Internal.IEquatable_1$instance<Vector512_1<T>>;
 
     // Structural method bridges for numeric interface constraints
     Equals(other: Vector512_1<T>): boolean;
 }
 
-export type Vector512_1<T> = Vector512_1$instance<T> & __Vector512_1$views<T> & { readonly [index: number]: T; };
+export type Vector512_1<T extends unknown> = Vector512_1$instance<T> & __Vector512_1$views<T> & { readonly [index: number]: T; };
 
 
-export interface Vector64_1$instance<T> extends IAdditionOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IBitwiseOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IDivisionOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IEqualityOperators_3<Vector64_1<T>, Vector64_1<T>, System_Internal.Boolean>, IMultiplyOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IShiftOperators_3<Vector64_1<T>, System_Internal.Int32, Vector64_1<T>>, ISubtractionOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IUnaryNegationOperators_2<Vector64_1<T>, Vector64_1<T>>, IUnaryPlusOperators_2<Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IAdditionOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector64_1<T>, Vector64_1<T>, System_Internal.Boolean>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector64_1<T>, System_Internal.Int32, Vector64_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector64_1<T>, Vector64_1<T>> {
+export interface Vector64_1$instance<T extends unknown> extends IAdditionOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IBitwiseOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IDivisionOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IEqualityOperators_3<Vector64_1<T>, Vector64_1<T>, System_Internal.Boolean>, IMultiplyOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IShiftOperators_3<Vector64_1<T>, System_Internal.Int32, Vector64_1<T>>, ISubtractionOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IUnaryNegationOperators_2<Vector64_1<T>, Vector64_1<T>>, IUnaryPlusOperators_2<Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IAdditionOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IBitwiseOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IDivisionOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IEqualityOperators_3$instance<Vector64_1<T>, Vector64_1<T>, System_Internal.Boolean>, System_Numerics_Internal.IMultiplyOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IShiftOperators_3$instance<Vector64_1<T>, System_Internal.Int32, Vector64_1<T>>, System_Numerics_Internal.ISubtractionOperators_3$instance<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IUnaryNegationOperators_2$instance<Vector64_1<T>, Vector64_1<T>>, System_Numerics_Internal.IUnaryPlusOperators_2$instance<Vector64_1<T>, Vector64_1<T>> {
     readonly __tsonic_type_System_Runtime_Intrinsics_Vector64_1: never;
 
     readonly __tsonic_iface_System_IEquatable_1: never;
@@ -154,7 +152,7 @@ export interface Vector64_1$instance<T> extends IAdditionOperators_3<Vector64_1<
     readonly __tsonic_iface_System_Numerics_IUnaryNegationOperators_2: never;
     readonly __tsonic_iface_System_Numerics_IUnaryPlusOperators_2: never;
 
-    Equals(obj: unknown): boolean;
+    Equals(obj: unknown | null): boolean;
     Equals(other: Vector64_1<T>): boolean;
     GetHashCode(): int;
     ToString(): string;
@@ -162,70 +160,70 @@ export interface Vector64_1$instance<T> extends IAdditionOperators_3<Vector64_1<
 
 
 export const Vector64_1: {
-    new<T>(): Vector64_1<T>;
-    readonly AllBitsSet: unknown;
+    new<T extends unknown>(): Vector64_1<T>;
+    readonly AllBitsSet: <T extends unknown>() => Vector64_1<T>;
     readonly Count: int;
-    readonly Indices: unknown;
+    readonly Indices: <T extends unknown>() => Vector64_1<T>;
     readonly IsSupported: boolean;
-    readonly One: unknown;
-    readonly Zero: unknown;
+    readonly One: <T extends unknown>() => Vector64_1<T>;
+    readonly Zero: <T extends unknown>() => Vector64_1<T>;
 };
 
 
-export interface __Vector64_1$views<T> {
+export interface __Vector64_1$views<T extends unknown> {
     As_IEquatable_1(): System_Internal.IEquatable_1$instance<Vector64_1<T>>;
 
     // Structural method bridges for numeric interface constraints
     Equals(other: Vector64_1<T>): boolean;
 }
 
-export type Vector64_1<T> = Vector64_1$instance<T> & __Vector64_1$views<T> & { readonly [index: number]: T; };
+export type Vector64_1<T extends unknown> = Vector64_1$instance<T> & __Vector64_1$views<T> & { readonly [index: number]: T; };
 
 
 export abstract class Vector128$instance {
     static readonly IsHardwareAccelerated: boolean;
-    static Abs<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static Add<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static AddSaturate<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static All<T>(vector: Vector128_1<T>, value: T): boolean;
-    static AllWhereAllBitsSet<T>(vector: Vector128_1<T>): boolean;
-    static AndNot<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Any<T>(vector: Vector128_1<T>, value: T): boolean;
-    static AnyWhereAllBitsSet<T>(vector: Vector128_1<T>): boolean;
-    static As<TFrom, TTo>(vector: Vector128_1<TFrom>): Vector128_1<TTo>;
-    static AsByte<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.Byte>;
-    static AsDouble<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.Double>;
-    static AsInt16<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.Int16>;
-    static AsInt32<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.Int32>;
-    static AsInt64<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.Int64>;
-    static AsNInt<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.IntPtr>;
-    static AsNUInt<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.UIntPtr>;
+    static Abs<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static Add<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static AddSaturate<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static All<T extends unknown>(vector: Vector128_1<T>, value: T): boolean;
+    static AllWhereAllBitsSet<T extends unknown>(vector: Vector128_1<T>): boolean;
+    static AndNot<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static Any<T extends unknown>(vector: Vector128_1<T>, value: T): boolean;
+    static AnyWhereAllBitsSet<T extends unknown>(vector: Vector128_1<T>): boolean;
+    static As<TFrom extends unknown, TTo extends unknown>(vector: Vector128_1<TFrom>): Vector128_1<TTo>;
+    static AsByte<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.Byte>;
+    static AsDouble<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.Double>;
+    static AsInt16<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.Int16>;
+    static AsInt32<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.Int32>;
+    static AsInt64<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.Int64>;
+    static AsNInt<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.IntPtr>;
+    static AsNUInt<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.UIntPtr>;
     static AsPlane(value: Vector128_1<System_Internal.Single>): Plane;
     static AsQuaternion(value: Vector128_1<System_Internal.Single>): Quaternion;
-    static AsSByte<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.SByte>;
-    static AsSingle<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.Single>;
-    static AsUInt16<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.UInt16>;
-    static AsUInt32<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.UInt32>;
-    static AsUInt64<T>(vector: Vector128_1<T>): Vector128_1<System_Internal.UInt64>;
-    static AsVector<T>(value: Vector128_1<T>): Vector_1<T>;
+    static AsSByte<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.SByte>;
+    static AsSingle<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.Single>;
+    static AsUInt16<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.UInt16>;
+    static AsUInt32<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.UInt32>;
+    static AsUInt64<T extends unknown>(vector: Vector128_1<T>): Vector128_1<System_Internal.UInt64>;
+    static AsVector<T extends unknown>(value: Vector128_1<T>): Vector_1<T>;
     static AsVector128(value: Plane): Vector128_1<System_Internal.Single>;
     static AsVector128(value: Quaternion): Vector128_1<System_Internal.Single>;
     static AsVector128(value: Vector2): Vector128_1<System_Internal.Single>;
     static AsVector128(value: Vector3): Vector128_1<System_Internal.Single>;
     static AsVector128(value: Vector4): Vector128_1<System_Internal.Single>;
-    static AsVector128<T>(value: Vector_1<T>): Vector128_1<T>;
+    static AsVector128<T extends unknown>(value: Vector_1<T>): Vector128_1<T>;
     static AsVector128Unsafe(value: Vector2): Vector128_1<System_Internal.Single>;
     static AsVector128Unsafe(value: Vector3): Vector128_1<System_Internal.Single>;
     static AsVector2(value: Vector128_1<System_Internal.Single>): Vector2;
     static AsVector3(value: Vector128_1<System_Internal.Single>): Vector3;
     static AsVector4(value: Vector128_1<System_Internal.Single>): Vector4;
-    static BitwiseAnd<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static BitwiseOr<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static BitwiseAnd<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static BitwiseOr<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
     static Ceiling(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static Ceiling(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
-    static Clamp<T>(value: Vector128_1<T>, min: Vector128_1<T>, max: Vector128_1<T>): Vector128_1<T>;
-    static ClampNative<T>(value: Vector128_1<T>, min: Vector128_1<T>, max: Vector128_1<T>): Vector128_1<T>;
-    static ConditionalSelect<T>(condition: Vector128_1<T>, left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static Clamp<T extends unknown>(value: Vector128_1<T>, min: Vector128_1<T>, max: Vector128_1<T>): Vector128_1<T>;
+    static ClampNative<T extends unknown>(value: Vector128_1<T>, min: Vector128_1<T>, max: Vector128_1<T>): Vector128_1<T>;
+    static ConditionalSelect<T extends unknown>(condition: Vector128_1<T>, left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
     static ConvertToDouble(vector: Vector128_1<System_Internal.Int64>): Vector128_1<System_Internal.Double>;
     static ConvertToDouble(vector: Vector128_1<System_Internal.UInt64>): Vector128_1<System_Internal.Double>;
     static ConvertToInt32(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Int32>;
@@ -238,15 +236,15 @@ export abstract class Vector128$instance {
     static ConvertToUInt32Native(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.UInt32>;
     static ConvertToUInt64(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.UInt64>;
     static ConvertToUInt64Native(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.UInt64>;
-    static CopySign<T>(value: Vector128_1<T>, sign: Vector128_1<T>): Vector128_1<T>;
-    static CopyTo<T>(vector: Vector128_1<T>, destination: Span_1<T>): void;
-    static CopyTo<T>(vector: Vector128_1<T>, destination: T[], startIndex: int): void;
-    static CopyTo<T>(vector: Vector128_1<T>, destination: T[]): void;
+    static CopySign<T extends unknown>(value: Vector128_1<T>, sign: Vector128_1<T>): Vector128_1<T>;
+    static CopyTo<T extends unknown>(vector: Vector128_1<T>, destination: Span_1<T>): void;
+    static CopyTo<T extends unknown>(vector: Vector128_1<T>, destination: T[], startIndex: int): void;
+    static CopyTo<T extends unknown>(vector: Vector128_1<T>, destination: T[]): void;
     static Cos(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static Cos(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
-    static Count<T>(vector: Vector128_1<T>, value: T): int;
-    static CountWhereAllBitsSet<T>(vector: Vector128_1<T>): int;
-    static Create<T>(values: ReadOnlySpan_1<T>): Vector128_1<T>;
+    static Count<T extends unknown>(vector: Vector128_1<T>, value: T): int;
+    static CountWhereAllBitsSet<T extends unknown>(vector: Vector128_1<T>): int;
+    static Create<T extends unknown>(values: ReadOnlySpan_1<T>): Vector128_1<T>;
     static Create(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte, e8: byte, e9: byte, e10: byte, e11: byte, e12: byte, e13: byte, e14: byte, e15: byte): Vector128_1<System_Internal.Byte>;
     static Create(value: byte): Vector128_1<System_Internal.Byte>;
     static Create(e0: double, e1: double): Vector128_1<System_Internal.Double>;
@@ -281,11 +279,11 @@ export abstract class Vector128$instance {
     static Create(e0: ulong, e1: ulong): Vector128_1<System_Internal.UInt64>;
     static Create(value: ulong): Vector128_1<System_Internal.UInt64>;
     static Create(value: nuint): Vector128_1<System_Internal.UIntPtr>;
-    static Create<T>(value: T): Vector128_1<T>;
-    static Create<T>(values: T[], index: int): Vector128_1<T>;
-    static Create<T>(values: T[]): Vector128_1<T>;
-    static Create<T>(lower: Vector64_1<T>, upper: Vector64_1<T>): Vector128_1<T>;
-    static Create<T>(value: Vector64_1<T>): Vector128_1<T>;
+    static Create<T extends unknown>(value: T): Vector128_1<T>;
+    static Create<T extends unknown>(values: T[], index: int): Vector128_1<T>;
+    static Create<T extends unknown>(values: T[]): Vector128_1<T>;
+    static Create<T extends unknown>(lower: Vector64_1<T>, upper: Vector64_1<T>): Vector128_1<T>;
+    static Create<T extends unknown>(value: Vector64_1<T>): Vector128_1<T>;
     static CreateScalar(value: byte): Vector128_1<System_Internal.Byte>;
     static CreateScalar(value: double): Vector128_1<System_Internal.Double>;
     static CreateScalar(value: short): Vector128_1<System_Internal.Int16>;
@@ -298,7 +296,7 @@ export abstract class Vector128$instance {
     static CreateScalar(value: uint): Vector128_1<System_Internal.UInt32>;
     static CreateScalar(value: ulong): Vector128_1<System_Internal.UInt64>;
     static CreateScalar(value: nuint): Vector128_1<System_Internal.UIntPtr>;
-    static CreateScalar<T>(value: T): Vector128_1<T>;
+    static CreateScalar<T extends unknown>(value: T): Vector128_1<T>;
     static CreateScalarUnsafe(value: byte): Vector128_1<System_Internal.Byte>;
     static CreateScalarUnsafe(value: double): Vector128_1<System_Internal.Double>;
     static CreateScalarUnsafe(value: short): Vector128_1<System_Internal.Int16>;
@@ -311,81 +309,81 @@ export abstract class Vector128$instance {
     static CreateScalarUnsafe(value: uint): Vector128_1<System_Internal.UInt32>;
     static CreateScalarUnsafe(value: ulong): Vector128_1<System_Internal.UInt64>;
     static CreateScalarUnsafe(value: nuint): Vector128_1<System_Internal.UIntPtr>;
-    static CreateScalarUnsafe<T>(value: T): Vector128_1<T>;
-    static CreateSequence<T>(start: T, step: T): Vector128_1<T>;
+    static CreateScalarUnsafe<T extends unknown>(value: T): Vector128_1<T>;
+    static CreateSequence<T extends unknown>(start: T, step: T): Vector128_1<T>;
     static DegreesToRadians(degrees: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static DegreesToRadians(degrees: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
-    static Divide<T>(left: Vector128_1<T>, right: T): Vector128_1<T>;
-    static Divide<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Dot<T>(left: Vector128_1<T>, right: Vector128_1<T>): T;
-    static Equals<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static EqualsAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static EqualsAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static Divide<T extends unknown>(left: Vector128_1<T>, right: T): Vector128_1<T>;
+    static Divide<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static Dot<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): T;
+    static Equals<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static EqualsAll<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static EqualsAny<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
     static Exp(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static Exp(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
-    static ExtractMostSignificantBits<T>(vector: Vector128_1<T>): uint;
+    static ExtractMostSignificantBits<T extends unknown>(vector: Vector128_1<T>): uint;
     static Floor(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static Floor(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
     static FusedMultiplyAdd(left: Vector128_1<System_Internal.Double>, right: Vector128_1<System_Internal.Double>, addend: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static FusedMultiplyAdd(left: Vector128_1<System_Internal.Single>, right: Vector128_1<System_Internal.Single>, addend: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
-    static GetElement<T>(vector: Vector128_1<T>, index: int): T;
-    static GetLower<T>(vector: Vector128_1<T>): Vector64_1<T>;
-    static GetUpper<T>(vector: Vector128_1<T>): Vector64_1<T>;
-    static GreaterThan<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static GreaterThanAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static GreaterThanAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static GreaterThanOrEqual<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static GreaterThanOrEqualAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static GreaterThanOrEqualAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static GetElement<T extends unknown>(vector: Vector128_1<T>, index: int): T;
+    static GetLower<T extends unknown>(vector: Vector128_1<T>): Vector64_1<T>;
+    static GetUpper<T extends unknown>(vector: Vector128_1<T>): Vector64_1<T>;
+    static GreaterThan<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static GreaterThanAll<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static GreaterThanAny<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static GreaterThanOrEqual<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static GreaterThanOrEqualAll<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static GreaterThanOrEqualAny<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
     static Hypot(x: Vector128_1<System_Internal.Double>, y: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static Hypot(x: Vector128_1<System_Internal.Single>, y: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
-    static IndexOf<T>(vector: Vector128_1<T>, value: T): int;
-    static IndexOfWhereAllBitsSet<T>(vector: Vector128_1<T>): int;
-    static IsEvenInteger<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsFinite<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsInfinity<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsInteger<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsNaN<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsNegative<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsNegativeInfinity<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsNormal<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsOddInteger<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsPositive<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsPositiveInfinity<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsSubnormal<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static IsZero<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static LastIndexOf<T>(vector: Vector128_1<T>, value: T): int;
-    static LastIndexOfWhereAllBitsSet<T>(vector: Vector128_1<T>): int;
+    static IndexOf<T extends unknown>(vector: Vector128_1<T>, value: T): int;
+    static IndexOfWhereAllBitsSet<T extends unknown>(vector: Vector128_1<T>): int;
+    static IsEvenInteger<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsFinite<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsInfinity<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsInteger<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsNaN<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsNegative<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsNegativeInfinity<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsNormal<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsOddInteger<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsPositive<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsPositiveInfinity<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsSubnormal<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static IsZero<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static LastIndexOf<T extends unknown>(vector: Vector128_1<T>, value: T): int;
+    static LastIndexOfWhereAllBitsSet<T extends unknown>(vector: Vector128_1<T>): int;
     static Lerp(x: Vector128_1<System_Internal.Double>, y: Vector128_1<System_Internal.Double>, amount: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static Lerp(x: Vector128_1<System_Internal.Single>, y: Vector128_1<System_Internal.Single>, amount: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
-    static LessThan<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static LessThanAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static LessThanAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static LessThanOrEqual<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static LessThanOrEqualAll<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static LessThanOrEqualAny<T>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
-    static Load<T>(source: ptr<T>): Vector128_1<T>;
-    static LoadAligned<T>(source: ptr<T>): Vector128_1<T>;
-    static LoadAlignedNonTemporal<T>(source: ptr<T>): Vector128_1<T>;
-    static LoadUnsafe<T>(source: T, elementOffset: nuint): Vector128_1<T>;
-    static LoadUnsafe<T>(source: T): Vector128_1<T>;
+    static LessThan<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static LessThanAll<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static LessThanAny<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static LessThanOrEqual<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static LessThanOrEqualAll<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static LessThanOrEqualAny<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): boolean;
+    static Load<T extends unknown>(source: ptr<T>): Vector128_1<T>;
+    static LoadAligned<T extends unknown>(source: ptr<T>): Vector128_1<T>;
+    static LoadAlignedNonTemporal<T extends unknown>(source: ptr<T>): Vector128_1<T>;
+    static LoadUnsafe<T extends unknown>(source: T, elementOffset: nuint): Vector128_1<T>;
+    static LoadUnsafe<T extends unknown>(source: T): Vector128_1<T>;
     static Log(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static Log(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
     static Log2(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static Log2(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
-    static Max<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MaxMagnitude<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MaxMagnitudeNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MaxNative<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MaxNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Min<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MinMagnitude<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MinMagnitudeNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MinNative<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static MinNumber<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Multiply<T>(left: T, right: Vector128_1<T>): Vector128_1<T>;
-    static Multiply<T>(left: Vector128_1<T>, right: T): Vector128_1<T>;
-    static Multiply<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static Max<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static MaxMagnitude<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static MaxMagnitudeNumber<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static MaxNative<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static MaxNumber<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static Min<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static MinMagnitude<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static MinMagnitudeNumber<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static MinNative<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static MinNumber<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static Multiply<T extends unknown>(left: T, right: Vector128_1<T>): Vector128_1<T>;
+    static Multiply<T extends unknown>(left: Vector128_1<T>, right: T): Vector128_1<T>;
+    static Multiply<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
     static MultiplyAddEstimate(left: Vector128_1<System_Internal.Double>, right: Vector128_1<System_Internal.Double>, addend: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static MultiplyAddEstimate(left: Vector128_1<System_Internal.Single>, right: Vector128_1<System_Internal.Single>, addend: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
     static Narrow(lower: Vector128_1<System_Internal.Double>, upper: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Single>;
@@ -402,10 +400,10 @@ export abstract class Vector128$instance {
     static NarrowWithSaturation(lower: Vector128_1<System_Internal.UInt16>, upper: Vector128_1<System_Internal.UInt16>): Vector128_1<System_Internal.Byte>;
     static NarrowWithSaturation(lower: Vector128_1<System_Internal.UInt32>, upper: Vector128_1<System_Internal.UInt32>): Vector128_1<System_Internal.UInt16>;
     static NarrowWithSaturation(lower: Vector128_1<System_Internal.UInt64>, upper: Vector128_1<System_Internal.UInt64>): Vector128_1<System_Internal.UInt32>;
-    static Negate<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static None<T>(vector: Vector128_1<T>, value: T): boolean;
-    static NoneWhereAllBitsSet<T>(vector: Vector128_1<T>): boolean;
-    static OnesComplement<T>(vector: Vector128_1<T>): Vector128_1<T>;
+    static Negate<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static None<T extends unknown>(vector: Vector128_1<T>, value: T): boolean;
+    static NoneWhereAllBitsSet<T extends unknown>(vector: Vector128_1<T>): boolean;
+    static OnesComplement<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
     static RadiansToDegrees(radians: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static RadiansToDegrees(radians: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
     static Round(vector: Vector128_1<System_Internal.Double>, mode: MidpointRounding): Vector128_1<System_Internal.Double>;
@@ -461,21 +459,21 @@ export abstract class Vector128$instance {
     static Sin(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
     static SinCos(vector: Vector128_1<System_Internal.Double>): ValueTuple_2<Vector128_1<System_Internal.Double>, Vector128_1<System_Internal.Double>>;
     static SinCos(vector: Vector128_1<System_Internal.Single>): ValueTuple_2<Vector128_1<System_Internal.Single>, Vector128_1<System_Internal.Single>>;
-    static Sqrt<T>(vector: Vector128_1<T>): Vector128_1<T>;
-    static Store<T>(source: Vector128_1<T>, destination: ptr<T>): void;
-    static StoreAligned<T>(source: Vector128_1<T>, destination: ptr<T>): void;
-    static StoreAlignedNonTemporal<T>(source: Vector128_1<T>, destination: ptr<T>): void;
-    static StoreUnsafe<T>(source: Vector128_1<T>, destination: T, elementOffset: nuint): void;
-    static StoreUnsafe<T>(source: Vector128_1<T>, destination: T): void;
-    static Subtract<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static SubtractSaturate<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
-    static Sum<T>(vector: Vector128_1<T>): T;
-    static ToScalar<T>(vector: Vector128_1<T>): T;
-    static ToVector256<T>(vector: Vector128_1<T>): Vector256_1<T>;
-    static ToVector256Unsafe<T>(vector: Vector128_1<T>): Vector256_1<T>;
+    static Sqrt<T extends unknown>(vector: Vector128_1<T>): Vector128_1<T>;
+    static Store<T extends unknown>(source: Vector128_1<T>, destination: ptr<T>): void;
+    static StoreAligned<T extends unknown>(source: Vector128_1<T>, destination: ptr<T>): void;
+    static StoreAlignedNonTemporal<T extends unknown>(source: Vector128_1<T>, destination: ptr<T>): void;
+    static StoreUnsafe<T extends unknown>(source: Vector128_1<T>, destination: T, elementOffset: nuint): void;
+    static StoreUnsafe<T extends unknown>(source: Vector128_1<T>, destination: T): void;
+    static Subtract<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static SubtractSaturate<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static Sum<T extends unknown>(vector: Vector128_1<T>): T;
+    static ToScalar<T extends unknown>(vector: Vector128_1<T>): T;
+    static ToVector256<T extends unknown>(vector: Vector128_1<T>): Vector256_1<T>;
+    static ToVector256Unsafe<T extends unknown>(vector: Vector128_1<T>): Vector256_1<T>;
     static Truncate(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
     static Truncate(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
-    static TryCopyTo<T>(vector: Vector128_1<T>, destination: Span_1<T>): boolean;
+    static TryCopyTo<T extends unknown>(vector: Vector128_1<T>, destination: Span_1<T>): boolean;
     static Widen(source: Vector128_1<System_Internal.Byte>): ValueTuple_2<Vector128_1<System_Internal.UInt16>, Vector128_1<System_Internal.UInt16>>;
     static Widen(source: Vector128_1<System_Internal.Int16>): ValueTuple_2<Vector128_1<System_Internal.Int32>, Vector128_1<System_Internal.Int32>>;
     static Widen(source: Vector128_1<System_Internal.Int32>): ValueTuple_2<Vector128_1<System_Internal.Int64>, Vector128_1<System_Internal.Int64>>;
@@ -497,10 +495,10 @@ export abstract class Vector128$instance {
     static WidenUpper(source: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Double>;
     static WidenUpper(source: Vector128_1<System_Internal.UInt16>): Vector128_1<System_Internal.UInt32>;
     static WidenUpper(source: Vector128_1<System_Internal.UInt32>): Vector128_1<System_Internal.UInt64>;
-    static WithElement<T>(vector: Vector128_1<T>, index: int, value: T): Vector128_1<T>;
-    static WithLower<T>(vector: Vector128_1<T>, value: Vector64_1<T>): Vector128_1<T>;
-    static WithUpper<T>(vector: Vector128_1<T>, value: Vector64_1<T>): Vector128_1<T>;
-    static Xor<T>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
+    static WithElement<T extends unknown>(vector: Vector128_1<T>, index: int, value: T): Vector128_1<T>;
+    static WithLower<T extends unknown>(vector: Vector128_1<T>, value: Vector64_1<T>): Vector128_1<T>;
+    static WithUpper<T extends unknown>(vector: Vector128_1<T>, value: Vector64_1<T>): Vector128_1<T>;
+    static Xor<T extends unknown>(left: Vector128_1<T>, right: Vector128_1<T>): Vector128_1<T>;
 }
 
 
@@ -508,36 +506,36 @@ export type Vector128 = Vector128$instance;
 
 export abstract class Vector256$instance {
     static readonly IsHardwareAccelerated: boolean;
-    static Abs<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static Add<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static AddSaturate<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static All<T>(vector: Vector256_1<T>, value: T): boolean;
-    static AllWhereAllBitsSet<T>(vector: Vector256_1<T>): boolean;
-    static AndNot<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Any<T>(vector: Vector256_1<T>, value: T): boolean;
-    static AnyWhereAllBitsSet<T>(vector: Vector256_1<T>): boolean;
-    static As<TFrom, TTo>(vector: Vector256_1<TFrom>): Vector256_1<TTo>;
-    static AsByte<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.Byte>;
-    static AsDouble<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.Double>;
-    static AsInt16<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.Int16>;
-    static AsInt32<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.Int32>;
-    static AsInt64<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.Int64>;
-    static AsNInt<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.IntPtr>;
-    static AsNUInt<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.UIntPtr>;
-    static AsSByte<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.SByte>;
-    static AsSingle<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.Single>;
-    static AsUInt16<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.UInt16>;
-    static AsUInt32<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.UInt32>;
-    static AsUInt64<T>(vector: Vector256_1<T>): Vector256_1<System_Internal.UInt64>;
-    static AsVector<T>(value: Vector256_1<T>): Vector_1<T>;
-    static AsVector256<T>(value: Vector_1<T>): Vector256_1<T>;
-    static BitwiseAnd<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static BitwiseOr<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static Abs<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static Add<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static AddSaturate<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static All<T extends unknown>(vector: Vector256_1<T>, value: T): boolean;
+    static AllWhereAllBitsSet<T extends unknown>(vector: Vector256_1<T>): boolean;
+    static AndNot<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static Any<T extends unknown>(vector: Vector256_1<T>, value: T): boolean;
+    static AnyWhereAllBitsSet<T extends unknown>(vector: Vector256_1<T>): boolean;
+    static As<TFrom extends unknown, TTo extends unknown>(vector: Vector256_1<TFrom>): Vector256_1<TTo>;
+    static AsByte<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.Byte>;
+    static AsDouble<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.Double>;
+    static AsInt16<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.Int16>;
+    static AsInt32<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.Int32>;
+    static AsInt64<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.Int64>;
+    static AsNInt<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.IntPtr>;
+    static AsNUInt<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.UIntPtr>;
+    static AsSByte<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.SByte>;
+    static AsSingle<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.Single>;
+    static AsUInt16<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.UInt16>;
+    static AsUInt32<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.UInt32>;
+    static AsUInt64<T extends unknown>(vector: Vector256_1<T>): Vector256_1<System_Internal.UInt64>;
+    static AsVector<T extends unknown>(value: Vector256_1<T>): Vector_1<T>;
+    static AsVector256<T extends unknown>(value: Vector_1<T>): Vector256_1<T>;
+    static BitwiseAnd<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static BitwiseOr<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
     static Ceiling(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static Ceiling(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
-    static Clamp<T>(value: Vector256_1<T>, min: Vector256_1<T>, max: Vector256_1<T>): Vector256_1<T>;
-    static ClampNative<T>(value: Vector256_1<T>, min: Vector256_1<T>, max: Vector256_1<T>): Vector256_1<T>;
-    static ConditionalSelect<T>(condition: Vector256_1<T>, left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static Clamp<T extends unknown>(value: Vector256_1<T>, min: Vector256_1<T>, max: Vector256_1<T>): Vector256_1<T>;
+    static ClampNative<T extends unknown>(value: Vector256_1<T>, min: Vector256_1<T>, max: Vector256_1<T>): Vector256_1<T>;
+    static ConditionalSelect<T extends unknown>(condition: Vector256_1<T>, left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
     static ConvertToDouble(vector: Vector256_1<System_Internal.Int64>): Vector256_1<System_Internal.Double>;
     static ConvertToDouble(vector: Vector256_1<System_Internal.UInt64>): Vector256_1<System_Internal.Double>;
     static ConvertToInt32(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Int32>;
@@ -550,15 +548,15 @@ export abstract class Vector256$instance {
     static ConvertToUInt32Native(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.UInt32>;
     static ConvertToUInt64(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.UInt64>;
     static ConvertToUInt64Native(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.UInt64>;
-    static CopySign<T>(value: Vector256_1<T>, sign: Vector256_1<T>): Vector256_1<T>;
-    static CopyTo<T>(vector: Vector256_1<T>, destination: Span_1<T>): void;
-    static CopyTo<T>(vector: Vector256_1<T>, destination: T[], startIndex: int): void;
-    static CopyTo<T>(vector: Vector256_1<T>, destination: T[]): void;
+    static CopySign<T extends unknown>(value: Vector256_1<T>, sign: Vector256_1<T>): Vector256_1<T>;
+    static CopyTo<T extends unknown>(vector: Vector256_1<T>, destination: Span_1<T>): void;
+    static CopyTo<T extends unknown>(vector: Vector256_1<T>, destination: T[], startIndex: int): void;
+    static CopyTo<T extends unknown>(vector: Vector256_1<T>, destination: T[]): void;
     static Cos(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static Cos(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
-    static Count<T>(vector: Vector256_1<T>, value: T): int;
-    static CountWhereAllBitsSet<T>(vector: Vector256_1<T>): int;
-    static Create<T>(values: ReadOnlySpan_1<T>): Vector256_1<T>;
+    static Count<T extends unknown>(vector: Vector256_1<T>, value: T): int;
+    static CountWhereAllBitsSet<T extends unknown>(vector: Vector256_1<T>): int;
+    static Create<T extends unknown>(values: ReadOnlySpan_1<T>): Vector256_1<T>;
     static Create(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte, e8: byte, e9: byte, e10: byte, e11: byte, e12: byte, e13: byte, e14: byte, e15: byte, e16: byte, e17: byte, e18: byte, e19: byte, e20: byte, e21: byte, e22: byte, e23: byte, e24: byte, e25: byte, e26: byte, e27: byte, e28: byte, e29: byte, e30: byte, e31: byte): Vector256_1<System_Internal.Byte>;
     static Create(value: byte): Vector256_1<System_Internal.Byte>;
     static Create(e0: double, e1: double, e2: double, e3: double): Vector256_1<System_Internal.Double>;
@@ -593,12 +591,12 @@ export abstract class Vector256$instance {
     static Create(e0: ulong, e1: ulong, e2: ulong, e3: ulong): Vector256_1<System_Internal.UInt64>;
     static Create(value: ulong): Vector256_1<System_Internal.UInt64>;
     static Create(value: nuint): Vector256_1<System_Internal.UIntPtr>;
-    static Create<T>(value: T): Vector256_1<T>;
-    static Create<T>(values: T[], index: int): Vector256_1<T>;
-    static Create<T>(values: T[]): Vector256_1<T>;
-    static Create<T>(lower: Vector128_1<T>, upper: Vector128_1<T>): Vector256_1<T>;
-    static Create<T>(value: Vector128_1<T>): Vector256_1<T>;
-    static Create<T>(value: Vector64_1<T>): Vector256_1<T>;
+    static Create<T extends unknown>(value: T): Vector256_1<T>;
+    static Create<T extends unknown>(values: T[], index: int): Vector256_1<T>;
+    static Create<T extends unknown>(values: T[]): Vector256_1<T>;
+    static Create<T extends unknown>(lower: Vector128_1<T>, upper: Vector128_1<T>): Vector256_1<T>;
+    static Create<T extends unknown>(value: Vector128_1<T>): Vector256_1<T>;
+    static Create<T extends unknown>(value: Vector64_1<T>): Vector256_1<T>;
     static CreateScalar(value: byte): Vector256_1<System_Internal.Byte>;
     static CreateScalar(value: double): Vector256_1<System_Internal.Double>;
     static CreateScalar(value: short): Vector256_1<System_Internal.Int16>;
@@ -611,7 +609,7 @@ export abstract class Vector256$instance {
     static CreateScalar(value: uint): Vector256_1<System_Internal.UInt32>;
     static CreateScalar(value: ulong): Vector256_1<System_Internal.UInt64>;
     static CreateScalar(value: nuint): Vector256_1<System_Internal.UIntPtr>;
-    static CreateScalar<T>(value: T): Vector256_1<T>;
+    static CreateScalar<T extends unknown>(value: T): Vector256_1<T>;
     static CreateScalarUnsafe(value: byte): Vector256_1<System_Internal.Byte>;
     static CreateScalarUnsafe(value: double): Vector256_1<System_Internal.Double>;
     static CreateScalarUnsafe(value: short): Vector256_1<System_Internal.Int16>;
@@ -624,81 +622,81 @@ export abstract class Vector256$instance {
     static CreateScalarUnsafe(value: uint): Vector256_1<System_Internal.UInt32>;
     static CreateScalarUnsafe(value: ulong): Vector256_1<System_Internal.UInt64>;
     static CreateScalarUnsafe(value: nuint): Vector256_1<System_Internal.UIntPtr>;
-    static CreateScalarUnsafe<T>(value: T): Vector256_1<T>;
-    static CreateSequence<T>(start: T, step: T): Vector256_1<T>;
+    static CreateScalarUnsafe<T extends unknown>(value: T): Vector256_1<T>;
+    static CreateSequence<T extends unknown>(start: T, step: T): Vector256_1<T>;
     static DegreesToRadians(degrees: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static DegreesToRadians(degrees: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
-    static Divide<T>(left: Vector256_1<T>, right: T): Vector256_1<T>;
-    static Divide<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Dot<T>(left: Vector256_1<T>, right: Vector256_1<T>): T;
-    static Equals<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static EqualsAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static EqualsAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static Divide<T extends unknown>(left: Vector256_1<T>, right: T): Vector256_1<T>;
+    static Divide<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static Dot<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): T;
+    static Equals<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static EqualsAll<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static EqualsAny<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
     static Exp(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static Exp(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
-    static ExtractMostSignificantBits<T>(vector: Vector256_1<T>): uint;
+    static ExtractMostSignificantBits<T extends unknown>(vector: Vector256_1<T>): uint;
     static Floor(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static Floor(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
     static FusedMultiplyAdd(left: Vector256_1<System_Internal.Double>, right: Vector256_1<System_Internal.Double>, addend: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static FusedMultiplyAdd(left: Vector256_1<System_Internal.Single>, right: Vector256_1<System_Internal.Single>, addend: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
-    static GetElement<T>(vector: Vector256_1<T>, index: int): T;
-    static GetLower<T>(vector: Vector256_1<T>): Vector128_1<T>;
-    static GetUpper<T>(vector: Vector256_1<T>): Vector128_1<T>;
-    static GreaterThan<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static GreaterThanAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static GreaterThanAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static GreaterThanOrEqual<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static GreaterThanOrEqualAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static GreaterThanOrEqualAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static GetElement<T extends unknown>(vector: Vector256_1<T>, index: int): T;
+    static GetLower<T extends unknown>(vector: Vector256_1<T>): Vector128_1<T>;
+    static GetUpper<T extends unknown>(vector: Vector256_1<T>): Vector128_1<T>;
+    static GreaterThan<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static GreaterThanAll<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static GreaterThanAny<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static GreaterThanOrEqual<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static GreaterThanOrEqualAll<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static GreaterThanOrEqualAny<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
     static Hypot(x: Vector256_1<System_Internal.Double>, y: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static Hypot(x: Vector256_1<System_Internal.Single>, y: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
-    static IndexOf<T>(vector: Vector256_1<T>, value: T): int;
-    static IndexOfWhereAllBitsSet<T>(vector: Vector256_1<T>): int;
-    static IsEvenInteger<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsFinite<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsInfinity<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsInteger<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsNaN<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsNegative<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsNegativeInfinity<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsNormal<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsOddInteger<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsPositive<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsPositiveInfinity<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsSubnormal<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static IsZero<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static LastIndexOf<T>(vector: Vector256_1<T>, value: T): int;
-    static LastIndexOfWhereAllBitsSet<T>(vector: Vector256_1<T>): int;
+    static IndexOf<T extends unknown>(vector: Vector256_1<T>, value: T): int;
+    static IndexOfWhereAllBitsSet<T extends unknown>(vector: Vector256_1<T>): int;
+    static IsEvenInteger<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsFinite<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsInfinity<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsInteger<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsNaN<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsNegative<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsNegativeInfinity<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsNormal<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsOddInteger<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsPositive<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsPositiveInfinity<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsSubnormal<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static IsZero<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static LastIndexOf<T extends unknown>(vector: Vector256_1<T>, value: T): int;
+    static LastIndexOfWhereAllBitsSet<T extends unknown>(vector: Vector256_1<T>): int;
     static Lerp(x: Vector256_1<System_Internal.Double>, y: Vector256_1<System_Internal.Double>, amount: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static Lerp(x: Vector256_1<System_Internal.Single>, y: Vector256_1<System_Internal.Single>, amount: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
-    static LessThan<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static LessThanAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static LessThanAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static LessThanOrEqual<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static LessThanOrEqualAll<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static LessThanOrEqualAny<T>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
-    static Load<T>(source: ptr<T>): Vector256_1<T>;
-    static LoadAligned<T>(source: ptr<T>): Vector256_1<T>;
-    static LoadAlignedNonTemporal<T>(source: ptr<T>): Vector256_1<T>;
-    static LoadUnsafe<T>(source: T, elementOffset: nuint): Vector256_1<T>;
-    static LoadUnsafe<T>(source: T): Vector256_1<T>;
+    static LessThan<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static LessThanAll<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static LessThanAny<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static LessThanOrEqual<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static LessThanOrEqualAll<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static LessThanOrEqualAny<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): boolean;
+    static Load<T extends unknown>(source: ptr<T>): Vector256_1<T>;
+    static LoadAligned<T extends unknown>(source: ptr<T>): Vector256_1<T>;
+    static LoadAlignedNonTemporal<T extends unknown>(source: ptr<T>): Vector256_1<T>;
+    static LoadUnsafe<T extends unknown>(source: T, elementOffset: nuint): Vector256_1<T>;
+    static LoadUnsafe<T extends unknown>(source: T): Vector256_1<T>;
     static Log(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static Log(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
     static Log2(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static Log2(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
-    static Max<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MaxMagnitude<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MaxMagnitudeNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MaxNative<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MaxNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Min<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MinMagnitude<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MinMagnitudeNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MinNative<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static MinNumber<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Multiply<T>(left: T, right: Vector256_1<T>): Vector256_1<T>;
-    static Multiply<T>(left: Vector256_1<T>, right: T): Vector256_1<T>;
-    static Multiply<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static Max<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static MaxMagnitude<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static MaxMagnitudeNumber<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static MaxNative<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static MaxNumber<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static Min<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static MinMagnitude<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static MinMagnitudeNumber<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static MinNative<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static MinNumber<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static Multiply<T extends unknown>(left: T, right: Vector256_1<T>): Vector256_1<T>;
+    static Multiply<T extends unknown>(left: Vector256_1<T>, right: T): Vector256_1<T>;
+    static Multiply<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
     static MultiplyAddEstimate(left: Vector256_1<System_Internal.Double>, right: Vector256_1<System_Internal.Double>, addend: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static MultiplyAddEstimate(left: Vector256_1<System_Internal.Single>, right: Vector256_1<System_Internal.Single>, addend: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
     static Narrow(lower: Vector256_1<System_Internal.Double>, upper: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Single>;
@@ -715,10 +713,10 @@ export abstract class Vector256$instance {
     static NarrowWithSaturation(lower: Vector256_1<System_Internal.UInt16>, upper: Vector256_1<System_Internal.UInt16>): Vector256_1<System_Internal.Byte>;
     static NarrowWithSaturation(lower: Vector256_1<System_Internal.UInt32>, upper: Vector256_1<System_Internal.UInt32>): Vector256_1<System_Internal.UInt16>;
     static NarrowWithSaturation(lower: Vector256_1<System_Internal.UInt64>, upper: Vector256_1<System_Internal.UInt64>): Vector256_1<System_Internal.UInt32>;
-    static Negate<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static None<T>(vector: Vector256_1<T>, value: T): boolean;
-    static NoneWhereAllBitsSet<T>(vector: Vector256_1<T>): boolean;
-    static OnesComplement<T>(vector: Vector256_1<T>): Vector256_1<T>;
+    static Negate<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static None<T extends unknown>(vector: Vector256_1<T>, value: T): boolean;
+    static NoneWhereAllBitsSet<T extends unknown>(vector: Vector256_1<T>): boolean;
+    static OnesComplement<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
     static RadiansToDegrees(radians: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static RadiansToDegrees(radians: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
     static Round(vector: Vector256_1<System_Internal.Double>, mode: MidpointRounding): Vector256_1<System_Internal.Double>;
@@ -774,21 +772,21 @@ export abstract class Vector256$instance {
     static Sin(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
     static SinCos(vector: Vector256_1<System_Internal.Double>): ValueTuple_2<Vector256_1<System_Internal.Double>, Vector256_1<System_Internal.Double>>;
     static SinCos(vector: Vector256_1<System_Internal.Single>): ValueTuple_2<Vector256_1<System_Internal.Single>, Vector256_1<System_Internal.Single>>;
-    static Sqrt<T>(vector: Vector256_1<T>): Vector256_1<T>;
-    static Store<T>(source: Vector256_1<T>, destination: ptr<T>): void;
-    static StoreAligned<T>(source: Vector256_1<T>, destination: ptr<T>): void;
-    static StoreAlignedNonTemporal<T>(source: Vector256_1<T>, destination: ptr<T>): void;
-    static StoreUnsafe<T>(source: Vector256_1<T>, destination: T, elementOffset: nuint): void;
-    static StoreUnsafe<T>(source: Vector256_1<T>, destination: T): void;
-    static Subtract<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static SubtractSaturate<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
-    static Sum<T>(vector: Vector256_1<T>): T;
-    static ToScalar<T>(vector: Vector256_1<T>): T;
-    static ToVector512<T>(vector: Vector256_1<T>): Vector512_1<T>;
-    static ToVector512Unsafe<T>(vector: Vector256_1<T>): Vector512_1<T>;
+    static Sqrt<T extends unknown>(vector: Vector256_1<T>): Vector256_1<T>;
+    static Store<T extends unknown>(source: Vector256_1<T>, destination: ptr<T>): void;
+    static StoreAligned<T extends unknown>(source: Vector256_1<T>, destination: ptr<T>): void;
+    static StoreAlignedNonTemporal<T extends unknown>(source: Vector256_1<T>, destination: ptr<T>): void;
+    static StoreUnsafe<T extends unknown>(source: Vector256_1<T>, destination: T, elementOffset: nuint): void;
+    static StoreUnsafe<T extends unknown>(source: Vector256_1<T>, destination: T): void;
+    static Subtract<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static SubtractSaturate<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static Sum<T extends unknown>(vector: Vector256_1<T>): T;
+    static ToScalar<T extends unknown>(vector: Vector256_1<T>): T;
+    static ToVector512<T extends unknown>(vector: Vector256_1<T>): Vector512_1<T>;
+    static ToVector512Unsafe<T extends unknown>(vector: Vector256_1<T>): Vector512_1<T>;
     static Truncate(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
     static Truncate(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
-    static TryCopyTo<T>(vector: Vector256_1<T>, destination: Span_1<T>): boolean;
+    static TryCopyTo<T extends unknown>(vector: Vector256_1<T>, destination: Span_1<T>): boolean;
     static Widen(source: Vector256_1<System_Internal.Byte>): ValueTuple_2<Vector256_1<System_Internal.UInt16>, Vector256_1<System_Internal.UInt16>>;
     static Widen(source: Vector256_1<System_Internal.Int16>): ValueTuple_2<Vector256_1<System_Internal.Int32>, Vector256_1<System_Internal.Int32>>;
     static Widen(source: Vector256_1<System_Internal.Int32>): ValueTuple_2<Vector256_1<System_Internal.Int64>, Vector256_1<System_Internal.Int64>>;
@@ -810,10 +808,10 @@ export abstract class Vector256$instance {
     static WidenUpper(source: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Double>;
     static WidenUpper(source: Vector256_1<System_Internal.UInt16>): Vector256_1<System_Internal.UInt32>;
     static WidenUpper(source: Vector256_1<System_Internal.UInt32>): Vector256_1<System_Internal.UInt64>;
-    static WithElement<T>(vector: Vector256_1<T>, index: int, value: T): Vector256_1<T>;
-    static WithLower<T>(vector: Vector256_1<T>, value: Vector128_1<T>): Vector256_1<T>;
-    static WithUpper<T>(vector: Vector256_1<T>, value: Vector128_1<T>): Vector256_1<T>;
-    static Xor<T>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
+    static WithElement<T extends unknown>(vector: Vector256_1<T>, index: int, value: T): Vector256_1<T>;
+    static WithLower<T extends unknown>(vector: Vector256_1<T>, value: Vector128_1<T>): Vector256_1<T>;
+    static WithUpper<T extends unknown>(vector: Vector256_1<T>, value: Vector128_1<T>): Vector256_1<T>;
+    static Xor<T extends unknown>(left: Vector256_1<T>, right: Vector256_1<T>): Vector256_1<T>;
 }
 
 
@@ -821,36 +819,36 @@ export type Vector256 = Vector256$instance;
 
 export abstract class Vector512$instance {
     static readonly IsHardwareAccelerated: boolean;
-    static Abs<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static Add<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static AddSaturate<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static All<T>(vector: Vector512_1<T>, value: T): boolean;
-    static AllWhereAllBitsSet<T>(vector: Vector512_1<T>): boolean;
-    static AndNot<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Any<T>(vector: Vector512_1<T>, value: T): boolean;
-    static AnyWhereAllBitsSet<T>(vector: Vector512_1<T>): boolean;
-    static As<TFrom, TTo>(vector: Vector512_1<TFrom>): Vector512_1<TTo>;
-    static AsByte<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.Byte>;
-    static AsDouble<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.Double>;
-    static AsInt16<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.Int16>;
-    static AsInt32<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.Int32>;
-    static AsInt64<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.Int64>;
-    static AsNInt<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.IntPtr>;
-    static AsNUInt<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.UIntPtr>;
-    static AsSByte<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.SByte>;
-    static AsSingle<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.Single>;
-    static AsUInt16<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.UInt16>;
-    static AsUInt32<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.UInt32>;
-    static AsUInt64<T>(vector: Vector512_1<T>): Vector512_1<System_Internal.UInt64>;
-    static AsVector<T>(value: Vector512_1<T>): Vector_1<T>;
-    static AsVector512<T>(value: Vector_1<T>): Vector512_1<T>;
-    static BitwiseAnd<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static BitwiseOr<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static Abs<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static Add<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static AddSaturate<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static All<T extends unknown>(vector: Vector512_1<T>, value: T): boolean;
+    static AllWhereAllBitsSet<T extends unknown>(vector: Vector512_1<T>): boolean;
+    static AndNot<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static Any<T extends unknown>(vector: Vector512_1<T>, value: T): boolean;
+    static AnyWhereAllBitsSet<T extends unknown>(vector: Vector512_1<T>): boolean;
+    static As<TFrom extends unknown, TTo extends unknown>(vector: Vector512_1<TFrom>): Vector512_1<TTo>;
+    static AsByte<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.Byte>;
+    static AsDouble<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.Double>;
+    static AsInt16<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.Int16>;
+    static AsInt32<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.Int32>;
+    static AsInt64<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.Int64>;
+    static AsNInt<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.IntPtr>;
+    static AsNUInt<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.UIntPtr>;
+    static AsSByte<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.SByte>;
+    static AsSingle<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.Single>;
+    static AsUInt16<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.UInt16>;
+    static AsUInt32<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.UInt32>;
+    static AsUInt64<T extends unknown>(vector: Vector512_1<T>): Vector512_1<System_Internal.UInt64>;
+    static AsVector<T extends unknown>(value: Vector512_1<T>): Vector_1<T>;
+    static AsVector512<T extends unknown>(value: Vector_1<T>): Vector512_1<T>;
+    static BitwiseAnd<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static BitwiseOr<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
     static Ceiling(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static Ceiling(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
-    static Clamp<T>(value: Vector512_1<T>, min: Vector512_1<T>, max: Vector512_1<T>): Vector512_1<T>;
-    static ClampNative<T>(value: Vector512_1<T>, min: Vector512_1<T>, max: Vector512_1<T>): Vector512_1<T>;
-    static ConditionalSelect<T>(condition: Vector512_1<T>, left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static Clamp<T extends unknown>(value: Vector512_1<T>, min: Vector512_1<T>, max: Vector512_1<T>): Vector512_1<T>;
+    static ClampNative<T extends unknown>(value: Vector512_1<T>, min: Vector512_1<T>, max: Vector512_1<T>): Vector512_1<T>;
+    static ConditionalSelect<T extends unknown>(condition: Vector512_1<T>, left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
     static ConvertToDouble(vector: Vector512_1<System_Internal.Int64>): Vector512_1<System_Internal.Double>;
     static ConvertToDouble(vector: Vector512_1<System_Internal.UInt64>): Vector512_1<System_Internal.Double>;
     static ConvertToInt32(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Int32>;
@@ -863,15 +861,15 @@ export abstract class Vector512$instance {
     static ConvertToUInt32Native(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.UInt32>;
     static ConvertToUInt64(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.UInt64>;
     static ConvertToUInt64Native(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.UInt64>;
-    static CopySign<T>(value: Vector512_1<T>, sign: Vector512_1<T>): Vector512_1<T>;
-    static CopyTo<T>(vector: Vector512_1<T>, destination: Span_1<T>): void;
-    static CopyTo<T>(vector: Vector512_1<T>, destination: T[], startIndex: int): void;
-    static CopyTo<T>(vector: Vector512_1<T>, destination: T[]): void;
+    static CopySign<T extends unknown>(value: Vector512_1<T>, sign: Vector512_1<T>): Vector512_1<T>;
+    static CopyTo<T extends unknown>(vector: Vector512_1<T>, destination: Span_1<T>): void;
+    static CopyTo<T extends unknown>(vector: Vector512_1<T>, destination: T[], startIndex: int): void;
+    static CopyTo<T extends unknown>(vector: Vector512_1<T>, destination: T[]): void;
     static Cos(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static Cos(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
-    static Count<T>(vector: Vector512_1<T>, value: T): int;
-    static CountWhereAllBitsSet<T>(vector: Vector512_1<T>): int;
-    static Create<T>(values: ReadOnlySpan_1<T>): Vector512_1<T>;
+    static Count<T extends unknown>(vector: Vector512_1<T>, value: T): int;
+    static CountWhereAllBitsSet<T extends unknown>(vector: Vector512_1<T>): int;
+    static Create<T extends unknown>(values: ReadOnlySpan_1<T>): Vector512_1<T>;
     static Create(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte, e8: byte, e9: byte, e10: byte, e11: byte, e12: byte, e13: byte, e14: byte, e15: byte, e16: byte, e17: byte, e18: byte, e19: byte, e20: byte, e21: byte, e22: byte, e23: byte, e24: byte, e25: byte, e26: byte, e27: byte, e28: byte, e29: byte, e30: byte, e31: byte, e32: byte, e33: byte, e34: byte, e35: byte, e36: byte, e37: byte, e38: byte, e39: byte, e40: byte, e41: byte, e42: byte, e43: byte, e44: byte, e45: byte, e46: byte, e47: byte, e48: byte, e49: byte, e50: byte, e51: byte, e52: byte, e53: byte, e54: byte, e55: byte, e56: byte, e57: byte, e58: byte, e59: byte, e60: byte, e61: byte, e62: byte, e63: byte): Vector512_1<System_Internal.Byte>;
     static Create(value: byte): Vector512_1<System_Internal.Byte>;
     static Create(e0: double, e1: double, e2: double, e3: double, e4: double, e5: double, e6: double, e7: double): Vector512_1<System_Internal.Double>;
@@ -906,13 +904,13 @@ export abstract class Vector512$instance {
     static Create(e0: ulong, e1: ulong, e2: ulong, e3: ulong, e4: ulong, e5: ulong, e6: ulong, e7: ulong): Vector512_1<System_Internal.UInt64>;
     static Create(value: ulong): Vector512_1<System_Internal.UInt64>;
     static Create(value: nuint): Vector512_1<System_Internal.UIntPtr>;
-    static Create<T>(value: T): Vector512_1<T>;
-    static Create<T>(values: T[], index: int): Vector512_1<T>;
-    static Create<T>(values: T[]): Vector512_1<T>;
-    static Create<T>(value: Vector128_1<T>): Vector512_1<T>;
-    static Create<T>(lower: Vector256_1<T>, upper: Vector256_1<T>): Vector512_1<T>;
-    static Create<T>(value: Vector256_1<T>): Vector512_1<T>;
-    static Create<T>(value: Vector64_1<T>): Vector512_1<T>;
+    static Create<T extends unknown>(value: T): Vector512_1<T>;
+    static Create<T extends unknown>(values: T[], index: int): Vector512_1<T>;
+    static Create<T extends unknown>(values: T[]): Vector512_1<T>;
+    static Create<T extends unknown>(value: Vector128_1<T>): Vector512_1<T>;
+    static Create<T extends unknown>(lower: Vector256_1<T>, upper: Vector256_1<T>): Vector512_1<T>;
+    static Create<T extends unknown>(value: Vector256_1<T>): Vector512_1<T>;
+    static Create<T extends unknown>(value: Vector64_1<T>): Vector512_1<T>;
     static CreateScalar(value: byte): Vector512_1<System_Internal.Byte>;
     static CreateScalar(value: double): Vector512_1<System_Internal.Double>;
     static CreateScalar(value: short): Vector512_1<System_Internal.Int16>;
@@ -925,7 +923,7 @@ export abstract class Vector512$instance {
     static CreateScalar(value: uint): Vector512_1<System_Internal.UInt32>;
     static CreateScalar(value: ulong): Vector512_1<System_Internal.UInt64>;
     static CreateScalar(value: nuint): Vector512_1<System_Internal.UIntPtr>;
-    static CreateScalar<T>(value: T): Vector512_1<T>;
+    static CreateScalar<T extends unknown>(value: T): Vector512_1<T>;
     static CreateScalarUnsafe(value: byte): Vector512_1<System_Internal.Byte>;
     static CreateScalarUnsafe(value: double): Vector512_1<System_Internal.Double>;
     static CreateScalarUnsafe(value: short): Vector512_1<System_Internal.Int16>;
@@ -938,81 +936,81 @@ export abstract class Vector512$instance {
     static CreateScalarUnsafe(value: uint): Vector512_1<System_Internal.UInt32>;
     static CreateScalarUnsafe(value: ulong): Vector512_1<System_Internal.UInt64>;
     static CreateScalarUnsafe(value: nuint): Vector512_1<System_Internal.UIntPtr>;
-    static CreateScalarUnsafe<T>(value: T): Vector512_1<T>;
-    static CreateSequence<T>(start: T, step: T): Vector512_1<T>;
+    static CreateScalarUnsafe<T extends unknown>(value: T): Vector512_1<T>;
+    static CreateSequence<T extends unknown>(start: T, step: T): Vector512_1<T>;
     static DegreesToRadians(degrees: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static DegreesToRadians(degrees: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
-    static Divide<T>(left: Vector512_1<T>, right: T): Vector512_1<T>;
-    static Divide<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Dot<T>(left: Vector512_1<T>, right: Vector512_1<T>): T;
-    static Equals<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static EqualsAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static EqualsAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static Divide<T extends unknown>(left: Vector512_1<T>, right: T): Vector512_1<T>;
+    static Divide<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static Dot<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): T;
+    static Equals<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static EqualsAll<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static EqualsAny<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
     static Exp(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static Exp(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
-    static ExtractMostSignificantBits<T>(vector: Vector512_1<T>): ulong;
+    static ExtractMostSignificantBits<T extends unknown>(vector: Vector512_1<T>): ulong;
     static Floor(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static Floor(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
     static FusedMultiplyAdd(left: Vector512_1<System_Internal.Double>, right: Vector512_1<System_Internal.Double>, addend: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static FusedMultiplyAdd(left: Vector512_1<System_Internal.Single>, right: Vector512_1<System_Internal.Single>, addend: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
-    static GetElement<T>(vector: Vector512_1<T>, index: int): T;
-    static GetLower<T>(vector: Vector512_1<T>): Vector256_1<T>;
-    static GetUpper<T>(vector: Vector512_1<T>): Vector256_1<T>;
-    static GreaterThan<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static GreaterThanAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static GreaterThanAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static GreaterThanOrEqual<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static GreaterThanOrEqualAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static GreaterThanOrEqualAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static GetElement<T extends unknown>(vector: Vector512_1<T>, index: int): T;
+    static GetLower<T extends unknown>(vector: Vector512_1<T>): Vector256_1<T>;
+    static GetUpper<T extends unknown>(vector: Vector512_1<T>): Vector256_1<T>;
+    static GreaterThan<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static GreaterThanAll<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static GreaterThanAny<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static GreaterThanOrEqual<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static GreaterThanOrEqualAll<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static GreaterThanOrEqualAny<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
     static Hypot(x: Vector512_1<System_Internal.Double>, y: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static Hypot(x: Vector512_1<System_Internal.Single>, y: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
-    static IndexOf<T>(vector: Vector512_1<T>, value: T): int;
-    static IndexOfWhereAllBitsSet<T>(vector: Vector512_1<T>): int;
-    static IsEvenInteger<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsFinite<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsInfinity<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsInteger<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsNaN<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsNegative<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsNegativeInfinity<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsNormal<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsOddInteger<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsPositive<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsPositiveInfinity<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsSubnormal<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static IsZero<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static LastIndexOf<T>(vector: Vector512_1<T>, value: T): int;
-    static LastIndexOfWhereAllBitsSet<T>(vector: Vector512_1<T>): int;
+    static IndexOf<T extends unknown>(vector: Vector512_1<T>, value: T): int;
+    static IndexOfWhereAllBitsSet<T extends unknown>(vector: Vector512_1<T>): int;
+    static IsEvenInteger<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsFinite<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsInfinity<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsInteger<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsNaN<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsNegative<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsNegativeInfinity<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsNormal<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsOddInteger<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsPositive<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsPositiveInfinity<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsSubnormal<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static IsZero<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static LastIndexOf<T extends unknown>(vector: Vector512_1<T>, value: T): int;
+    static LastIndexOfWhereAllBitsSet<T extends unknown>(vector: Vector512_1<T>): int;
     static Lerp(x: Vector512_1<System_Internal.Double>, y: Vector512_1<System_Internal.Double>, amount: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static Lerp(x: Vector512_1<System_Internal.Single>, y: Vector512_1<System_Internal.Single>, amount: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
-    static LessThan<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static LessThanAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static LessThanAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static LessThanOrEqual<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static LessThanOrEqualAll<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static LessThanOrEqualAny<T>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
-    static Load<T>(source: ptr<T>): Vector512_1<T>;
-    static LoadAligned<T>(source: ptr<T>): Vector512_1<T>;
-    static LoadAlignedNonTemporal<T>(source: ptr<T>): Vector512_1<T>;
-    static LoadUnsafe<T>(source: T, elementOffset: nuint): Vector512_1<T>;
-    static LoadUnsafe<T>(source: T): Vector512_1<T>;
+    static LessThan<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static LessThanAll<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static LessThanAny<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static LessThanOrEqual<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static LessThanOrEqualAll<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static LessThanOrEqualAny<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): boolean;
+    static Load<T extends unknown>(source: ptr<T>): Vector512_1<T>;
+    static LoadAligned<T extends unknown>(source: ptr<T>): Vector512_1<T>;
+    static LoadAlignedNonTemporal<T extends unknown>(source: ptr<T>): Vector512_1<T>;
+    static LoadUnsafe<T extends unknown>(source: T, elementOffset: nuint): Vector512_1<T>;
+    static LoadUnsafe<T extends unknown>(source: T): Vector512_1<T>;
     static Log(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static Log(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
     static Log2(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static Log2(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
-    static Max<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MaxMagnitude<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MaxMagnitudeNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MaxNative<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MaxNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Min<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MinMagnitude<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MinMagnitudeNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MinNative<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static MinNumber<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Multiply<T>(left: T, right: Vector512_1<T>): Vector512_1<T>;
-    static Multiply<T>(left: Vector512_1<T>, right: T): Vector512_1<T>;
-    static Multiply<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static Max<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static MaxMagnitude<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static MaxMagnitudeNumber<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static MaxNative<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static MaxNumber<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static Min<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static MinMagnitude<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static MinMagnitudeNumber<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static MinNative<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static MinNumber<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static Multiply<T extends unknown>(left: T, right: Vector512_1<T>): Vector512_1<T>;
+    static Multiply<T extends unknown>(left: Vector512_1<T>, right: T): Vector512_1<T>;
+    static Multiply<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
     static MultiplyAddEstimate(left: Vector512_1<System_Internal.Double>, right: Vector512_1<System_Internal.Double>, addend: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static MultiplyAddEstimate(left: Vector512_1<System_Internal.Single>, right: Vector512_1<System_Internal.Single>, addend: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
     static Narrow(lower: Vector512_1<System_Internal.Double>, upper: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Single>;
@@ -1029,10 +1027,10 @@ export abstract class Vector512$instance {
     static NarrowWithSaturation(lower: Vector512_1<System_Internal.UInt16>, upper: Vector512_1<System_Internal.UInt16>): Vector512_1<System_Internal.Byte>;
     static NarrowWithSaturation(lower: Vector512_1<System_Internal.UInt32>, upper: Vector512_1<System_Internal.UInt32>): Vector512_1<System_Internal.UInt16>;
     static NarrowWithSaturation(lower: Vector512_1<System_Internal.UInt64>, upper: Vector512_1<System_Internal.UInt64>): Vector512_1<System_Internal.UInt32>;
-    static Negate<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static None<T>(vector: Vector512_1<T>, value: T): boolean;
-    static NoneWhereAllBitsSet<T>(vector: Vector512_1<T>): boolean;
-    static OnesComplement<T>(vector: Vector512_1<T>): Vector512_1<T>;
+    static Negate<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static None<T extends unknown>(vector: Vector512_1<T>, value: T): boolean;
+    static NoneWhereAllBitsSet<T extends unknown>(vector: Vector512_1<T>): boolean;
+    static OnesComplement<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
     static RadiansToDegrees(radians: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static RadiansToDegrees(radians: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
     static Round(vector: Vector512_1<System_Internal.Double>, mode: MidpointRounding): Vector512_1<System_Internal.Double>;
@@ -1088,19 +1086,19 @@ export abstract class Vector512$instance {
     static Sin(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
     static SinCos(vector: Vector512_1<System_Internal.Double>): ValueTuple_2<Vector512_1<System_Internal.Double>, Vector512_1<System_Internal.Double>>;
     static SinCos(vector: Vector512_1<System_Internal.Single>): ValueTuple_2<Vector512_1<System_Internal.Single>, Vector512_1<System_Internal.Single>>;
-    static Sqrt<T>(vector: Vector512_1<T>): Vector512_1<T>;
-    static Store<T>(source: Vector512_1<T>, destination: ptr<T>): void;
-    static StoreAligned<T>(source: Vector512_1<T>, destination: ptr<T>): void;
-    static StoreAlignedNonTemporal<T>(source: Vector512_1<T>, destination: ptr<T>): void;
-    static StoreUnsafe<T>(source: Vector512_1<T>, destination: T, elementOffset: nuint): void;
-    static StoreUnsafe<T>(source: Vector512_1<T>, destination: T): void;
-    static Subtract<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static SubtractSaturate<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
-    static Sum<T>(vector: Vector512_1<T>): T;
-    static ToScalar<T>(vector: Vector512_1<T>): T;
+    static Sqrt<T extends unknown>(vector: Vector512_1<T>): Vector512_1<T>;
+    static Store<T extends unknown>(source: Vector512_1<T>, destination: ptr<T>): void;
+    static StoreAligned<T extends unknown>(source: Vector512_1<T>, destination: ptr<T>): void;
+    static StoreAlignedNonTemporal<T extends unknown>(source: Vector512_1<T>, destination: ptr<T>): void;
+    static StoreUnsafe<T extends unknown>(source: Vector512_1<T>, destination: T, elementOffset: nuint): void;
+    static StoreUnsafe<T extends unknown>(source: Vector512_1<T>, destination: T): void;
+    static Subtract<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static SubtractSaturate<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static Sum<T extends unknown>(vector: Vector512_1<T>): T;
+    static ToScalar<T extends unknown>(vector: Vector512_1<T>): T;
     static Truncate(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
     static Truncate(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
-    static TryCopyTo<T>(vector: Vector512_1<T>, destination: Span_1<T>): boolean;
+    static TryCopyTo<T extends unknown>(vector: Vector512_1<T>, destination: Span_1<T>): boolean;
     static Widen(source: Vector512_1<System_Internal.Byte>): ValueTuple_2<Vector512_1<System_Internal.UInt16>, Vector512_1<System_Internal.UInt16>>;
     static Widen(source: Vector512_1<System_Internal.Int16>): ValueTuple_2<Vector512_1<System_Internal.Int32>, Vector512_1<System_Internal.Int32>>;
     static Widen(source: Vector512_1<System_Internal.Int32>): ValueTuple_2<Vector512_1<System_Internal.Int64>, Vector512_1<System_Internal.Int64>>;
@@ -1122,10 +1120,10 @@ export abstract class Vector512$instance {
     static WidenUpper(source: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Double>;
     static WidenUpper(source: Vector512_1<System_Internal.UInt16>): Vector512_1<System_Internal.UInt32>;
     static WidenUpper(source: Vector512_1<System_Internal.UInt32>): Vector512_1<System_Internal.UInt64>;
-    static WithElement<T>(vector: Vector512_1<T>, index: int, value: T): Vector512_1<T>;
-    static WithLower<T>(vector: Vector512_1<T>, value: Vector256_1<T>): Vector512_1<T>;
-    static WithUpper<T>(vector: Vector512_1<T>, value: Vector256_1<T>): Vector512_1<T>;
-    static Xor<T>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
+    static WithElement<T extends unknown>(vector: Vector512_1<T>, index: int, value: T): Vector512_1<T>;
+    static WithLower<T extends unknown>(vector: Vector512_1<T>, value: Vector256_1<T>): Vector512_1<T>;
+    static WithUpper<T extends unknown>(vector: Vector512_1<T>, value: Vector256_1<T>): Vector512_1<T>;
+    static Xor<T extends unknown>(left: Vector512_1<T>, right: Vector512_1<T>): Vector512_1<T>;
 }
 
 
@@ -1133,34 +1131,34 @@ export type Vector512 = Vector512$instance;
 
 export abstract class Vector64$instance {
     static readonly IsHardwareAccelerated: boolean;
-    static Abs<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static Add<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static AddSaturate<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static All<T>(vector: Vector64_1<T>, value: T): boolean;
-    static AllWhereAllBitsSet<T>(vector: Vector64_1<T>): boolean;
-    static AndNot<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Any<T>(vector: Vector64_1<T>, value: T): boolean;
-    static AnyWhereAllBitsSet<T>(vector: Vector64_1<T>): boolean;
-    static As<TFrom, TTo>(vector: Vector64_1<TFrom>): Vector64_1<TTo>;
-    static AsByte<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.Byte>;
-    static AsDouble<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.Double>;
-    static AsInt16<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.Int16>;
-    static AsInt32<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.Int32>;
-    static AsInt64<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.Int64>;
-    static AsNInt<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.IntPtr>;
-    static AsNUInt<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.UIntPtr>;
-    static AsSByte<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.SByte>;
-    static AsSingle<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.Single>;
-    static AsUInt16<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.UInt16>;
-    static AsUInt32<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.UInt32>;
-    static AsUInt64<T>(vector: Vector64_1<T>): Vector64_1<System_Internal.UInt64>;
-    static BitwiseAnd<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static BitwiseOr<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static Abs<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static Add<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static AddSaturate<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static All<T extends unknown>(vector: Vector64_1<T>, value: T): boolean;
+    static AllWhereAllBitsSet<T extends unknown>(vector: Vector64_1<T>): boolean;
+    static AndNot<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static Any<T extends unknown>(vector: Vector64_1<T>, value: T): boolean;
+    static AnyWhereAllBitsSet<T extends unknown>(vector: Vector64_1<T>): boolean;
+    static As<TFrom extends unknown, TTo extends unknown>(vector: Vector64_1<TFrom>): Vector64_1<TTo>;
+    static AsByte<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.Byte>;
+    static AsDouble<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.Double>;
+    static AsInt16<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.Int16>;
+    static AsInt32<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.Int32>;
+    static AsInt64<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.Int64>;
+    static AsNInt<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.IntPtr>;
+    static AsNUInt<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.UIntPtr>;
+    static AsSByte<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.SByte>;
+    static AsSingle<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.Single>;
+    static AsUInt16<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.UInt16>;
+    static AsUInt32<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.UInt32>;
+    static AsUInt64<T extends unknown>(vector: Vector64_1<T>): Vector64_1<System_Internal.UInt64>;
+    static BitwiseAnd<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static BitwiseOr<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
     static Ceiling(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static Ceiling(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
-    static Clamp<T>(value: Vector64_1<T>, min: Vector64_1<T>, max: Vector64_1<T>): Vector64_1<T>;
-    static ClampNative<T>(value: Vector64_1<T>, min: Vector64_1<T>, max: Vector64_1<T>): Vector64_1<T>;
-    static ConditionalSelect<T>(condition: Vector64_1<T>, left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static Clamp<T extends unknown>(value: Vector64_1<T>, min: Vector64_1<T>, max: Vector64_1<T>): Vector64_1<T>;
+    static ClampNative<T extends unknown>(value: Vector64_1<T>, min: Vector64_1<T>, max: Vector64_1<T>): Vector64_1<T>;
+    static ConditionalSelect<T extends unknown>(condition: Vector64_1<T>, left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
     static ConvertToDouble(vector: Vector64_1<System_Internal.Int64>): Vector64_1<System_Internal.Double>;
     static ConvertToDouble(vector: Vector64_1<System_Internal.UInt64>): Vector64_1<System_Internal.Double>;
     static ConvertToInt32(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Int32>;
@@ -1173,15 +1171,15 @@ export abstract class Vector64$instance {
     static ConvertToUInt32Native(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.UInt32>;
     static ConvertToUInt64(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.UInt64>;
     static ConvertToUInt64Native(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.UInt64>;
-    static CopySign<T>(value: Vector64_1<T>, sign: Vector64_1<T>): Vector64_1<T>;
-    static CopyTo<T>(vector: Vector64_1<T>, destination: Span_1<T>): void;
-    static CopyTo<T>(vector: Vector64_1<T>, destination: T[], startIndex: int): void;
-    static CopyTo<T>(vector: Vector64_1<T>, destination: T[]): void;
+    static CopySign<T extends unknown>(value: Vector64_1<T>, sign: Vector64_1<T>): Vector64_1<T>;
+    static CopyTo<T extends unknown>(vector: Vector64_1<T>, destination: Span_1<T>): void;
+    static CopyTo<T extends unknown>(vector: Vector64_1<T>, destination: T[], startIndex: int): void;
+    static CopyTo<T extends unknown>(vector: Vector64_1<T>, destination: T[]): void;
     static Cos(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static Cos(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
-    static Count<T>(vector: Vector64_1<T>, value: T): int;
-    static CountWhereAllBitsSet<T>(vector: Vector64_1<T>): int;
-    static Create<T>(values: ReadOnlySpan_1<T>): Vector64_1<T>;
+    static Count<T extends unknown>(vector: Vector64_1<T>, value: T): int;
+    static CountWhereAllBitsSet<T extends unknown>(vector: Vector64_1<T>): int;
+    static Create<T extends unknown>(values: ReadOnlySpan_1<T>): Vector64_1<T>;
     static Create(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte): Vector64_1<System_Internal.Byte>;
     static Create(value: byte): Vector64_1<System_Internal.Byte>;
     static Create(value: double): Vector64_1<System_Internal.Double>;
@@ -1201,9 +1199,9 @@ export abstract class Vector64$instance {
     static Create(value: uint): Vector64_1<System_Internal.UInt32>;
     static Create(value: ulong): Vector64_1<System_Internal.UInt64>;
     static Create(value: nuint): Vector64_1<System_Internal.UIntPtr>;
-    static Create<T>(value: T): Vector64_1<T>;
-    static Create<T>(values: T[], index: int): Vector64_1<T>;
-    static Create<T>(values: T[]): Vector64_1<T>;
+    static Create<T extends unknown>(value: T): Vector64_1<T>;
+    static Create<T extends unknown>(values: T[], index: int): Vector64_1<T>;
+    static Create<T extends unknown>(values: T[]): Vector64_1<T>;
     static CreateScalar(value: byte): Vector64_1<System_Internal.Byte>;
     static CreateScalar(value: double): Vector64_1<System_Internal.Double>;
     static CreateScalar(value: short): Vector64_1<System_Internal.Int16>;
@@ -1216,7 +1214,7 @@ export abstract class Vector64$instance {
     static CreateScalar(value: uint): Vector64_1<System_Internal.UInt32>;
     static CreateScalar(value: ulong): Vector64_1<System_Internal.UInt64>;
     static CreateScalar(value: nuint): Vector64_1<System_Internal.UIntPtr>;
-    static CreateScalar<T>(value: T): Vector64_1<T>;
+    static CreateScalar<T extends unknown>(value: T): Vector64_1<T>;
     static CreateScalarUnsafe(value: byte): Vector64_1<System_Internal.Byte>;
     static CreateScalarUnsafe(value: double): Vector64_1<System_Internal.Double>;
     static CreateScalarUnsafe(value: short): Vector64_1<System_Internal.Int16>;
@@ -1229,79 +1227,79 @@ export abstract class Vector64$instance {
     static CreateScalarUnsafe(value: uint): Vector64_1<System_Internal.UInt32>;
     static CreateScalarUnsafe(value: ulong): Vector64_1<System_Internal.UInt64>;
     static CreateScalarUnsafe(value: nuint): Vector64_1<System_Internal.UIntPtr>;
-    static CreateScalarUnsafe<T>(value: T): Vector64_1<T>;
-    static CreateSequence<T>(start: T, step: T): Vector64_1<T>;
+    static CreateScalarUnsafe<T extends unknown>(value: T): Vector64_1<T>;
+    static CreateSequence<T extends unknown>(start: T, step: T): Vector64_1<T>;
     static DegreesToRadians(degrees: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static DegreesToRadians(degrees: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
-    static Divide<T>(left: Vector64_1<T>, right: T): Vector64_1<T>;
-    static Divide<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Dot<T>(left: Vector64_1<T>, right: Vector64_1<T>): T;
-    static Equals<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static EqualsAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static EqualsAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static Divide<T extends unknown>(left: Vector64_1<T>, right: T): Vector64_1<T>;
+    static Divide<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static Dot<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): T;
+    static Equals<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static EqualsAll<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static EqualsAny<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
     static Exp(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static Exp(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
-    static ExtractMostSignificantBits<T>(vector: Vector64_1<T>): uint;
+    static ExtractMostSignificantBits<T extends unknown>(vector: Vector64_1<T>): uint;
     static Floor(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static Floor(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
     static FusedMultiplyAdd(left: Vector64_1<System_Internal.Double>, right: Vector64_1<System_Internal.Double>, addend: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static FusedMultiplyAdd(left: Vector64_1<System_Internal.Single>, right: Vector64_1<System_Internal.Single>, addend: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
-    static GetElement<T>(vector: Vector64_1<T>, index: int): T;
-    static GreaterThan<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static GreaterThanAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static GreaterThanAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static GreaterThanOrEqual<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static GreaterThanOrEqualAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static GreaterThanOrEqualAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static GetElement<T extends unknown>(vector: Vector64_1<T>, index: int): T;
+    static GreaterThan<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static GreaterThanAll<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static GreaterThanAny<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static GreaterThanOrEqual<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static GreaterThanOrEqualAll<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static GreaterThanOrEqualAny<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
     static Hypot(x: Vector64_1<System_Internal.Double>, y: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static Hypot(x: Vector64_1<System_Internal.Single>, y: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
-    static IndexOf<T>(vector: Vector64_1<T>, value: T): int;
-    static IndexOfWhereAllBitsSet<T>(vector: Vector64_1<T>): int;
-    static IsEvenInteger<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsFinite<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsInfinity<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsInteger<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsNaN<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsNegative<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsNegativeInfinity<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsNormal<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsOddInteger<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsPositive<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsPositiveInfinity<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsSubnormal<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static IsZero<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static LastIndexOf<T>(vector: Vector64_1<T>, value: T): int;
-    static LastIndexOfWhereAllBitsSet<T>(vector: Vector64_1<T>): int;
+    static IndexOf<T extends unknown>(vector: Vector64_1<T>, value: T): int;
+    static IndexOfWhereAllBitsSet<T extends unknown>(vector: Vector64_1<T>): int;
+    static IsEvenInteger<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsFinite<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsInfinity<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsInteger<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsNaN<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsNegative<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsNegativeInfinity<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsNormal<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsOddInteger<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsPositive<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsPositiveInfinity<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsSubnormal<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static IsZero<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static LastIndexOf<T extends unknown>(vector: Vector64_1<T>, value: T): int;
+    static LastIndexOfWhereAllBitsSet<T extends unknown>(vector: Vector64_1<T>): int;
     static Lerp(x: Vector64_1<System_Internal.Double>, y: Vector64_1<System_Internal.Double>, amount: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static Lerp(x: Vector64_1<System_Internal.Single>, y: Vector64_1<System_Internal.Single>, amount: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
-    static LessThan<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static LessThanAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static LessThanAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static LessThanOrEqual<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static LessThanOrEqualAll<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static LessThanOrEqualAny<T>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
-    static Load<T>(source: ptr<T>): Vector64_1<T>;
-    static LoadAligned<T>(source: ptr<T>): Vector64_1<T>;
-    static LoadAlignedNonTemporal<T>(source: ptr<T>): Vector64_1<T>;
-    static LoadUnsafe<T>(source: T, elementOffset: nuint): Vector64_1<T>;
-    static LoadUnsafe<T>(source: T): Vector64_1<T>;
+    static LessThan<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static LessThanAll<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static LessThanAny<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static LessThanOrEqual<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static LessThanOrEqualAll<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static LessThanOrEqualAny<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): boolean;
+    static Load<T extends unknown>(source: ptr<T>): Vector64_1<T>;
+    static LoadAligned<T extends unknown>(source: ptr<T>): Vector64_1<T>;
+    static LoadAlignedNonTemporal<T extends unknown>(source: ptr<T>): Vector64_1<T>;
+    static LoadUnsafe<T extends unknown>(source: T, elementOffset: nuint): Vector64_1<T>;
+    static LoadUnsafe<T extends unknown>(source: T): Vector64_1<T>;
     static Log(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static Log(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
     static Log2(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static Log2(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
-    static Max<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MaxMagnitude<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MaxMagnitudeNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MaxNative<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MaxNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Min<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MinMagnitude<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MinMagnitudeNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MinNative<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static MinNumber<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Multiply<T>(left: T, right: Vector64_1<T>): Vector64_1<T>;
-    static Multiply<T>(left: Vector64_1<T>, right: T): Vector64_1<T>;
-    static Multiply<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static Max<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static MaxMagnitude<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static MaxMagnitudeNumber<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static MaxNative<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static MaxNumber<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static Min<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static MinMagnitude<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static MinMagnitudeNumber<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static MinNative<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static MinNumber<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static Multiply<T extends unknown>(left: T, right: Vector64_1<T>): Vector64_1<T>;
+    static Multiply<T extends unknown>(left: Vector64_1<T>, right: T): Vector64_1<T>;
+    static Multiply<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
     static MultiplyAddEstimate(left: Vector64_1<System_Internal.Double>, right: Vector64_1<System_Internal.Double>, addend: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static MultiplyAddEstimate(left: Vector64_1<System_Internal.Single>, right: Vector64_1<System_Internal.Single>, addend: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
     static Narrow(lower: Vector64_1<System_Internal.Double>, upper: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Single>;
@@ -1318,10 +1316,10 @@ export abstract class Vector64$instance {
     static NarrowWithSaturation(lower: Vector64_1<System_Internal.UInt16>, upper: Vector64_1<System_Internal.UInt16>): Vector64_1<System_Internal.Byte>;
     static NarrowWithSaturation(lower: Vector64_1<System_Internal.UInt32>, upper: Vector64_1<System_Internal.UInt32>): Vector64_1<System_Internal.UInt16>;
     static NarrowWithSaturation(lower: Vector64_1<System_Internal.UInt64>, upper: Vector64_1<System_Internal.UInt64>): Vector64_1<System_Internal.UInt32>;
-    static Negate<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static None<T>(vector: Vector64_1<T>, value: T): boolean;
-    static NoneWhereAllBitsSet<T>(vector: Vector64_1<T>): boolean;
-    static OnesComplement<T>(vector: Vector64_1<T>): Vector64_1<T>;
+    static Negate<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static None<T extends unknown>(vector: Vector64_1<T>, value: T): boolean;
+    static NoneWhereAllBitsSet<T extends unknown>(vector: Vector64_1<T>): boolean;
+    static OnesComplement<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
     static RadiansToDegrees(radians: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static RadiansToDegrees(radians: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
     static Round(vector: Vector64_1<System_Internal.Double>, mode: MidpointRounding): Vector64_1<System_Internal.Double>;
@@ -1371,21 +1369,21 @@ export abstract class Vector64$instance {
     static Sin(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
     static SinCos(vector: Vector64_1<System_Internal.Double>): ValueTuple_2<Vector64_1<System_Internal.Double>, Vector64_1<System_Internal.Double>>;
     static SinCos(vector: Vector64_1<System_Internal.Single>): ValueTuple_2<Vector64_1<System_Internal.Single>, Vector64_1<System_Internal.Single>>;
-    static Sqrt<T>(vector: Vector64_1<T>): Vector64_1<T>;
-    static Store<T>(source: Vector64_1<T>, destination: ptr<T>): void;
-    static StoreAligned<T>(source: Vector64_1<T>, destination: ptr<T>): void;
-    static StoreAlignedNonTemporal<T>(source: Vector64_1<T>, destination: ptr<T>): void;
-    static StoreUnsafe<T>(source: Vector64_1<T>, destination: T, elementOffset: nuint): void;
-    static StoreUnsafe<T>(source: Vector64_1<T>, destination: T): void;
-    static Subtract<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static SubtractSaturate<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
-    static Sum<T>(vector: Vector64_1<T>): T;
-    static ToScalar<T>(vector: Vector64_1<T>): T;
-    static ToVector128<T>(vector: Vector64_1<T>): Vector128_1<T>;
-    static ToVector128Unsafe<T>(vector: Vector64_1<T>): Vector128_1<T>;
+    static Sqrt<T extends unknown>(vector: Vector64_1<T>): Vector64_1<T>;
+    static Store<T extends unknown>(source: Vector64_1<T>, destination: ptr<T>): void;
+    static StoreAligned<T extends unknown>(source: Vector64_1<T>, destination: ptr<T>): void;
+    static StoreAlignedNonTemporal<T extends unknown>(source: Vector64_1<T>, destination: ptr<T>): void;
+    static StoreUnsafe<T extends unknown>(source: Vector64_1<T>, destination: T, elementOffset: nuint): void;
+    static StoreUnsafe<T extends unknown>(source: Vector64_1<T>, destination: T): void;
+    static Subtract<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static SubtractSaturate<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static Sum<T extends unknown>(vector: Vector64_1<T>): T;
+    static ToScalar<T extends unknown>(vector: Vector64_1<T>): T;
+    static ToVector128<T extends unknown>(vector: Vector64_1<T>): Vector128_1<T>;
+    static ToVector128Unsafe<T extends unknown>(vector: Vector64_1<T>): Vector128_1<T>;
     static Truncate(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
     static Truncate(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
-    static TryCopyTo<T>(vector: Vector64_1<T>, destination: Span_1<T>): boolean;
+    static TryCopyTo<T extends unknown>(vector: Vector64_1<T>, destination: Span_1<T>): boolean;
     static Widen(source: Vector64_1<System_Internal.Byte>): ValueTuple_2<Vector64_1<System_Internal.UInt16>, Vector64_1<System_Internal.UInt16>>;
     static Widen(source: Vector64_1<System_Internal.Int16>): ValueTuple_2<Vector64_1<System_Internal.Int32>, Vector64_1<System_Internal.Int32>>;
     static Widen(source: Vector64_1<System_Internal.Int32>): ValueTuple_2<Vector64_1<System_Internal.Int64>, Vector64_1<System_Internal.Int64>>;
@@ -1407,8 +1405,8 @@ export abstract class Vector64$instance {
     static WidenUpper(source: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Double>;
     static WidenUpper(source: Vector64_1<System_Internal.UInt16>): Vector64_1<System_Internal.UInt32>;
     static WidenUpper(source: Vector64_1<System_Internal.UInt32>): Vector64_1<System_Internal.UInt64>;
-    static WithElement<T>(vector: Vector64_1<T>, index: int, value: T): Vector64_1<T>;
-    static Xor<T>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
+    static WithElement<T extends unknown>(vector: Vector64_1<T>, index: int, value: T): Vector64_1<T>;
+    static Xor<T extends unknown>(left: Vector64_1<T>, right: Vector64_1<T>): Vector64_1<T>;
 }