@tsonic/dotnet 0.7.4 → 0.7.7

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

@@ -6,7 +6,7 @@
 import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/types';
 
 // Import support types from @tsonic/types
-import type { ptr, ref } from "@tsonic/types";
+import type { ptr } from "@tsonic/types";
 
 // Import types from other namespaces
 import * as System_Numerics_Internal from "../../System.Numerics/internal/index.js";
@@ -14,32 +14,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";
 
-// CLROf<T> - Maps ergonomic primitives to their CLR types for generic constraints
-// This utility is used ONLY in generic type arguments to satisfy CLR interface constraints
-// Value positions (parameters, return types) use lowercase primitives for ergonomics
-export type CLROf<T> =
-    T extends sbyte ? System_Internal.SByte :
-    T extends short ? System_Internal.Int16 :
-    T extends int ? System_Internal.Int32 :
-    T extends long ? System_Internal.Int64 :
-    T extends int128 ? System_Internal.Int128 :
-    T extends nint ? System_Internal.IntPtr :
-    T extends byte ? System_Internal.Byte :
-    T extends ushort ? System_Internal.UInt16 :
-    T extends uint ? System_Internal.UInt32 :
-    T extends ulong ? System_Internal.UInt64 :
-    T extends uint128 ? System_Internal.UInt128 :
-    T extends nuint ? System_Internal.UIntPtr :
-    T extends half ? System_Internal.Half :
-    T extends float ? System_Internal.Single :
-    T extends double ? System_Internal.Double :
-    T extends decimal ? System_Internal.Decimal :
-    T extends char ? System_Internal.Char :
-    T extends boolean ? System_Internal.Boolean :
-    T extends string ? System_Internal.String :
-    T; // Identity fallback for non-primitive types
-
-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>, CLROf<boolean>>, IMultiplyOperators_3<Vector128_1<T>, Vector128_1<T>, Vector128_1<T>>, IShiftOperators_3<Vector128_1<T>, CLROf<int>, 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>> {
+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>> {
     readonly item: T;
     equals(obj: unknown): boolean;
     equals(other: Vector128_1<T>): boolean;
@@ -66,12 +41,12 @@ export interface __Vector128_1$views<T> {
     equals(other: Vector128_1<T>): boolean;
 }
 
-export interface Vector128_1$instance<T> extends 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>, CLROf<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>, CLROf<int>, 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 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 type Vector128_1<T> = Vector128_1$instance<T> & __Vector128_1$views<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>, CLROf<boolean>>, IMultiplyOperators_3<Vector256_1<T>, Vector256_1<T>, Vector256_1<T>>, IShiftOperators_3<Vector256_1<T>, CLROf<int>, 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>> {
+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>> {
     readonly item: T;
     equals(obj: unknown): boolean;
     equals(other: Vector256_1<T>): boolean;
@@ -98,12 +73,12 @@ export interface __Vector256_1$views<T> {
     equals(other: Vector256_1<T>): boolean;
 }
 
-export interface Vector256_1$instance<T> extends 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>, CLROf<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>, CLROf<int>, 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 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 type Vector256_1<T> = Vector256_1$instance<T> & __Vector256_1$views<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>, CLROf<boolean>>, IMultiplyOperators_3<Vector512_1<T>, Vector512_1<T>, Vector512_1<T>>, IShiftOperators_3<Vector512_1<T>, CLROf<int>, 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>> {
+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>> {
     readonly item: T;
     equals(obj: unknown): boolean;
     equals(other: Vector512_1<T>): boolean;
@@ -130,12 +105,12 @@ export interface __Vector512_1$views<T> {
     equals(other: Vector512_1<T>): boolean;
 }
 
-export interface Vector512_1$instance<T> extends 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>, CLROf<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>, CLROf<int>, 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 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 type Vector512_1<T> = Vector512_1$instance<T> & __Vector512_1$views<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>, CLROf<boolean>>, IMultiplyOperators_3<Vector64_1<T>, Vector64_1<T>, Vector64_1<T>>, IShiftOperators_3<Vector64_1<T>, CLROf<int>, 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>> {
+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>> {
     readonly item: T;
     equals(obj: unknown): boolean;
     equals(other: Vector64_1<T>): boolean;
@@ -162,7 +137,7 @@ export interface __Vector64_1$views<T> {
     equals(other: Vector64_1<T>): boolean;
 }
 
-export interface Vector64_1$instance<T> extends 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>, CLROf<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>, CLROf<int>, 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 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 type Vector64_1<T> = Vector64_1$instance<T> & __Vector64_1$views<T>;
 
@@ -178,141 +153,141 @@ export abstract class Vector128$instance {
     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<CLROf<byte>>;
-    static asDouble<T>(vector: Vector128_1<T>): Vector128_1<CLROf<double>>;
-    static asInt16<T>(vector: Vector128_1<T>): Vector128_1<CLROf<short>>;
-    static asInt32<T>(vector: Vector128_1<T>): Vector128_1<CLROf<int>>;
-    static asInt64<T>(vector: Vector128_1<T>): Vector128_1<CLROf<long>>;
-    static asNInt<T>(vector: Vector128_1<T>): Vector128_1<CLROf<nint>>;
-    static asNUInt<T>(vector: Vector128_1<T>): Vector128_1<CLROf<nuint>>;
-    static asPlane(value: Vector128_1<CLROf<float>>): Plane;
-    static asQuaternion(value: Vector128_1<CLROf<float>>): Quaternion;
-    static asSByte<T>(vector: Vector128_1<T>): Vector128_1<CLROf<sbyte>>;
-    static asSingle<T>(vector: Vector128_1<T>): Vector128_1<CLROf<float>>;
-    static asUInt16<T>(vector: Vector128_1<T>): Vector128_1<CLROf<ushort>>;
-    static asUInt32<T>(vector: Vector128_1<T>): Vector128_1<CLROf<uint>>;
-    static asUInt64<T>(vector: Vector128_1<T>): Vector128_1<CLROf<ulong>>;
+    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 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 asVector128(value: Plane): Vector128_1<CLROf<float>>;
-    static asVector128(value: Quaternion): Vector128_1<CLROf<float>>;
-    static asVector128(value: Vector2): Vector128_1<CLROf<float>>;
-    static asVector128(value: Vector3): Vector128_1<CLROf<float>>;
-    static asVector128(value: Vector4): Vector128_1<CLROf<float>>;
+    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 asVector128Unsafe(value: Vector2): Vector128_1<CLROf<float>>;
-    static asVector128Unsafe(value: Vector3): Vector128_1<CLROf<float>>;
-    static asVector2(value: Vector128_1<CLROf<float>>): Vector2;
-    static asVector3(value: Vector128_1<CLROf<float>>): Vector3;
-    static asVector4(value: Vector128_1<CLROf<float>>): Vector4;
+    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 ceiling(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static ceiling(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    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 convertToDouble(vector: Vector128_1<CLROf<long>>): Vector128_1<CLROf<double>>;
-    static convertToDouble(vector: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<double>>;
-    static convertToInt32(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<int>>;
-    static convertToInt32Native(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<int>>;
-    static convertToInt64(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<long>>;
-    static convertToInt64Native(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<long>>;
-    static convertToSingle(vector: Vector128_1<CLROf<int>>): Vector128_1<CLROf<float>>;
-    static convertToSingle(vector: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<float>>;
-    static convertToUInt32(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<uint>>;
-    static convertToUInt32Native(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<uint>>;
-    static convertToUInt64(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<ulong>>;
-    static convertToUInt64Native(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<ulong>>;
+    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>;
+    static convertToInt32Native(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Int32>;
+    static convertToInt64(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Int64>;
+    static convertToInt64Native(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Int64>;
+    static convertToSingle(vector: Vector128_1<System_Internal.Int32>): Vector128_1<System_Internal.Single>;
+    static convertToSingle(vector: Vector128_1<System_Internal.UInt32>): Vector128_1<System_Internal.Single>;
+    static convertToUInt32(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.UInt32>;
+    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 cos(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static cos(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    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 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<CLROf<byte>>;
-    static create(value: byte): Vector128_1<CLROf<byte>>;
-    static create(e0: double, e1: double): Vector128_1<CLROf<double>>;
-    static create(value: double): Vector128_1<CLROf<double>>;
-    static create(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short): Vector128_1<CLROf<short>>;
-    static create(value: short): Vector128_1<CLROf<short>>;
-    static create(e0: int, e1: int, e2: int, e3: int): Vector128_1<CLROf<int>>;
-    static create(value: int): Vector128_1<CLROf<int>>;
-    static create(e0: long, e1: long): Vector128_1<CLROf<long>>;
-    static create(value: long): Vector128_1<CLROf<long>>;
-    static create(value: nint): Vector128_1<CLROf<nint>>;
-    static create(lower: Vector64_1<CLROf<byte>>, upper: Vector64_1<CLROf<byte>>): Vector128_1<CLROf<byte>>;
-    static create(lower: Vector64_1<CLROf<double>>, upper: Vector64_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static create(lower: Vector64_1<CLROf<short>>, upper: Vector64_1<CLROf<short>>): Vector128_1<CLROf<short>>;
-    static create(lower: Vector64_1<CLROf<int>>, upper: Vector64_1<CLROf<int>>): Vector128_1<CLROf<int>>;
-    static create(lower: Vector64_1<CLROf<long>>, upper: Vector64_1<CLROf<long>>): Vector128_1<CLROf<long>>;
-    static create(lower: Vector64_1<CLROf<nint>>, upper: Vector64_1<CLROf<nint>>): Vector128_1<CLROf<nint>>;
-    static create(lower: Vector64_1<CLROf<sbyte>>, upper: Vector64_1<CLROf<sbyte>>): Vector128_1<CLROf<sbyte>>;
-    static create(lower: Vector64_1<CLROf<float>>, upper: Vector64_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static create(lower: Vector64_1<CLROf<ushort>>, upper: Vector64_1<CLROf<ushort>>): Vector128_1<CLROf<ushort>>;
-    static create(lower: Vector64_1<CLROf<uint>>, upper: Vector64_1<CLROf<uint>>): Vector128_1<CLROf<uint>>;
-    static create(lower: Vector64_1<CLROf<ulong>>, upper: Vector64_1<CLROf<ulong>>): Vector128_1<CLROf<ulong>>;
-    static create(lower: Vector64_1<CLROf<nuint>>, upper: Vector64_1<CLROf<nuint>>): Vector128_1<CLROf<nuint>>;
-    static create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte): Vector128_1<CLROf<sbyte>>;
-    static create(value: sbyte): Vector128_1<CLROf<sbyte>>;
-    static create(e0: float, e1: float, e2: float, e3: float): Vector128_1<CLROf<float>>;
-    static create(value: float): Vector128_1<CLROf<float>>;
-    static create(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort): Vector128_1<CLROf<ushort>>;
-    static create(value: ushort): Vector128_1<CLROf<ushort>>;
-    static create(e0: uint, e1: uint, e2: uint, e3: uint): Vector128_1<CLROf<uint>>;
-    static create(value: uint): Vector128_1<CLROf<uint>>;
-    static create(e0: ulong, e1: ulong): Vector128_1<CLROf<ulong>>;
-    static create(value: ulong): Vector128_1<CLROf<ulong>>;
-    static create(value: nuint): Vector128_1<CLROf<nuint>>;
+    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>;
+    static create(value: double): Vector128_1<System_Internal.Double>;
+    static create(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short): Vector128_1<System_Internal.Int16>;
+    static create(value: short): Vector128_1<System_Internal.Int16>;
+    static create(e0: int, e1: int, e2: int, e3: int): Vector128_1<System_Internal.Int32>;
+    static create(value: int): Vector128_1<System_Internal.Int32>;
+    static create(e0: long, e1: long): Vector128_1<System_Internal.Int64>;
+    static create(value: long): Vector128_1<System_Internal.Int64>;
+    static create(value: nint): Vector128_1<System_Internal.IntPtr>;
+    static create(lower: Vector64_1<System_Internal.Byte>, upper: Vector64_1<System_Internal.Byte>): Vector128_1<System_Internal.Byte>;
+    static create(lower: Vector64_1<System_Internal.Double>, upper: Vector64_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
+    static create(lower: Vector64_1<System_Internal.Int16>, upper: Vector64_1<System_Internal.Int16>): Vector128_1<System_Internal.Int16>;
+    static create(lower: Vector64_1<System_Internal.Int32>, upper: Vector64_1<System_Internal.Int32>): Vector128_1<System_Internal.Int32>;
+    static create(lower: Vector64_1<System_Internal.Int64>, upper: Vector64_1<System_Internal.Int64>): Vector128_1<System_Internal.Int64>;
+    static create(lower: Vector64_1<System_Internal.IntPtr>, upper: Vector64_1<System_Internal.IntPtr>): Vector128_1<System_Internal.IntPtr>;
+    static create(lower: Vector64_1<System_Internal.SByte>, upper: Vector64_1<System_Internal.SByte>): Vector128_1<System_Internal.SByte>;
+    static create(lower: Vector64_1<System_Internal.Single>, upper: Vector64_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
+    static create(lower: Vector64_1<System_Internal.UInt16>, upper: Vector64_1<System_Internal.UInt16>): Vector128_1<System_Internal.UInt16>;
+    static create(lower: Vector64_1<System_Internal.UInt32>, upper: Vector64_1<System_Internal.UInt32>): Vector128_1<System_Internal.UInt32>;
+    static create(lower: Vector64_1<System_Internal.UInt64>, upper: Vector64_1<System_Internal.UInt64>): Vector128_1<System_Internal.UInt64>;
+    static create(lower: Vector64_1<System_Internal.UIntPtr>, upper: Vector64_1<System_Internal.UIntPtr>): Vector128_1<System_Internal.UIntPtr>;
+    static create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte): Vector128_1<System_Internal.SByte>;
+    static create(value: sbyte): Vector128_1<System_Internal.SByte>;
+    static create(e0: float, e1: float, e2: float, e3: float): Vector128_1<System_Internal.Single>;
+    static create(value: float): Vector128_1<System_Internal.Single>;
+    static create(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort): Vector128_1<System_Internal.UInt16>;
+    static create(value: ushort): Vector128_1<System_Internal.UInt16>;
+    static create(e0: uint, e1: uint, e2: uint, e3: uint): Vector128_1<System_Internal.UInt32>;
+    static create(value: uint): Vector128_1<System_Internal.UInt32>;
+    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 createScalar(value: byte): Vector128_1<CLROf<byte>>;
-    static createScalar(value: double): Vector128_1<CLROf<double>>;
-    static createScalar(value: short): Vector128_1<CLROf<short>>;
-    static createScalar(value: int): Vector128_1<CLROf<int>>;
-    static createScalar(value: long): Vector128_1<CLROf<long>>;
-    static createScalar(value: nint): Vector128_1<CLROf<nint>>;
-    static createScalar(value: sbyte): Vector128_1<CLROf<sbyte>>;
-    static createScalar(value: float): Vector128_1<CLROf<float>>;
-    static createScalar(value: ushort): Vector128_1<CLROf<ushort>>;
-    static createScalar(value: uint): Vector128_1<CLROf<uint>>;
-    static createScalar(value: ulong): Vector128_1<CLROf<ulong>>;
-    static createScalar(value: nuint): Vector128_1<CLROf<nuint>>;
+    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>;
+    static createScalar(value: int): Vector128_1<System_Internal.Int32>;
+    static createScalar(value: long): Vector128_1<System_Internal.Int64>;
+    static createScalar(value: nint): Vector128_1<System_Internal.IntPtr>;
+    static createScalar(value: sbyte): Vector128_1<System_Internal.SByte>;
+    static createScalar(value: float): Vector128_1<System_Internal.Single>;
+    static createScalar(value: ushort): Vector128_1<System_Internal.UInt16>;
+    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 createScalarUnsafe(value: byte): Vector128_1<CLROf<byte>>;
-    static createScalarUnsafe(value: double): Vector128_1<CLROf<double>>;
-    static createScalarUnsafe(value: short): Vector128_1<CLROf<short>>;
-    static createScalarUnsafe(value: int): Vector128_1<CLROf<int>>;
-    static createScalarUnsafe(value: long): Vector128_1<CLROf<long>>;
-    static createScalarUnsafe(value: nint): Vector128_1<CLROf<nint>>;
-    static createScalarUnsafe(value: sbyte): Vector128_1<CLROf<sbyte>>;
-    static createScalarUnsafe(value: float): Vector128_1<CLROf<float>>;
-    static createScalarUnsafe(value: ushort): Vector128_1<CLROf<ushort>>;
-    static createScalarUnsafe(value: uint): Vector128_1<CLROf<uint>>;
-    static createScalarUnsafe(value: ulong): Vector128_1<CLROf<ulong>>;
-    static createScalarUnsafe(value: nuint): Vector128_1<CLROf<nuint>>;
+    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>;
+    static createScalarUnsafe(value: int): Vector128_1<System_Internal.Int32>;
+    static createScalarUnsafe(value: long): Vector128_1<System_Internal.Int64>;
+    static createScalarUnsafe(value: nint): Vector128_1<System_Internal.IntPtr>;
+    static createScalarUnsafe(value: sbyte): Vector128_1<System_Internal.SByte>;
+    static createScalarUnsafe(value: float): Vector128_1<System_Internal.Single>;
+    static createScalarUnsafe(value: ushort): Vector128_1<System_Internal.UInt16>;
+    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 degreesToRadians(degrees: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static degreesToRadians(degrees: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    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 exp(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static exp(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    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 floor(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static floor(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static fusedMultiplyAdd(left: Vector128_1<CLROf<double>>, right: Vector128_1<CLROf<double>>, addend: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static fusedMultiplyAdd(left: Vector128_1<CLROf<float>>, right: Vector128_1<CLROf<float>>, addend: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    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>;
@@ -322,8 +297,8 @@ export abstract class Vector128$instance {
     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 hypot(x: Vector128_1<CLROf<double>>, y: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static hypot(x: Vector128_1<CLROf<float>>, y: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    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>;
@@ -341,8 +316,8 @@ export abstract class Vector128$instance {
     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 lerp(x: Vector128_1<CLROf<double>>, y: Vector128_1<CLROf<double>>, amount: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static lerp(x: Vector128_1<CLROf<float>>, y: Vector128_1<CLROf<float>>, amount: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    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;
@@ -352,12 +327,12 @@ export abstract class Vector128$instance {
     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: { value: ref<T> }, elementOffset: nuint): Vector128_1<T>;
-    static loadUnsafe<T>(source: { value: ref<T> }): Vector128_1<T>;
-    static log(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static log(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static log2(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static log2(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    static loadUnsafe<T>(source: T, elementOffset: nuint): Vector128_1<T>;
+    static loadUnsafe<T>(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>;
@@ -371,117 +346,117 @@ export abstract class Vector128$instance {
     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 multiplyAddEstimate(left: Vector128_1<CLROf<double>>, right: Vector128_1<CLROf<double>>, addend: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static multiplyAddEstimate(left: Vector128_1<CLROf<float>>, right: Vector128_1<CLROf<float>>, addend: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static narrow(lower: Vector128_1<CLROf<double>>, upper: Vector128_1<CLROf<double>>): Vector128_1<CLROf<float>>;
-    static narrow(lower: Vector128_1<CLROf<short>>, upper: Vector128_1<CLROf<short>>): Vector128_1<CLROf<sbyte>>;
-    static narrow(lower: Vector128_1<CLROf<int>>, upper: Vector128_1<CLROf<int>>): Vector128_1<CLROf<short>>;
-    static narrow(lower: Vector128_1<CLROf<long>>, upper: Vector128_1<CLROf<long>>): Vector128_1<CLROf<int>>;
-    static narrow(lower: Vector128_1<CLROf<ushort>>, upper: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<byte>>;
-    static narrow(lower: Vector128_1<CLROf<uint>>, upper: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ushort>>;
-    static narrow(lower: Vector128_1<CLROf<ulong>>, upper: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<uint>>;
-    static narrowWithSaturation(lower: Vector128_1<CLROf<double>>, upper: Vector128_1<CLROf<double>>): Vector128_1<CLROf<float>>;
-    static narrowWithSaturation(lower: Vector128_1<CLROf<short>>, upper: Vector128_1<CLROf<short>>): Vector128_1<CLROf<sbyte>>;
-    static narrowWithSaturation(lower: Vector128_1<CLROf<int>>, upper: Vector128_1<CLROf<int>>): Vector128_1<CLROf<short>>;
-    static narrowWithSaturation(lower: Vector128_1<CLROf<long>>, upper: Vector128_1<CLROf<long>>): Vector128_1<CLROf<int>>;
-    static narrowWithSaturation(lower: Vector128_1<CLROf<ushort>>, upper: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<byte>>;
-    static narrowWithSaturation(lower: Vector128_1<CLROf<uint>>, upper: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ushort>>;
-    static narrowWithSaturation(lower: Vector128_1<CLROf<ulong>>, upper: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<uint>>;
+    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>;
+    static narrow(lower: Vector128_1<System_Internal.Int16>, upper: Vector128_1<System_Internal.Int16>): Vector128_1<System_Internal.SByte>;
+    static narrow(lower: Vector128_1<System_Internal.Int32>, upper: Vector128_1<System_Internal.Int32>): Vector128_1<System_Internal.Int16>;
+    static narrow(lower: Vector128_1<System_Internal.Int64>, upper: Vector128_1<System_Internal.Int64>): Vector128_1<System_Internal.Int32>;
+    static narrow(lower: Vector128_1<System_Internal.UInt16>, upper: Vector128_1<System_Internal.UInt16>): Vector128_1<System_Internal.Byte>;
+    static narrow(lower: Vector128_1<System_Internal.UInt32>, upper: Vector128_1<System_Internal.UInt32>): Vector128_1<System_Internal.UInt16>;
+    static narrow(lower: Vector128_1<System_Internal.UInt64>, upper: Vector128_1<System_Internal.UInt64>): Vector128_1<System_Internal.UInt32>;
+    static narrowWithSaturation(lower: Vector128_1<System_Internal.Double>, upper: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Single>;
+    static narrowWithSaturation(lower: Vector128_1<System_Internal.Int16>, upper: Vector128_1<System_Internal.Int16>): Vector128_1<System_Internal.SByte>;
+    static narrowWithSaturation(lower: Vector128_1<System_Internal.Int32>, upper: Vector128_1<System_Internal.Int32>): Vector128_1<System_Internal.Int16>;
+    static narrowWithSaturation(lower: Vector128_1<System_Internal.Int64>, upper: Vector128_1<System_Internal.Int64>): Vector128_1<System_Internal.Int32>;
+    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 radiansToDegrees(radians: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static radiansToDegrees(radians: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static round(vector: Vector128_1<CLROf<double>>, mode: MidpointRounding): Vector128_1<CLROf<double>>;
-    static round(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static round(vector: Vector128_1<CLROf<float>>, mode: MidpointRounding): Vector128_1<CLROf<float>>;
-    static round(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static shiftLeft(vector: Vector128_1<CLROf<byte>>, shiftCount: int): Vector128_1<CLROf<byte>>;
-    static shiftLeft(vector: Vector128_1<CLROf<short>>, shiftCount: int): Vector128_1<CLROf<short>>;
-    static shiftLeft(vector: Vector128_1<CLROf<int>>, shiftCount: int): Vector128_1<CLROf<int>>;
-    static shiftLeft(vector: Vector128_1<CLROf<long>>, shiftCount: int): Vector128_1<CLROf<long>>;
-    static shiftLeft(vector: Vector128_1<CLROf<nint>>, shiftCount: int): Vector128_1<CLROf<nint>>;
-    static shiftLeft(vector: Vector128_1<CLROf<sbyte>>, shiftCount: int): Vector128_1<CLROf<sbyte>>;
-    static shiftLeft(vector: Vector128_1<CLROf<ushort>>, shiftCount: int): Vector128_1<CLROf<ushort>>;
-    static shiftLeft(vector: Vector128_1<CLROf<uint>>, shiftCount: int): Vector128_1<CLROf<uint>>;
-    static shiftLeft(vector: Vector128_1<CLROf<ulong>>, shiftCount: int): Vector128_1<CLROf<ulong>>;
-    static shiftLeft(vector: Vector128_1<CLROf<nuint>>, shiftCount: int): Vector128_1<CLROf<nuint>>;
-    static shiftRightArithmetic(vector: Vector128_1<CLROf<short>>, shiftCount: int): Vector128_1<CLROf<short>>;
-    static shiftRightArithmetic(vector: Vector128_1<CLROf<int>>, shiftCount: int): Vector128_1<CLROf<int>>;
-    static shiftRightArithmetic(vector: Vector128_1<CLROf<long>>, shiftCount: int): Vector128_1<CLROf<long>>;
-    static shiftRightArithmetic(vector: Vector128_1<CLROf<nint>>, shiftCount: int): Vector128_1<CLROf<nint>>;
-    static shiftRightArithmetic(vector: Vector128_1<CLROf<sbyte>>, shiftCount: int): Vector128_1<CLROf<sbyte>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<byte>>, shiftCount: int): Vector128_1<CLROf<byte>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<short>>, shiftCount: int): Vector128_1<CLROf<short>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<int>>, shiftCount: int): Vector128_1<CLROf<int>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<long>>, shiftCount: int): Vector128_1<CLROf<long>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<nint>>, shiftCount: int): Vector128_1<CLROf<nint>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<sbyte>>, shiftCount: int): Vector128_1<CLROf<sbyte>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<ushort>>, shiftCount: int): Vector128_1<CLROf<ushort>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<uint>>, shiftCount: int): Vector128_1<CLROf<uint>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<ulong>>, shiftCount: int): Vector128_1<CLROf<ulong>>;
-    static shiftRightLogical(vector: Vector128_1<CLROf<nuint>>, shiftCount: int): Vector128_1<CLROf<nuint>>;
-    static shuffle(vector: Vector128_1<CLROf<byte>>, indices: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<byte>>;
-    static shuffle(vector: Vector128_1<CLROf<double>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<double>>;
-    static shuffle(vector: Vector128_1<CLROf<short>>, indices: Vector128_1<CLROf<short>>): Vector128_1<CLROf<short>>;
-    static shuffle(vector: Vector128_1<CLROf<int>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<int>>;
-    static shuffle(vector: Vector128_1<CLROf<long>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<long>>;
-    static shuffle(vector: Vector128_1<CLROf<sbyte>>, indices: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<sbyte>>;
-    static shuffle(vector: Vector128_1<CLROf<float>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<float>>;
-    static shuffle(vector: Vector128_1<CLROf<ushort>>, indices: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<ushort>>;
-    static shuffle(vector: Vector128_1<CLROf<uint>>, indices: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<uint>>;
-    static shuffle(vector: Vector128_1<CLROf<ulong>>, indices: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<ulong>>;
-    static shuffleNative(vector: Vector128_1<CLROf<byte>>, indices: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<byte>>;
-    static shuffleNative(vector: Vector128_1<CLROf<double>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<double>>;
-    static shuffleNative(vector: Vector128_1<CLROf<short>>, indices: Vector128_1<CLROf<short>>): Vector128_1<CLROf<short>>;
-    static shuffleNative(vector: Vector128_1<CLROf<int>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<int>>;
-    static shuffleNative(vector: Vector128_1<CLROf<long>>, indices: Vector128_1<CLROf<long>>): Vector128_1<CLROf<long>>;
-    static shuffleNative(vector: Vector128_1<CLROf<sbyte>>, indices: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<sbyte>>;
-    static shuffleNative(vector: Vector128_1<CLROf<float>>, indices: Vector128_1<CLROf<int>>): Vector128_1<CLROf<float>>;
-    static shuffleNative(vector: Vector128_1<CLROf<ushort>>, indices: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<ushort>>;
-    static shuffleNative(vector: Vector128_1<CLROf<uint>>, indices: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<uint>>;
-    static shuffleNative(vector: Vector128_1<CLROf<ulong>>, indices: Vector128_1<CLROf<ulong>>): Vector128_1<CLROf<ulong>>;
-    static sin(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static sin(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
-    static sinCos(vector: Vector128_1<CLROf<double>>): ValueTuple_2<Vector128_1<CLROf<double>>, Vector128_1<CLROf<double>>>;
-    static sinCos(vector: Vector128_1<CLROf<float>>): ValueTuple_2<Vector128_1<CLROf<float>>, Vector128_1<CLROf<float>>>;
+    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>;
+    static round(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
+    static round(vector: Vector128_1<System_Internal.Single>, mode: MidpointRounding): Vector128_1<System_Internal.Single>;
+    static round(vector: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Single>;
+    static shiftLeft(vector: Vector128_1<System_Internal.Byte>, shiftCount: int): Vector128_1<System_Internal.Byte>;
+    static shiftLeft(vector: Vector128_1<System_Internal.Int16>, shiftCount: int): Vector128_1<System_Internal.Int16>;
+    static shiftLeft(vector: Vector128_1<System_Internal.Int32>, shiftCount: int): Vector128_1<System_Internal.Int32>;
+    static shiftLeft(vector: Vector128_1<System_Internal.Int64>, shiftCount: int): Vector128_1<System_Internal.Int64>;
+    static shiftLeft(vector: Vector128_1<System_Internal.IntPtr>, shiftCount: int): Vector128_1<System_Internal.IntPtr>;
+    static shiftLeft(vector: Vector128_1<System_Internal.SByte>, shiftCount: int): Vector128_1<System_Internal.SByte>;
+    static shiftLeft(vector: Vector128_1<System_Internal.UInt16>, shiftCount: int): Vector128_1<System_Internal.UInt16>;
+    static shiftLeft(vector: Vector128_1<System_Internal.UInt32>, shiftCount: int): Vector128_1<System_Internal.UInt32>;
+    static shiftLeft(vector: Vector128_1<System_Internal.UInt64>, shiftCount: int): Vector128_1<System_Internal.UInt64>;
+    static shiftLeft(vector: Vector128_1<System_Internal.UIntPtr>, shiftCount: int): Vector128_1<System_Internal.UIntPtr>;
+    static shiftRightArithmetic(vector: Vector128_1<System_Internal.Int16>, shiftCount: int): Vector128_1<System_Internal.Int16>;
+    static shiftRightArithmetic(vector: Vector128_1<System_Internal.Int32>, shiftCount: int): Vector128_1<System_Internal.Int32>;
+    static shiftRightArithmetic(vector: Vector128_1<System_Internal.Int64>, shiftCount: int): Vector128_1<System_Internal.Int64>;
+    static shiftRightArithmetic(vector: Vector128_1<System_Internal.IntPtr>, shiftCount: int): Vector128_1<System_Internal.IntPtr>;
+    static shiftRightArithmetic(vector: Vector128_1<System_Internal.SByte>, shiftCount: int): Vector128_1<System_Internal.SByte>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.Byte>, shiftCount: int): Vector128_1<System_Internal.Byte>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.Int16>, shiftCount: int): Vector128_1<System_Internal.Int16>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.Int32>, shiftCount: int): Vector128_1<System_Internal.Int32>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.Int64>, shiftCount: int): Vector128_1<System_Internal.Int64>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.IntPtr>, shiftCount: int): Vector128_1<System_Internal.IntPtr>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.SByte>, shiftCount: int): Vector128_1<System_Internal.SByte>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.UInt16>, shiftCount: int): Vector128_1<System_Internal.UInt16>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.UInt32>, shiftCount: int): Vector128_1<System_Internal.UInt32>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.UInt64>, shiftCount: int): Vector128_1<System_Internal.UInt64>;
+    static shiftRightLogical(vector: Vector128_1<System_Internal.UIntPtr>, shiftCount: int): Vector128_1<System_Internal.UIntPtr>;
+    static shuffle(vector: Vector128_1<System_Internal.Byte>, indices: Vector128_1<System_Internal.Byte>): Vector128_1<System_Internal.Byte>;
+    static shuffle(vector: Vector128_1<System_Internal.Double>, indices: Vector128_1<System_Internal.Int64>): Vector128_1<System_Internal.Double>;
+    static shuffle(vector: Vector128_1<System_Internal.Int16>, indices: Vector128_1<System_Internal.Int16>): Vector128_1<System_Internal.Int16>;
+    static shuffle(vector: Vector128_1<System_Internal.Int32>, indices: Vector128_1<System_Internal.Int32>): Vector128_1<System_Internal.Int32>;
+    static shuffle(vector: Vector128_1<System_Internal.Int64>, indices: Vector128_1<System_Internal.Int64>): Vector128_1<System_Internal.Int64>;
+    static shuffle(vector: Vector128_1<System_Internal.SByte>, indices: Vector128_1<System_Internal.SByte>): Vector128_1<System_Internal.SByte>;
+    static shuffle(vector: Vector128_1<System_Internal.Single>, indices: Vector128_1<System_Internal.Int32>): Vector128_1<System_Internal.Single>;
+    static shuffle(vector: Vector128_1<System_Internal.UInt16>, indices: Vector128_1<System_Internal.UInt16>): Vector128_1<System_Internal.UInt16>;
+    static shuffle(vector: Vector128_1<System_Internal.UInt32>, indices: Vector128_1<System_Internal.UInt32>): Vector128_1<System_Internal.UInt32>;
+    static shuffle(vector: Vector128_1<System_Internal.UInt64>, indices: Vector128_1<System_Internal.UInt64>): Vector128_1<System_Internal.UInt64>;
+    static shuffleNative(vector: Vector128_1<System_Internal.Byte>, indices: Vector128_1<System_Internal.Byte>): Vector128_1<System_Internal.Byte>;
+    static shuffleNative(vector: Vector128_1<System_Internal.Double>, indices: Vector128_1<System_Internal.Int64>): Vector128_1<System_Internal.Double>;
+    static shuffleNative(vector: Vector128_1<System_Internal.Int16>, indices: Vector128_1<System_Internal.Int16>): Vector128_1<System_Internal.Int16>;
+    static shuffleNative(vector: Vector128_1<System_Internal.Int32>, indices: Vector128_1<System_Internal.Int32>): Vector128_1<System_Internal.Int32>;
+    static shuffleNative(vector: Vector128_1<System_Internal.Int64>, indices: Vector128_1<System_Internal.Int64>): Vector128_1<System_Internal.Int64>;
+    static shuffleNative(vector: Vector128_1<System_Internal.SByte>, indices: Vector128_1<System_Internal.SByte>): Vector128_1<System_Internal.SByte>;
+    static shuffleNative(vector: Vector128_1<System_Internal.Single>, indices: Vector128_1<System_Internal.Int32>): Vector128_1<System_Internal.Single>;
+    static shuffleNative(vector: Vector128_1<System_Internal.UInt16>, indices: Vector128_1<System_Internal.UInt16>): Vector128_1<System_Internal.UInt16>;
+    static shuffleNative(vector: Vector128_1<System_Internal.UInt32>, indices: Vector128_1<System_Internal.UInt32>): Vector128_1<System_Internal.UInt32>;
+    static shuffleNative(vector: Vector128_1<System_Internal.UInt64>, indices: Vector128_1<System_Internal.UInt64>): Vector128_1<System_Internal.UInt64>;
+    static sin(vector: Vector128_1<System_Internal.Double>): Vector128_1<System_Internal.Double>;
+    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: { value: ref<T> }, elementOffset: nuint): void;
-    static storeUnsafe<T>(source: Vector128_1<T>, destination: { value: ref<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 truncate(vector: Vector128_1<CLROf<double>>): Vector128_1<CLROf<double>>;
-    static truncate(vector: Vector128_1<CLROf<float>>): Vector128_1<CLROf<float>>;
+    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 widen(source: Vector128_1<CLROf<byte>>): ValueTuple_2<Vector128_1<CLROf<ushort>>, Vector128_1<CLROf<ushort>>>;
-    static widen(source: Vector128_1<CLROf<short>>): ValueTuple_2<Vector128_1<CLROf<int>>, Vector128_1<CLROf<int>>>;
-    static widen(source: Vector128_1<CLROf<int>>): ValueTuple_2<Vector128_1<CLROf<long>>, Vector128_1<CLROf<long>>>;
-    static widen(source: Vector128_1<CLROf<sbyte>>): ValueTuple_2<Vector128_1<CLROf<short>>, Vector128_1<CLROf<short>>>;
-    static widen(source: Vector128_1<CLROf<float>>): ValueTuple_2<Vector128_1<CLROf<double>>, Vector128_1<CLROf<double>>>;
-    static widen(source: Vector128_1<CLROf<ushort>>): ValueTuple_2<Vector128_1<CLROf<uint>>, Vector128_1<CLROf<uint>>>;
-    static widen(source: Vector128_1<CLROf<uint>>): ValueTuple_2<Vector128_1<CLROf<ulong>>, Vector128_1<CLROf<ulong>>>;
-    static widenLower(source: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<ushort>>;
-    static widenLower(source: Vector128_1<CLROf<short>>): Vector128_1<CLROf<int>>;
-    static widenLower(source: Vector128_1<CLROf<int>>): Vector128_1<CLROf<long>>;
-    static widenLower(source: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<short>>;
-    static widenLower(source: Vector128_1<CLROf<float>>): Vector128_1<CLROf<double>>;
-    static widenLower(source: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<uint>>;
-    static widenLower(source: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ulong>>;
-    static widenUpper(source: Vector128_1<CLROf<byte>>): Vector128_1<CLROf<ushort>>;
-    static widenUpper(source: Vector128_1<CLROf<short>>): Vector128_1<CLROf<int>>;
-    static widenUpper(source: Vector128_1<CLROf<int>>): Vector128_1<CLROf<long>>;
-    static widenUpper(source: Vector128_1<CLROf<sbyte>>): Vector128_1<CLROf<short>>;
-    static widenUpper(source: Vector128_1<CLROf<float>>): Vector128_1<CLROf<double>>;
-    static widenUpper(source: Vector128_1<CLROf<ushort>>): Vector128_1<CLROf<uint>>;
-    static widenUpper(source: Vector128_1<CLROf<uint>>): Vector128_1<CLROf<ulong>>;
+    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>>;
+    static widen(source: Vector128_1<System_Internal.SByte>): ValueTuple_2<Vector128_1<System_Internal.Int16>, Vector128_1<System_Internal.Int16>>;
+    static widen(source: Vector128_1<System_Internal.Single>): ValueTuple_2<Vector128_1<System_Internal.Double>, Vector128_1<System_Internal.Double>>;
+    static widen(source: Vector128_1<System_Internal.UInt16>): ValueTuple_2<Vector128_1<System_Internal.UInt32>, Vector128_1<System_Internal.UInt32>>;
+    static widen(source: Vector128_1<System_Internal.UInt32>): ValueTuple_2<Vector128_1<System_Internal.UInt64>, Vector128_1<System_Internal.UInt64>>;
+    static widenLower(source: Vector128_1<System_Internal.Byte>): Vector128_1<System_Internal.UInt16>;
+    static widenLower(source: Vector128_1<System_Internal.Int16>): Vector128_1<System_Internal.Int32>;
+    static widenLower(source: Vector128_1<System_Internal.Int32>): Vector128_1<System_Internal.Int64>;
+    static widenLower(source: Vector128_1<System_Internal.SByte>): Vector128_1<System_Internal.Int16>;
+    static widenLower(source: Vector128_1<System_Internal.Single>): Vector128_1<System_Internal.Double>;
+    static widenLower(source: Vector128_1<System_Internal.UInt16>): Vector128_1<System_Internal.UInt32>;
+    static widenLower(source: Vector128_1<System_Internal.UInt32>): Vector128_1<System_Internal.UInt64>;
+    static widenUpper(source: Vector128_1<System_Internal.Byte>): Vector128_1<System_Internal.UInt16>;
+    static widenUpper(source: Vector128_1<System_Internal.Int16>): Vector128_1<System_Internal.Int32>;
+    static widenUpper(source: Vector128_1<System_Internal.Int32>): Vector128_1<System_Internal.Int64>;
+    static widenUpper(source: Vector128_1<System_Internal.SByte>): Vector128_1<System_Internal.Int16>;
+    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>;
@@ -502,130 +477,130 @@ export abstract class Vector256$instance {
     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<CLROf<byte>>;
-    static asDouble<T>(vector: Vector256_1<T>): Vector256_1<CLROf<double>>;
-    static asInt16<T>(vector: Vector256_1<T>): Vector256_1<CLROf<short>>;
-    static asInt32<T>(vector: Vector256_1<T>): Vector256_1<CLROf<int>>;
-    static asInt64<T>(vector: Vector256_1<T>): Vector256_1<CLROf<long>>;
-    static asNInt<T>(vector: Vector256_1<T>): Vector256_1<CLROf<nint>>;
-    static asNUInt<T>(vector: Vector256_1<T>): Vector256_1<CLROf<nuint>>;
-    static asSByte<T>(vector: Vector256_1<T>): Vector256_1<CLROf<sbyte>>;
-    static asSingle<T>(vector: Vector256_1<T>): Vector256_1<CLROf<float>>;
-    static asUInt16<T>(vector: Vector256_1<T>): Vector256_1<CLROf<ushort>>;
-    static asUInt32<T>(vector: Vector256_1<T>): Vector256_1<CLROf<uint>>;
-    static asUInt64<T>(vector: Vector256_1<T>): Vector256_1<CLROf<ulong>>;
+    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 ceiling(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static ceiling(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    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 convertToDouble(vector: Vector256_1<CLROf<long>>): Vector256_1<CLROf<double>>;
-    static convertToDouble(vector: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<double>>;
-    static convertToInt32(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<int>>;
-    static convertToInt32Native(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<int>>;
-    static convertToInt64(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<long>>;
-    static convertToInt64Native(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<long>>;
-    static convertToSingle(vector: Vector256_1<CLROf<int>>): Vector256_1<CLROf<float>>;
-    static convertToSingle(vector: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<float>>;
-    static convertToUInt32(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<uint>>;
-    static convertToUInt32Native(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<uint>>;
-    static convertToUInt64(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<ulong>>;
-    static convertToUInt64Native(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<ulong>>;
+    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>;
+    static convertToInt32Native(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Int32>;
+    static convertToInt64(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Int64>;
+    static convertToInt64Native(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Int64>;
+    static convertToSingle(vector: Vector256_1<System_Internal.Int32>): Vector256_1<System_Internal.Single>;
+    static convertToSingle(vector: Vector256_1<System_Internal.UInt32>): Vector256_1<System_Internal.Single>;
+    static convertToUInt32(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.UInt32>;
+    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 cos(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static cos(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    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 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<CLROf<byte>>;
-    static create(value: byte): Vector256_1<CLROf<byte>>;
-    static create(e0: double, e1: double, e2: double, e3: double): Vector256_1<CLROf<double>>;
-    static create(value: double): Vector256_1<CLROf<double>>;
-    static create(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short, e8: short, e9: short, e10: short, e11: short, e12: short, e13: short, e14: short, e15: short): Vector256_1<CLROf<short>>;
-    static create(value: short): Vector256_1<CLROf<short>>;
-    static create(e0: int, e1: int, e2: int, e3: int, e4: int, e5: int, e6: int, e7: int): Vector256_1<CLROf<int>>;
-    static create(value: int): Vector256_1<CLROf<int>>;
-    static create(e0: long, e1: long, e2: long, e3: long): Vector256_1<CLROf<long>>;
-    static create(value: long): Vector256_1<CLROf<long>>;
-    static create(value: nint): Vector256_1<CLROf<nint>>;
-    static create(lower: Vector128_1<CLROf<byte>>, upper: Vector128_1<CLROf<byte>>): Vector256_1<CLROf<byte>>;
-    static create(lower: Vector128_1<CLROf<double>>, upper: Vector128_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static create(lower: Vector128_1<CLROf<short>>, upper: Vector128_1<CLROf<short>>): Vector256_1<CLROf<short>>;
-    static create(lower: Vector128_1<CLROf<int>>, upper: Vector128_1<CLROf<int>>): Vector256_1<CLROf<int>>;
-    static create(lower: Vector128_1<CLROf<long>>, upper: Vector128_1<CLROf<long>>): Vector256_1<CLROf<long>>;
-    static create(lower: Vector128_1<CLROf<nint>>, upper: Vector128_1<CLROf<nint>>): Vector256_1<CLROf<nint>>;
-    static create(lower: Vector128_1<CLROf<sbyte>>, upper: Vector128_1<CLROf<sbyte>>): Vector256_1<CLROf<sbyte>>;
-    static create(lower: Vector128_1<CLROf<float>>, upper: Vector128_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static create(lower: Vector128_1<CLROf<ushort>>, upper: Vector128_1<CLROf<ushort>>): Vector256_1<CLROf<ushort>>;
-    static create(lower: Vector128_1<CLROf<uint>>, upper: Vector128_1<CLROf<uint>>): Vector256_1<CLROf<uint>>;
-    static create(lower: Vector128_1<CLROf<ulong>>, upper: Vector128_1<CLROf<ulong>>): Vector256_1<CLROf<ulong>>;
-    static create(lower: Vector128_1<CLROf<nuint>>, upper: Vector128_1<CLROf<nuint>>): Vector256_1<CLROf<nuint>>;
-    static create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte, e16: sbyte, e17: sbyte, e18: sbyte, e19: sbyte, e20: sbyte, e21: sbyte, e22: sbyte, e23: sbyte, e24: sbyte, e25: sbyte, e26: sbyte, e27: sbyte, e28: sbyte, e29: sbyte, e30: sbyte, e31: sbyte): Vector256_1<CLROf<sbyte>>;
-    static create(value: sbyte): Vector256_1<CLROf<sbyte>>;
-    static create(e0: float, e1: float, e2: float, e3: float, e4: float, e5: float, e6: float, e7: float): Vector256_1<CLROf<float>>;
-    static create(value: float): Vector256_1<CLROf<float>>;
-    static create(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort, e8: ushort, e9: ushort, e10: ushort, e11: ushort, e12: ushort, e13: ushort, e14: ushort, e15: ushort): Vector256_1<CLROf<ushort>>;
-    static create(value: ushort): Vector256_1<CLROf<ushort>>;
-    static create(e0: uint, e1: uint, e2: uint, e3: uint, e4: uint, e5: uint, e6: uint, e7: uint): Vector256_1<CLROf<uint>>;
-    static create(value: uint): Vector256_1<CLROf<uint>>;
-    static create(e0: ulong, e1: ulong, e2: ulong, e3: ulong): Vector256_1<CLROf<ulong>>;
-    static create(value: ulong): Vector256_1<CLROf<ulong>>;
-    static create(value: nuint): Vector256_1<CLROf<nuint>>;
+    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>;
+    static create(value: double): Vector256_1<System_Internal.Double>;
+    static create(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short, e8: short, e9: short, e10: short, e11: short, e12: short, e13: short, e14: short, e15: short): Vector256_1<System_Internal.Int16>;
+    static create(value: short): Vector256_1<System_Internal.Int16>;
+    static create(e0: int, e1: int, e2: int, e3: int, e4: int, e5: int, e6: int, e7: int): Vector256_1<System_Internal.Int32>;
+    static create(value: int): Vector256_1<System_Internal.Int32>;
+    static create(e0: long, e1: long, e2: long, e3: long): Vector256_1<System_Internal.Int64>;
+    static create(value: long): Vector256_1<System_Internal.Int64>;
+    static create(value: nint): Vector256_1<System_Internal.IntPtr>;
+    static create(lower: Vector128_1<System_Internal.Byte>, upper: Vector128_1<System_Internal.Byte>): Vector256_1<System_Internal.Byte>;
+    static create(lower: Vector128_1<System_Internal.Double>, upper: Vector128_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
+    static create(lower: Vector128_1<System_Internal.Int16>, upper: Vector128_1<System_Internal.Int16>): Vector256_1<System_Internal.Int16>;
+    static create(lower: Vector128_1<System_Internal.Int32>, upper: Vector128_1<System_Internal.Int32>): Vector256_1<System_Internal.Int32>;
+    static create(lower: Vector128_1<System_Internal.Int64>, upper: Vector128_1<System_Internal.Int64>): Vector256_1<System_Internal.Int64>;
+    static create(lower: Vector128_1<System_Internal.IntPtr>, upper: Vector128_1<System_Internal.IntPtr>): Vector256_1<System_Internal.IntPtr>;
+    static create(lower: Vector128_1<System_Internal.SByte>, upper: Vector128_1<System_Internal.SByte>): Vector256_1<System_Internal.SByte>;
+    static create(lower: Vector128_1<System_Internal.Single>, upper: Vector128_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
+    static create(lower: Vector128_1<System_Internal.UInt16>, upper: Vector128_1<System_Internal.UInt16>): Vector256_1<System_Internal.UInt16>;
+    static create(lower: Vector128_1<System_Internal.UInt32>, upper: Vector128_1<System_Internal.UInt32>): Vector256_1<System_Internal.UInt32>;
+    static create(lower: Vector128_1<System_Internal.UInt64>, upper: Vector128_1<System_Internal.UInt64>): Vector256_1<System_Internal.UInt64>;
+    static create(lower: Vector128_1<System_Internal.UIntPtr>, upper: Vector128_1<System_Internal.UIntPtr>): Vector256_1<System_Internal.UIntPtr>;
+    static create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte, e16: sbyte, e17: sbyte, e18: sbyte, e19: sbyte, e20: sbyte, e21: sbyte, e22: sbyte, e23: sbyte, e24: sbyte, e25: sbyte, e26: sbyte, e27: sbyte, e28: sbyte, e29: sbyte, e30: sbyte, e31: sbyte): Vector256_1<System_Internal.SByte>;
+    static create(value: sbyte): Vector256_1<System_Internal.SByte>;
+    static create(e0: float, e1: float, e2: float, e3: float, e4: float, e5: float, e6: float, e7: float): Vector256_1<System_Internal.Single>;
+    static create(value: float): Vector256_1<System_Internal.Single>;
+    static create(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort, e8: ushort, e9: ushort, e10: ushort, e11: ushort, e12: ushort, e13: ushort, e14: ushort, e15: ushort): Vector256_1<System_Internal.UInt16>;
+    static create(value: ushort): Vector256_1<System_Internal.UInt16>;
+    static create(e0: uint, e1: uint, e2: uint, e3: uint, e4: uint, e5: uint, e6: uint, e7: uint): Vector256_1<System_Internal.UInt32>;
+    static create(value: uint): Vector256_1<System_Internal.UInt32>;
+    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 createScalar(value: byte): Vector256_1<CLROf<byte>>;
-    static createScalar(value: double): Vector256_1<CLROf<double>>;
-    static createScalar(value: short): Vector256_1<CLROf<short>>;
-    static createScalar(value: int): Vector256_1<CLROf<int>>;
-    static createScalar(value: long): Vector256_1<CLROf<long>>;
-    static createScalar(value: nint): Vector256_1<CLROf<nint>>;
-    static createScalar(value: sbyte): Vector256_1<CLROf<sbyte>>;
-    static createScalar(value: float): Vector256_1<CLROf<float>>;
-    static createScalar(value: ushort): Vector256_1<CLROf<ushort>>;
-    static createScalar(value: uint): Vector256_1<CLROf<uint>>;
-    static createScalar(value: ulong): Vector256_1<CLROf<ulong>>;
-    static createScalar(value: nuint): Vector256_1<CLROf<nuint>>;
+    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>;
+    static createScalar(value: int): Vector256_1<System_Internal.Int32>;
+    static createScalar(value: long): Vector256_1<System_Internal.Int64>;
+    static createScalar(value: nint): Vector256_1<System_Internal.IntPtr>;
+    static createScalar(value: sbyte): Vector256_1<System_Internal.SByte>;
+    static createScalar(value: float): Vector256_1<System_Internal.Single>;
+    static createScalar(value: ushort): Vector256_1<System_Internal.UInt16>;
+    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 createScalarUnsafe(value: byte): Vector256_1<CLROf<byte>>;
-    static createScalarUnsafe(value: double): Vector256_1<CLROf<double>>;
-    static createScalarUnsafe(value: short): Vector256_1<CLROf<short>>;
-    static createScalarUnsafe(value: int): Vector256_1<CLROf<int>>;
-    static createScalarUnsafe(value: long): Vector256_1<CLROf<long>>;
-    static createScalarUnsafe(value: nint): Vector256_1<CLROf<nint>>;
-    static createScalarUnsafe(value: sbyte): Vector256_1<CLROf<sbyte>>;
-    static createScalarUnsafe(value: float): Vector256_1<CLROf<float>>;
-    static createScalarUnsafe(value: ushort): Vector256_1<CLROf<ushort>>;
-    static createScalarUnsafe(value: uint): Vector256_1<CLROf<uint>>;
-    static createScalarUnsafe(value: ulong): Vector256_1<CLROf<ulong>>;
-    static createScalarUnsafe(value: nuint): Vector256_1<CLROf<nuint>>;
+    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>;
+    static createScalarUnsafe(value: int): Vector256_1<System_Internal.Int32>;
+    static createScalarUnsafe(value: long): Vector256_1<System_Internal.Int64>;
+    static createScalarUnsafe(value: nint): Vector256_1<System_Internal.IntPtr>;
+    static createScalarUnsafe(value: sbyte): Vector256_1<System_Internal.SByte>;
+    static createScalarUnsafe(value: float): Vector256_1<System_Internal.Single>;
+    static createScalarUnsafe(value: ushort): Vector256_1<System_Internal.UInt16>;
+    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 degreesToRadians(degrees: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static degreesToRadians(degrees: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    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 exp(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static exp(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    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 floor(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static floor(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static fusedMultiplyAdd(left: Vector256_1<CLROf<double>>, right: Vector256_1<CLROf<double>>, addend: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static fusedMultiplyAdd(left: Vector256_1<CLROf<float>>, right: Vector256_1<CLROf<float>>, addend: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    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>;
@@ -635,8 +610,8 @@ export abstract class Vector256$instance {
     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 hypot(x: Vector256_1<CLROf<double>>, y: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static hypot(x: Vector256_1<CLROf<float>>, y: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    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>;
@@ -654,8 +629,8 @@ export abstract class Vector256$instance {
     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 lerp(x: Vector256_1<CLROf<double>>, y: Vector256_1<CLROf<double>>, amount: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static lerp(x: Vector256_1<CLROf<float>>, y: Vector256_1<CLROf<float>>, amount: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    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;
@@ -665,12 +640,12 @@ export abstract class Vector256$instance {
     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: { value: ref<T> }, elementOffset: nuint): Vector256_1<T>;
-    static loadUnsafe<T>(source: { value: ref<T> }): Vector256_1<T>;
-    static log(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static log(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static log2(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static log2(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    static loadUnsafe<T>(source: T, elementOffset: nuint): Vector256_1<T>;
+    static loadUnsafe<T>(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>;
@@ -684,117 +659,117 @@ export abstract class Vector256$instance {
     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 multiplyAddEstimate(left: Vector256_1<CLROf<double>>, right: Vector256_1<CLROf<double>>, addend: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static multiplyAddEstimate(left: Vector256_1<CLROf<float>>, right: Vector256_1<CLROf<float>>, addend: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static narrow(lower: Vector256_1<CLROf<double>>, upper: Vector256_1<CLROf<double>>): Vector256_1<CLROf<float>>;
-    static narrow(lower: Vector256_1<CLROf<short>>, upper: Vector256_1<CLROf<short>>): Vector256_1<CLROf<sbyte>>;
-    static narrow(lower: Vector256_1<CLROf<int>>, upper: Vector256_1<CLROf<int>>): Vector256_1<CLROf<short>>;
-    static narrow(lower: Vector256_1<CLROf<long>>, upper: Vector256_1<CLROf<long>>): Vector256_1<CLROf<int>>;
-    static narrow(lower: Vector256_1<CLROf<ushort>>, upper: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<byte>>;
-    static narrow(lower: Vector256_1<CLROf<uint>>, upper: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ushort>>;
-    static narrow(lower: Vector256_1<CLROf<ulong>>, upper: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<uint>>;
-    static narrowWithSaturation(lower: Vector256_1<CLROf<double>>, upper: Vector256_1<CLROf<double>>): Vector256_1<CLROf<float>>;
-    static narrowWithSaturation(lower: Vector256_1<CLROf<short>>, upper: Vector256_1<CLROf<short>>): Vector256_1<CLROf<sbyte>>;
-    static narrowWithSaturation(lower: Vector256_1<CLROf<int>>, upper: Vector256_1<CLROf<int>>): Vector256_1<CLROf<short>>;
-    static narrowWithSaturation(lower: Vector256_1<CLROf<long>>, upper: Vector256_1<CLROf<long>>): Vector256_1<CLROf<int>>;
-    static narrowWithSaturation(lower: Vector256_1<CLROf<ushort>>, upper: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<byte>>;
-    static narrowWithSaturation(lower: Vector256_1<CLROf<uint>>, upper: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ushort>>;
-    static narrowWithSaturation(lower: Vector256_1<CLROf<ulong>>, upper: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<uint>>;
+    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>;
+    static narrow(lower: Vector256_1<System_Internal.Int16>, upper: Vector256_1<System_Internal.Int16>): Vector256_1<System_Internal.SByte>;
+    static narrow(lower: Vector256_1<System_Internal.Int32>, upper: Vector256_1<System_Internal.Int32>): Vector256_1<System_Internal.Int16>;
+    static narrow(lower: Vector256_1<System_Internal.Int64>, upper: Vector256_1<System_Internal.Int64>): Vector256_1<System_Internal.Int32>;
+    static narrow(lower: Vector256_1<System_Internal.UInt16>, upper: Vector256_1<System_Internal.UInt16>): Vector256_1<System_Internal.Byte>;
+    static narrow(lower: Vector256_1<System_Internal.UInt32>, upper: Vector256_1<System_Internal.UInt32>): Vector256_1<System_Internal.UInt16>;
+    static narrow(lower: Vector256_1<System_Internal.UInt64>, upper: Vector256_1<System_Internal.UInt64>): Vector256_1<System_Internal.UInt32>;
+    static narrowWithSaturation(lower: Vector256_1<System_Internal.Double>, upper: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Single>;
+    static narrowWithSaturation(lower: Vector256_1<System_Internal.Int16>, upper: Vector256_1<System_Internal.Int16>): Vector256_1<System_Internal.SByte>;
+    static narrowWithSaturation(lower: Vector256_1<System_Internal.Int32>, upper: Vector256_1<System_Internal.Int32>): Vector256_1<System_Internal.Int16>;
+    static narrowWithSaturation(lower: Vector256_1<System_Internal.Int64>, upper: Vector256_1<System_Internal.Int64>): Vector256_1<System_Internal.Int32>;
+    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 radiansToDegrees(radians: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static radiansToDegrees(radians: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static round(vector: Vector256_1<CLROf<double>>, mode: MidpointRounding): Vector256_1<CLROf<double>>;
-    static round(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static round(vector: Vector256_1<CLROf<float>>, mode: MidpointRounding): Vector256_1<CLROf<float>>;
-    static round(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static shiftLeft(vector: Vector256_1<CLROf<byte>>, shiftCount: int): Vector256_1<CLROf<byte>>;
-    static shiftLeft(vector: Vector256_1<CLROf<short>>, shiftCount: int): Vector256_1<CLROf<short>>;
-    static shiftLeft(vector: Vector256_1<CLROf<int>>, shiftCount: int): Vector256_1<CLROf<int>>;
-    static shiftLeft(vector: Vector256_1<CLROf<long>>, shiftCount: int): Vector256_1<CLROf<long>>;
-    static shiftLeft(vector: Vector256_1<CLROf<nint>>, shiftCount: int): Vector256_1<CLROf<nint>>;
-    static shiftLeft(vector: Vector256_1<CLROf<sbyte>>, shiftCount: int): Vector256_1<CLROf<sbyte>>;
-    static shiftLeft(vector: Vector256_1<CLROf<ushort>>, shiftCount: int): Vector256_1<CLROf<ushort>>;
-    static shiftLeft(vector: Vector256_1<CLROf<uint>>, shiftCount: int): Vector256_1<CLROf<uint>>;
-    static shiftLeft(vector: Vector256_1<CLROf<ulong>>, shiftCount: int): Vector256_1<CLROf<ulong>>;
-    static shiftLeft(vector: Vector256_1<CLROf<nuint>>, shiftCount: int): Vector256_1<CLROf<nuint>>;
-    static shiftRightArithmetic(vector: Vector256_1<CLROf<short>>, shiftCount: int): Vector256_1<CLROf<short>>;
-    static shiftRightArithmetic(vector: Vector256_1<CLROf<int>>, shiftCount: int): Vector256_1<CLROf<int>>;
-    static shiftRightArithmetic(vector: Vector256_1<CLROf<long>>, shiftCount: int): Vector256_1<CLROf<long>>;
-    static shiftRightArithmetic(vector: Vector256_1<CLROf<nint>>, shiftCount: int): Vector256_1<CLROf<nint>>;
-    static shiftRightArithmetic(vector: Vector256_1<CLROf<sbyte>>, shiftCount: int): Vector256_1<CLROf<sbyte>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<byte>>, shiftCount: int): Vector256_1<CLROf<byte>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<short>>, shiftCount: int): Vector256_1<CLROf<short>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<int>>, shiftCount: int): Vector256_1<CLROf<int>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<long>>, shiftCount: int): Vector256_1<CLROf<long>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<nint>>, shiftCount: int): Vector256_1<CLROf<nint>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<sbyte>>, shiftCount: int): Vector256_1<CLROf<sbyte>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<ushort>>, shiftCount: int): Vector256_1<CLROf<ushort>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<uint>>, shiftCount: int): Vector256_1<CLROf<uint>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<ulong>>, shiftCount: int): Vector256_1<CLROf<ulong>>;
-    static shiftRightLogical(vector: Vector256_1<CLROf<nuint>>, shiftCount: int): Vector256_1<CLROf<nuint>>;
-    static shuffle(vector: Vector256_1<CLROf<byte>>, indices: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<byte>>;
-    static shuffle(vector: Vector256_1<CLROf<double>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<double>>;
-    static shuffle(vector: Vector256_1<CLROf<short>>, indices: Vector256_1<CLROf<short>>): Vector256_1<CLROf<short>>;
-    static shuffle(vector: Vector256_1<CLROf<int>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<int>>;
-    static shuffle(vector: Vector256_1<CLROf<long>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<long>>;
-    static shuffle(vector: Vector256_1<CLROf<sbyte>>, indices: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<sbyte>>;
-    static shuffle(vector: Vector256_1<CLROf<float>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<float>>;
-    static shuffle(vector: Vector256_1<CLROf<ushort>>, indices: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<ushort>>;
-    static shuffle(vector: Vector256_1<CLROf<uint>>, indices: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<uint>>;
-    static shuffle(vector: Vector256_1<CLROf<ulong>>, indices: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<ulong>>;
-    static shuffleNative(vector: Vector256_1<CLROf<byte>>, indices: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<byte>>;
-    static shuffleNative(vector: Vector256_1<CLROf<double>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<double>>;
-    static shuffleNative(vector: Vector256_1<CLROf<short>>, indices: Vector256_1<CLROf<short>>): Vector256_1<CLROf<short>>;
-    static shuffleNative(vector: Vector256_1<CLROf<int>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<int>>;
-    static shuffleNative(vector: Vector256_1<CLROf<long>>, indices: Vector256_1<CLROf<long>>): Vector256_1<CLROf<long>>;
-    static shuffleNative(vector: Vector256_1<CLROf<sbyte>>, indices: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<sbyte>>;
-    static shuffleNative(vector: Vector256_1<CLROf<float>>, indices: Vector256_1<CLROf<int>>): Vector256_1<CLROf<float>>;
-    static shuffleNative(vector: Vector256_1<CLROf<ushort>>, indices: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<ushort>>;
-    static shuffleNative(vector: Vector256_1<CLROf<uint>>, indices: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<uint>>;
-    static shuffleNative(vector: Vector256_1<CLROf<ulong>>, indices: Vector256_1<CLROf<ulong>>): Vector256_1<CLROf<ulong>>;
-    static sin(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static sin(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
-    static sinCos(vector: Vector256_1<CLROf<double>>): ValueTuple_2<Vector256_1<CLROf<double>>, Vector256_1<CLROf<double>>>;
-    static sinCos(vector: Vector256_1<CLROf<float>>): ValueTuple_2<Vector256_1<CLROf<float>>, Vector256_1<CLROf<float>>>;
+    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>;
+    static round(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
+    static round(vector: Vector256_1<System_Internal.Single>, mode: MidpointRounding): Vector256_1<System_Internal.Single>;
+    static round(vector: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Single>;
+    static shiftLeft(vector: Vector256_1<System_Internal.Byte>, shiftCount: int): Vector256_1<System_Internal.Byte>;
+    static shiftLeft(vector: Vector256_1<System_Internal.Int16>, shiftCount: int): Vector256_1<System_Internal.Int16>;
+    static shiftLeft(vector: Vector256_1<System_Internal.Int32>, shiftCount: int): Vector256_1<System_Internal.Int32>;
+    static shiftLeft(vector: Vector256_1<System_Internal.Int64>, shiftCount: int): Vector256_1<System_Internal.Int64>;
+    static shiftLeft(vector: Vector256_1<System_Internal.IntPtr>, shiftCount: int): Vector256_1<System_Internal.IntPtr>;
+    static shiftLeft(vector: Vector256_1<System_Internal.SByte>, shiftCount: int): Vector256_1<System_Internal.SByte>;
+    static shiftLeft(vector: Vector256_1<System_Internal.UInt16>, shiftCount: int): Vector256_1<System_Internal.UInt16>;
+    static shiftLeft(vector: Vector256_1<System_Internal.UInt32>, shiftCount: int): Vector256_1<System_Internal.UInt32>;
+    static shiftLeft(vector: Vector256_1<System_Internal.UInt64>, shiftCount: int): Vector256_1<System_Internal.UInt64>;
+    static shiftLeft(vector: Vector256_1<System_Internal.UIntPtr>, shiftCount: int): Vector256_1<System_Internal.UIntPtr>;
+    static shiftRightArithmetic(vector: Vector256_1<System_Internal.Int16>, shiftCount: int): Vector256_1<System_Internal.Int16>;
+    static shiftRightArithmetic(vector: Vector256_1<System_Internal.Int32>, shiftCount: int): Vector256_1<System_Internal.Int32>;
+    static shiftRightArithmetic(vector: Vector256_1<System_Internal.Int64>, shiftCount: int): Vector256_1<System_Internal.Int64>;
+    static shiftRightArithmetic(vector: Vector256_1<System_Internal.IntPtr>, shiftCount: int): Vector256_1<System_Internal.IntPtr>;
+    static shiftRightArithmetic(vector: Vector256_1<System_Internal.SByte>, shiftCount: int): Vector256_1<System_Internal.SByte>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.Byte>, shiftCount: int): Vector256_1<System_Internal.Byte>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.Int16>, shiftCount: int): Vector256_1<System_Internal.Int16>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.Int32>, shiftCount: int): Vector256_1<System_Internal.Int32>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.Int64>, shiftCount: int): Vector256_1<System_Internal.Int64>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.IntPtr>, shiftCount: int): Vector256_1<System_Internal.IntPtr>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.SByte>, shiftCount: int): Vector256_1<System_Internal.SByte>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.UInt16>, shiftCount: int): Vector256_1<System_Internal.UInt16>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.UInt32>, shiftCount: int): Vector256_1<System_Internal.UInt32>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.UInt64>, shiftCount: int): Vector256_1<System_Internal.UInt64>;
+    static shiftRightLogical(vector: Vector256_1<System_Internal.UIntPtr>, shiftCount: int): Vector256_1<System_Internal.UIntPtr>;
+    static shuffle(vector: Vector256_1<System_Internal.Byte>, indices: Vector256_1<System_Internal.Byte>): Vector256_1<System_Internal.Byte>;
+    static shuffle(vector: Vector256_1<System_Internal.Double>, indices: Vector256_1<System_Internal.Int64>): Vector256_1<System_Internal.Double>;
+    static shuffle(vector: Vector256_1<System_Internal.Int16>, indices: Vector256_1<System_Internal.Int16>): Vector256_1<System_Internal.Int16>;
+    static shuffle(vector: Vector256_1<System_Internal.Int32>, indices: Vector256_1<System_Internal.Int32>): Vector256_1<System_Internal.Int32>;
+    static shuffle(vector: Vector256_1<System_Internal.Int64>, indices: Vector256_1<System_Internal.Int64>): Vector256_1<System_Internal.Int64>;
+    static shuffle(vector: Vector256_1<System_Internal.SByte>, indices: Vector256_1<System_Internal.SByte>): Vector256_1<System_Internal.SByte>;
+    static shuffle(vector: Vector256_1<System_Internal.Single>, indices: Vector256_1<System_Internal.Int32>): Vector256_1<System_Internal.Single>;
+    static shuffle(vector: Vector256_1<System_Internal.UInt16>, indices: Vector256_1<System_Internal.UInt16>): Vector256_1<System_Internal.UInt16>;
+    static shuffle(vector: Vector256_1<System_Internal.UInt32>, indices: Vector256_1<System_Internal.UInt32>): Vector256_1<System_Internal.UInt32>;
+    static shuffle(vector: Vector256_1<System_Internal.UInt64>, indices: Vector256_1<System_Internal.UInt64>): Vector256_1<System_Internal.UInt64>;
+    static shuffleNative(vector: Vector256_1<System_Internal.Byte>, indices: Vector256_1<System_Internal.Byte>): Vector256_1<System_Internal.Byte>;
+    static shuffleNative(vector: Vector256_1<System_Internal.Double>, indices: Vector256_1<System_Internal.Int64>): Vector256_1<System_Internal.Double>;
+    static shuffleNative(vector: Vector256_1<System_Internal.Int16>, indices: Vector256_1<System_Internal.Int16>): Vector256_1<System_Internal.Int16>;
+    static shuffleNative(vector: Vector256_1<System_Internal.Int32>, indices: Vector256_1<System_Internal.Int32>): Vector256_1<System_Internal.Int32>;
+    static shuffleNative(vector: Vector256_1<System_Internal.Int64>, indices: Vector256_1<System_Internal.Int64>): Vector256_1<System_Internal.Int64>;
+    static shuffleNative(vector: Vector256_1<System_Internal.SByte>, indices: Vector256_1<System_Internal.SByte>): Vector256_1<System_Internal.SByte>;
+    static shuffleNative(vector: Vector256_1<System_Internal.Single>, indices: Vector256_1<System_Internal.Int32>): Vector256_1<System_Internal.Single>;
+    static shuffleNative(vector: Vector256_1<System_Internal.UInt16>, indices: Vector256_1<System_Internal.UInt16>): Vector256_1<System_Internal.UInt16>;
+    static shuffleNative(vector: Vector256_1<System_Internal.UInt32>, indices: Vector256_1<System_Internal.UInt32>): Vector256_1<System_Internal.UInt32>;
+    static shuffleNative(vector: Vector256_1<System_Internal.UInt64>, indices: Vector256_1<System_Internal.UInt64>): Vector256_1<System_Internal.UInt64>;
+    static sin(vector: Vector256_1<System_Internal.Double>): Vector256_1<System_Internal.Double>;
+    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: { value: ref<T> }, elementOffset: nuint): void;
-    static storeUnsafe<T>(source: Vector256_1<T>, destination: { value: ref<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 truncate(vector: Vector256_1<CLROf<double>>): Vector256_1<CLROf<double>>;
-    static truncate(vector: Vector256_1<CLROf<float>>): Vector256_1<CLROf<float>>;
+    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 widen(source: Vector256_1<CLROf<byte>>): ValueTuple_2<Vector256_1<CLROf<ushort>>, Vector256_1<CLROf<ushort>>>;
-    static widen(source: Vector256_1<CLROf<short>>): ValueTuple_2<Vector256_1<CLROf<int>>, Vector256_1<CLROf<int>>>;
-    static widen(source: Vector256_1<CLROf<int>>): ValueTuple_2<Vector256_1<CLROf<long>>, Vector256_1<CLROf<long>>>;
-    static widen(source: Vector256_1<CLROf<sbyte>>): ValueTuple_2<Vector256_1<CLROf<short>>, Vector256_1<CLROf<short>>>;
-    static widen(source: Vector256_1<CLROf<float>>): ValueTuple_2<Vector256_1<CLROf<double>>, Vector256_1<CLROf<double>>>;
-    static widen(source: Vector256_1<CLROf<ushort>>): ValueTuple_2<Vector256_1<CLROf<uint>>, Vector256_1<CLROf<uint>>>;
-    static widen(source: Vector256_1<CLROf<uint>>): ValueTuple_2<Vector256_1<CLROf<ulong>>, Vector256_1<CLROf<ulong>>>;
-    static widenLower(source: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<ushort>>;
-    static widenLower(source: Vector256_1<CLROf<short>>): Vector256_1<CLROf<int>>;
-    static widenLower(source: Vector256_1<CLROf<int>>): Vector256_1<CLROf<long>>;
-    static widenLower(source: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<short>>;
-    static widenLower(source: Vector256_1<CLROf<float>>): Vector256_1<CLROf<double>>;
-    static widenLower(source: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<uint>>;
-    static widenLower(source: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ulong>>;
-    static widenUpper(source: Vector256_1<CLROf<byte>>): Vector256_1<CLROf<ushort>>;
-    static widenUpper(source: Vector256_1<CLROf<short>>): Vector256_1<CLROf<int>>;
-    static widenUpper(source: Vector256_1<CLROf<int>>): Vector256_1<CLROf<long>>;
-    static widenUpper(source: Vector256_1<CLROf<sbyte>>): Vector256_1<CLROf<short>>;
-    static widenUpper(source: Vector256_1<CLROf<float>>): Vector256_1<CLROf<double>>;
-    static widenUpper(source: Vector256_1<CLROf<ushort>>): Vector256_1<CLROf<uint>>;
-    static widenUpper(source: Vector256_1<CLROf<uint>>): Vector256_1<CLROf<ulong>>;
+    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>>;
+    static widen(source: Vector256_1<System_Internal.SByte>): ValueTuple_2<Vector256_1<System_Internal.Int16>, Vector256_1<System_Internal.Int16>>;
+    static widen(source: Vector256_1<System_Internal.Single>): ValueTuple_2<Vector256_1<System_Internal.Double>, Vector256_1<System_Internal.Double>>;
+    static widen(source: Vector256_1<System_Internal.UInt16>): ValueTuple_2<Vector256_1<System_Internal.UInt32>, Vector256_1<System_Internal.UInt32>>;
+    static widen(source: Vector256_1<System_Internal.UInt32>): ValueTuple_2<Vector256_1<System_Internal.UInt64>, Vector256_1<System_Internal.UInt64>>;
+    static widenLower(source: Vector256_1<System_Internal.Byte>): Vector256_1<System_Internal.UInt16>;
+    static widenLower(source: Vector256_1<System_Internal.Int16>): Vector256_1<System_Internal.Int32>;
+    static widenLower(source: Vector256_1<System_Internal.Int32>): Vector256_1<System_Internal.Int64>;
+    static widenLower(source: Vector256_1<System_Internal.SByte>): Vector256_1<System_Internal.Int16>;
+    static widenLower(source: Vector256_1<System_Internal.Single>): Vector256_1<System_Internal.Double>;
+    static widenLower(source: Vector256_1<System_Internal.UInt16>): Vector256_1<System_Internal.UInt32>;
+    static widenLower(source: Vector256_1<System_Internal.UInt32>): Vector256_1<System_Internal.UInt64>;
+    static widenUpper(source: Vector256_1<System_Internal.Byte>): Vector256_1<System_Internal.UInt16>;
+    static widenUpper(source: Vector256_1<System_Internal.Int16>): Vector256_1<System_Internal.Int32>;
+    static widenUpper(source: Vector256_1<System_Internal.Int32>): Vector256_1<System_Internal.Int64>;
+    static widenUpper(source: Vector256_1<System_Internal.SByte>): Vector256_1<System_Internal.Int16>;
+    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>;
@@ -815,82 +790,82 @@ export abstract class Vector512$instance {
     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<CLROf<byte>>;
-    static asDouble<T>(vector: Vector512_1<T>): Vector512_1<CLROf<double>>;
-    static asInt16<T>(vector: Vector512_1<T>): Vector512_1<CLROf<short>>;
-    static asInt32<T>(vector: Vector512_1<T>): Vector512_1<CLROf<int>>;
-    static asInt64<T>(vector: Vector512_1<T>): Vector512_1<CLROf<long>>;
-    static asNInt<T>(vector: Vector512_1<T>): Vector512_1<CLROf<nint>>;
-    static asNUInt<T>(vector: Vector512_1<T>): Vector512_1<CLROf<nuint>>;
-    static asSByte<T>(vector: Vector512_1<T>): Vector512_1<CLROf<sbyte>>;
-    static asSingle<T>(vector: Vector512_1<T>): Vector512_1<CLROf<float>>;
-    static asUInt16<T>(vector: Vector512_1<T>): Vector512_1<CLROf<ushort>>;
-    static asUInt32<T>(vector: Vector512_1<T>): Vector512_1<CLROf<uint>>;
-    static asUInt64<T>(vector: Vector512_1<T>): Vector512_1<CLROf<ulong>>;
+    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 ceiling(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static ceiling(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    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 convertToDouble(vector: Vector512_1<CLROf<long>>): Vector512_1<CLROf<double>>;
-    static convertToDouble(vector: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<double>>;
-    static convertToInt32(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<int>>;
-    static convertToInt32Native(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<int>>;
-    static convertToInt64(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<long>>;
-    static convertToInt64Native(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<long>>;
-    static convertToSingle(vector: Vector512_1<CLROf<int>>): Vector512_1<CLROf<float>>;
-    static convertToSingle(vector: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<float>>;
-    static convertToUInt32(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<uint>>;
-    static convertToUInt32Native(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<uint>>;
-    static convertToUInt64(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<ulong>>;
-    static convertToUInt64Native(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<ulong>>;
+    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>;
+    static convertToInt32Native(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Int32>;
+    static convertToInt64(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Int64>;
+    static convertToInt64Native(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Int64>;
+    static convertToSingle(vector: Vector512_1<System_Internal.Int32>): Vector512_1<System_Internal.Single>;
+    static convertToSingle(vector: Vector512_1<System_Internal.UInt32>): Vector512_1<System_Internal.Single>;
+    static convertToUInt32(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.UInt32>;
+    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 cos(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static cos(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    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 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<CLROf<byte>>;
-    static create(value: byte): Vector512_1<CLROf<byte>>;
-    static create(e0: double, e1: double, e2: double, e3: double, e4: double, e5: double, e6: double, e7: double): Vector512_1<CLROf<double>>;
-    static create(value: double): Vector512_1<CLROf<double>>;
-    static create(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short, e8: short, e9: short, e10: short, e11: short, e12: short, e13: short, e14: short, e15: short, e16: short, e17: short, e18: short, e19: short, e20: short, e21: short, e22: short, e23: short, e24: short, e25: short, e26: short, e27: short, e28: short, e29: short, e30: short, e31: short): Vector512_1<CLROf<short>>;
-    static create(value: short): Vector512_1<CLROf<short>>;
-    static create(e0: int, e1: int, e2: int, e3: int, e4: int, e5: int, e6: int, e7: int, e8: int, e9: int, e10: int, e11: int, e12: int, e13: int, e14: int, e15: int): Vector512_1<CLROf<int>>;
-    static create(value: int): Vector512_1<CLROf<int>>;
-    static create(e0: long, e1: long, e2: long, e3: long, e4: long, e5: long, e6: long, e7: long): Vector512_1<CLROf<long>>;
-    static create(value: long): Vector512_1<CLROf<long>>;
-    static create(value: nint): Vector512_1<CLROf<nint>>;
-    static create(lower: Vector256_1<CLROf<byte>>, upper: Vector256_1<CLROf<byte>>): Vector512_1<CLROf<byte>>;
-    static create(lower: Vector256_1<CLROf<double>>, upper: Vector256_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static create(lower: Vector256_1<CLROf<short>>, upper: Vector256_1<CLROf<short>>): Vector512_1<CLROf<short>>;
-    static create(lower: Vector256_1<CLROf<int>>, upper: Vector256_1<CLROf<int>>): Vector512_1<CLROf<int>>;
-    static create(lower: Vector256_1<CLROf<long>>, upper: Vector256_1<CLROf<long>>): Vector512_1<CLROf<long>>;
-    static create(lower: Vector256_1<CLROf<nint>>, upper: Vector256_1<CLROf<nint>>): Vector512_1<CLROf<nint>>;
-    static create(lower: Vector256_1<CLROf<sbyte>>, upper: Vector256_1<CLROf<sbyte>>): Vector512_1<CLROf<sbyte>>;
-    static create(lower: Vector256_1<CLROf<float>>, upper: Vector256_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static create(lower: Vector256_1<CLROf<ushort>>, upper: Vector256_1<CLROf<ushort>>): Vector512_1<CLROf<ushort>>;
-    static create(lower: Vector256_1<CLROf<uint>>, upper: Vector256_1<CLROf<uint>>): Vector512_1<CLROf<uint>>;
-    static create(lower: Vector256_1<CLROf<ulong>>, upper: Vector256_1<CLROf<ulong>>): Vector512_1<CLROf<ulong>>;
-    static create(lower: Vector256_1<CLROf<nuint>>, upper: Vector256_1<CLROf<nuint>>): Vector512_1<CLROf<nuint>>;
-    static create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte, e16: sbyte, e17: sbyte, e18: sbyte, e19: sbyte, e20: sbyte, e21: sbyte, e22: sbyte, e23: sbyte, e24: sbyte, e25: sbyte, e26: sbyte, e27: sbyte, e28: sbyte, e29: sbyte, e30: sbyte, e31: sbyte, e32: sbyte, e33: sbyte, e34: sbyte, e35: sbyte, e36: sbyte, e37: sbyte, e38: sbyte, e39: sbyte, e40: sbyte, e41: sbyte, e42: sbyte, e43: sbyte, e44: sbyte, e45: sbyte, e46: sbyte, e47: sbyte, e48: sbyte, e49: sbyte, e50: sbyte, e51: sbyte, e52: sbyte, e53: sbyte, e54: sbyte, e55: sbyte, e56: sbyte, e57: sbyte, e58: sbyte, e59: sbyte, e60: sbyte, e61: sbyte, e62: sbyte, e63: sbyte): Vector512_1<CLROf<sbyte>>;
-    static create(value: sbyte): Vector512_1<CLROf<sbyte>>;
-    static create(e0: float, e1: float, e2: float, e3: float, e4: float, e5: float, e6: float, e7: float, e8: float, e9: float, e10: float, e11: float, e12: float, e13: float, e14: float, e15: float): Vector512_1<CLROf<float>>;
-    static create(value: float): Vector512_1<CLROf<float>>;
-    static create(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort, e8: ushort, e9: ushort, e10: ushort, e11: ushort, e12: ushort, e13: ushort, e14: ushort, e15: ushort, e16: ushort, e17: ushort, e18: ushort, e19: ushort, e20: ushort, e21: ushort, e22: ushort, e23: ushort, e24: ushort, e25: ushort, e26: ushort, e27: ushort, e28: ushort, e29: ushort, e30: ushort, e31: ushort): Vector512_1<CLROf<ushort>>;
-    static create(value: ushort): Vector512_1<CLROf<ushort>>;
-    static create(e0: uint, e1: uint, e2: uint, e3: uint, e4: uint, e5: uint, e6: uint, e7: uint, e8: uint, e9: uint, e10: uint, e11: uint, e12: uint, e13: uint, e14: uint, e15: uint): Vector512_1<CLROf<uint>>;
-    static create(value: uint): Vector512_1<CLROf<uint>>;
-    static create(e0: ulong, e1: ulong, e2: ulong, e3: ulong, e4: ulong, e5: ulong, e6: ulong, e7: ulong): Vector512_1<CLROf<ulong>>;
-    static create(value: ulong): Vector512_1<CLROf<ulong>>;
-    static create(value: nuint): Vector512_1<CLROf<nuint>>;
+    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>;
+    static create(value: double): Vector512_1<System_Internal.Double>;
+    static create(e0: short, e1: short, e2: short, e3: short, e4: short, e5: short, e6: short, e7: short, e8: short, e9: short, e10: short, e11: short, e12: short, e13: short, e14: short, e15: short, e16: short, e17: short, e18: short, e19: short, e20: short, e21: short, e22: short, e23: short, e24: short, e25: short, e26: short, e27: short, e28: short, e29: short, e30: short, e31: short): Vector512_1<System_Internal.Int16>;
+    static create(value: short): Vector512_1<System_Internal.Int16>;
+    static create(e0: int, e1: int, e2: int, e3: int, e4: int, e5: int, e6: int, e7: int, e8: int, e9: int, e10: int, e11: int, e12: int, e13: int, e14: int, e15: int): Vector512_1<System_Internal.Int32>;
+    static create(value: int): Vector512_1<System_Internal.Int32>;
+    static create(e0: long, e1: long, e2: long, e3: long, e4: long, e5: long, e6: long, e7: long): Vector512_1<System_Internal.Int64>;
+    static create(value: long): Vector512_1<System_Internal.Int64>;
+    static create(value: nint): Vector512_1<System_Internal.IntPtr>;
+    static create(lower: Vector256_1<System_Internal.Byte>, upper: Vector256_1<System_Internal.Byte>): Vector512_1<System_Internal.Byte>;
+    static create(lower: Vector256_1<System_Internal.Double>, upper: Vector256_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
+    static create(lower: Vector256_1<System_Internal.Int16>, upper: Vector256_1<System_Internal.Int16>): Vector512_1<System_Internal.Int16>;
+    static create(lower: Vector256_1<System_Internal.Int32>, upper: Vector256_1<System_Internal.Int32>): Vector512_1<System_Internal.Int32>;
+    static create(lower: Vector256_1<System_Internal.Int64>, upper: Vector256_1<System_Internal.Int64>): Vector512_1<System_Internal.Int64>;
+    static create(lower: Vector256_1<System_Internal.IntPtr>, upper: Vector256_1<System_Internal.IntPtr>): Vector512_1<System_Internal.IntPtr>;
+    static create(lower: Vector256_1<System_Internal.SByte>, upper: Vector256_1<System_Internal.SByte>): Vector512_1<System_Internal.SByte>;
+    static create(lower: Vector256_1<System_Internal.Single>, upper: Vector256_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
+    static create(lower: Vector256_1<System_Internal.UInt16>, upper: Vector256_1<System_Internal.UInt16>): Vector512_1<System_Internal.UInt16>;
+    static create(lower: Vector256_1<System_Internal.UInt32>, upper: Vector256_1<System_Internal.UInt32>): Vector512_1<System_Internal.UInt32>;
+    static create(lower: Vector256_1<System_Internal.UInt64>, upper: Vector256_1<System_Internal.UInt64>): Vector512_1<System_Internal.UInt64>;
+    static create(lower: Vector256_1<System_Internal.UIntPtr>, upper: Vector256_1<System_Internal.UIntPtr>): Vector512_1<System_Internal.UIntPtr>;
+    static create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte, e8: sbyte, e9: sbyte, e10: sbyte, e11: sbyte, e12: sbyte, e13: sbyte, e14: sbyte, e15: sbyte, e16: sbyte, e17: sbyte, e18: sbyte, e19: sbyte, e20: sbyte, e21: sbyte, e22: sbyte, e23: sbyte, e24: sbyte, e25: sbyte, e26: sbyte, e27: sbyte, e28: sbyte, e29: sbyte, e30: sbyte, e31: sbyte, e32: sbyte, e33: sbyte, e34: sbyte, e35: sbyte, e36: sbyte, e37: sbyte, e38: sbyte, e39: sbyte, e40: sbyte, e41: sbyte, e42: sbyte, e43: sbyte, e44: sbyte, e45: sbyte, e46: sbyte, e47: sbyte, e48: sbyte, e49: sbyte, e50: sbyte, e51: sbyte, e52: sbyte, e53: sbyte, e54: sbyte, e55: sbyte, e56: sbyte, e57: sbyte, e58: sbyte, e59: sbyte, e60: sbyte, e61: sbyte, e62: sbyte, e63: sbyte): Vector512_1<System_Internal.SByte>;
+    static create(value: sbyte): Vector512_1<System_Internal.SByte>;
+    static create(e0: float, e1: float, e2: float, e3: float, e4: float, e5: float, e6: float, e7: float, e8: float, e9: float, e10: float, e11: float, e12: float, e13: float, e14: float, e15: float): Vector512_1<System_Internal.Single>;
+    static create(value: float): Vector512_1<System_Internal.Single>;
+    static create(e0: ushort, e1: ushort, e2: ushort, e3: ushort, e4: ushort, e5: ushort, e6: ushort, e7: ushort, e8: ushort, e9: ushort, e10: ushort, e11: ushort, e12: ushort, e13: ushort, e14: ushort, e15: ushort, e16: ushort, e17: ushort, e18: ushort, e19: ushort, e20: ushort, e21: ushort, e22: ushort, e23: ushort, e24: ushort, e25: ushort, e26: ushort, e27: ushort, e28: ushort, e29: ushort, e30: ushort, e31: ushort): Vector512_1<System_Internal.UInt16>;
+    static create(value: ushort): Vector512_1<System_Internal.UInt16>;
+    static create(e0: uint, e1: uint, e2: uint, e3: uint, e4: uint, e5: uint, e6: uint, e7: uint, e8: uint, e9: uint, e10: uint, e11: uint, e12: uint, e13: uint, e14: uint, e15: uint): Vector512_1<System_Internal.UInt32>;
+    static create(value: uint): Vector512_1<System_Internal.UInt32>;
+    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>;
@@ -898,48 +873,48 @@ export abstract class Vector512$instance {
     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 createScalar(value: byte): Vector512_1<CLROf<byte>>;
-    static createScalar(value: double): Vector512_1<CLROf<double>>;
-    static createScalar(value: short): Vector512_1<CLROf<short>>;
-    static createScalar(value: int): Vector512_1<CLROf<int>>;
-    static createScalar(value: long): Vector512_1<CLROf<long>>;
-    static createScalar(value: nint): Vector512_1<CLROf<nint>>;
-    static createScalar(value: sbyte): Vector512_1<CLROf<sbyte>>;
-    static createScalar(value: float): Vector512_1<CLROf<float>>;
-    static createScalar(value: ushort): Vector512_1<CLROf<ushort>>;
-    static createScalar(value: uint): Vector512_1<CLROf<uint>>;
-    static createScalar(value: ulong): Vector512_1<CLROf<ulong>>;
-    static createScalar(value: nuint): Vector512_1<CLROf<nuint>>;
+    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>;
+    static createScalar(value: int): Vector512_1<System_Internal.Int32>;
+    static createScalar(value: long): Vector512_1<System_Internal.Int64>;
+    static createScalar(value: nint): Vector512_1<System_Internal.IntPtr>;
+    static createScalar(value: sbyte): Vector512_1<System_Internal.SByte>;
+    static createScalar(value: float): Vector512_1<System_Internal.Single>;
+    static createScalar(value: ushort): Vector512_1<System_Internal.UInt16>;
+    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 createScalarUnsafe(value: byte): Vector512_1<CLROf<byte>>;
-    static createScalarUnsafe(value: double): Vector512_1<CLROf<double>>;
-    static createScalarUnsafe(value: short): Vector512_1<CLROf<short>>;
-    static createScalarUnsafe(value: int): Vector512_1<CLROf<int>>;
-    static createScalarUnsafe(value: long): Vector512_1<CLROf<long>>;
-    static createScalarUnsafe(value: nint): Vector512_1<CLROf<nint>>;
-    static createScalarUnsafe(value: sbyte): Vector512_1<CLROf<sbyte>>;
-    static createScalarUnsafe(value: float): Vector512_1<CLROf<float>>;
-    static createScalarUnsafe(value: ushort): Vector512_1<CLROf<ushort>>;
-    static createScalarUnsafe(value: uint): Vector512_1<CLROf<uint>>;
-    static createScalarUnsafe(value: ulong): Vector512_1<CLROf<ulong>>;
-    static createScalarUnsafe(value: nuint): Vector512_1<CLROf<nuint>>;
+    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>;
+    static createScalarUnsafe(value: int): Vector512_1<System_Internal.Int32>;
+    static createScalarUnsafe(value: long): Vector512_1<System_Internal.Int64>;
+    static createScalarUnsafe(value: nint): Vector512_1<System_Internal.IntPtr>;
+    static createScalarUnsafe(value: sbyte): Vector512_1<System_Internal.SByte>;
+    static createScalarUnsafe(value: float): Vector512_1<System_Internal.Single>;
+    static createScalarUnsafe(value: ushort): Vector512_1<System_Internal.UInt16>;
+    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 degreesToRadians(degrees: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static degreesToRadians(degrees: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    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 exp(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static exp(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    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 floor(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static floor(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static fusedMultiplyAdd(left: Vector512_1<CLROf<double>>, right: Vector512_1<CLROf<double>>, addend: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static fusedMultiplyAdd(left: Vector512_1<CLROf<float>>, right: Vector512_1<CLROf<float>>, addend: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    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>;
@@ -949,8 +924,8 @@ export abstract class Vector512$instance {
     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 hypot(x: Vector512_1<CLROf<double>>, y: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static hypot(x: Vector512_1<CLROf<float>>, y: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    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>;
@@ -968,8 +943,8 @@ export abstract class Vector512$instance {
     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 lerp(x: Vector512_1<CLROf<double>>, y: Vector512_1<CLROf<double>>, amount: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static lerp(x: Vector512_1<CLROf<float>>, y: Vector512_1<CLROf<float>>, amount: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    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;
@@ -979,12 +954,12 @@ export abstract class Vector512$instance {
     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: { value: ref<T> }, elementOffset: nuint): Vector512_1<T>;
-    static loadUnsafe<T>(source: { value: ref<T> }): Vector512_1<T>;
-    static log(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static log(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static log2(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static log2(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    static loadUnsafe<T>(source: T, elementOffset: nuint): Vector512_1<T>;
+    static loadUnsafe<T>(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>;
@@ -998,115 +973,115 @@ export abstract class Vector512$instance {
     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 multiplyAddEstimate(left: Vector512_1<CLROf<double>>, right: Vector512_1<CLROf<double>>, addend: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static multiplyAddEstimate(left: Vector512_1<CLROf<float>>, right: Vector512_1<CLROf<float>>, addend: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static narrow(lower: Vector512_1<CLROf<double>>, upper: Vector512_1<CLROf<double>>): Vector512_1<CLROf<float>>;
-    static narrow(lower: Vector512_1<CLROf<short>>, upper: Vector512_1<CLROf<short>>): Vector512_1<CLROf<sbyte>>;
-    static narrow(lower: Vector512_1<CLROf<int>>, upper: Vector512_1<CLROf<int>>): Vector512_1<CLROf<short>>;
-    static narrow(lower: Vector512_1<CLROf<long>>, upper: Vector512_1<CLROf<long>>): Vector512_1<CLROf<int>>;
-    static narrow(lower: Vector512_1<CLROf<ushort>>, upper: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<byte>>;
-    static narrow(lower: Vector512_1<CLROf<uint>>, upper: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ushort>>;
-    static narrow(lower: Vector512_1<CLROf<ulong>>, upper: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<uint>>;
-    static narrowWithSaturation(lower: Vector512_1<CLROf<double>>, upper: Vector512_1<CLROf<double>>): Vector512_1<CLROf<float>>;
-    static narrowWithSaturation(lower: Vector512_1<CLROf<short>>, upper: Vector512_1<CLROf<short>>): Vector512_1<CLROf<sbyte>>;
-    static narrowWithSaturation(lower: Vector512_1<CLROf<int>>, upper: Vector512_1<CLROf<int>>): Vector512_1<CLROf<short>>;
-    static narrowWithSaturation(lower: Vector512_1<CLROf<long>>, upper: Vector512_1<CLROf<long>>): Vector512_1<CLROf<int>>;
-    static narrowWithSaturation(lower: Vector512_1<CLROf<ushort>>, upper: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<byte>>;
-    static narrowWithSaturation(lower: Vector512_1<CLROf<uint>>, upper: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ushort>>;
-    static narrowWithSaturation(lower: Vector512_1<CLROf<ulong>>, upper: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<uint>>;
+    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>;
+    static narrow(lower: Vector512_1<System_Internal.Int16>, upper: Vector512_1<System_Internal.Int16>): Vector512_1<System_Internal.SByte>;
+    static narrow(lower: Vector512_1<System_Internal.Int32>, upper: Vector512_1<System_Internal.Int32>): Vector512_1<System_Internal.Int16>;
+    static narrow(lower: Vector512_1<System_Internal.Int64>, upper: Vector512_1<System_Internal.Int64>): Vector512_1<System_Internal.Int32>;
+    static narrow(lower: Vector512_1<System_Internal.UInt16>, upper: Vector512_1<System_Internal.UInt16>): Vector512_1<System_Internal.Byte>;
+    static narrow(lower: Vector512_1<System_Internal.UInt32>, upper: Vector512_1<System_Internal.UInt32>): Vector512_1<System_Internal.UInt16>;
+    static narrow(lower: Vector512_1<System_Internal.UInt64>, upper: Vector512_1<System_Internal.UInt64>): Vector512_1<System_Internal.UInt32>;
+    static narrowWithSaturation(lower: Vector512_1<System_Internal.Double>, upper: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Single>;
+    static narrowWithSaturation(lower: Vector512_1<System_Internal.Int16>, upper: Vector512_1<System_Internal.Int16>): Vector512_1<System_Internal.SByte>;
+    static narrowWithSaturation(lower: Vector512_1<System_Internal.Int32>, upper: Vector512_1<System_Internal.Int32>): Vector512_1<System_Internal.Int16>;
+    static narrowWithSaturation(lower: Vector512_1<System_Internal.Int64>, upper: Vector512_1<System_Internal.Int64>): Vector512_1<System_Internal.Int32>;
+    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 radiansToDegrees(radians: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static radiansToDegrees(radians: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static round(vector: Vector512_1<CLROf<double>>, mode: MidpointRounding): Vector512_1<CLROf<double>>;
-    static round(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static round(vector: Vector512_1<CLROf<float>>, mode: MidpointRounding): Vector512_1<CLROf<float>>;
-    static round(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static shiftLeft(vector: Vector512_1<CLROf<byte>>, shiftCount: int): Vector512_1<CLROf<byte>>;
-    static shiftLeft(vector: Vector512_1<CLROf<short>>, shiftCount: int): Vector512_1<CLROf<short>>;
-    static shiftLeft(vector: Vector512_1<CLROf<int>>, shiftCount: int): Vector512_1<CLROf<int>>;
-    static shiftLeft(vector: Vector512_1<CLROf<long>>, shiftCount: int): Vector512_1<CLROf<long>>;
-    static shiftLeft(vector: Vector512_1<CLROf<nint>>, shiftCount: int): Vector512_1<CLROf<nint>>;
-    static shiftLeft(vector: Vector512_1<CLROf<sbyte>>, shiftCount: int): Vector512_1<CLROf<sbyte>>;
-    static shiftLeft(vector: Vector512_1<CLROf<ushort>>, shiftCount: int): Vector512_1<CLROf<ushort>>;
-    static shiftLeft(vector: Vector512_1<CLROf<uint>>, shiftCount: int): Vector512_1<CLROf<uint>>;
-    static shiftLeft(vector: Vector512_1<CLROf<ulong>>, shiftCount: int): Vector512_1<CLROf<ulong>>;
-    static shiftLeft(vector: Vector512_1<CLROf<nuint>>, shiftCount: int): Vector512_1<CLROf<nuint>>;
-    static shiftRightArithmetic(vector: Vector512_1<CLROf<short>>, shiftCount: int): Vector512_1<CLROf<short>>;
-    static shiftRightArithmetic(vector: Vector512_1<CLROf<int>>, shiftCount: int): Vector512_1<CLROf<int>>;
-    static shiftRightArithmetic(vector: Vector512_1<CLROf<long>>, shiftCount: int): Vector512_1<CLROf<long>>;
-    static shiftRightArithmetic(vector: Vector512_1<CLROf<nint>>, shiftCount: int): Vector512_1<CLROf<nint>>;
-    static shiftRightArithmetic(vector: Vector512_1<CLROf<sbyte>>, shiftCount: int): Vector512_1<CLROf<sbyte>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<byte>>, shiftCount: int): Vector512_1<CLROf<byte>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<short>>, shiftCount: int): Vector512_1<CLROf<short>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<int>>, shiftCount: int): Vector512_1<CLROf<int>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<long>>, shiftCount: int): Vector512_1<CLROf<long>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<nint>>, shiftCount: int): Vector512_1<CLROf<nint>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<sbyte>>, shiftCount: int): Vector512_1<CLROf<sbyte>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<ushort>>, shiftCount: int): Vector512_1<CLROf<ushort>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<uint>>, shiftCount: int): Vector512_1<CLROf<uint>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<ulong>>, shiftCount: int): Vector512_1<CLROf<ulong>>;
-    static shiftRightLogical(vector: Vector512_1<CLROf<nuint>>, shiftCount: int): Vector512_1<CLROf<nuint>>;
-    static shuffle(vector: Vector512_1<CLROf<byte>>, indices: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<byte>>;
-    static shuffle(vector: Vector512_1<CLROf<double>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<double>>;
-    static shuffle(vector: Vector512_1<CLROf<short>>, indices: Vector512_1<CLROf<short>>): Vector512_1<CLROf<short>>;
-    static shuffle(vector: Vector512_1<CLROf<int>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<int>>;
-    static shuffle(vector: Vector512_1<CLROf<long>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<long>>;
-    static shuffle(vector: Vector512_1<CLROf<sbyte>>, indices: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<sbyte>>;
-    static shuffle(vector: Vector512_1<CLROf<float>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<float>>;
-    static shuffle(vector: Vector512_1<CLROf<ushort>>, indices: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<ushort>>;
-    static shuffle(vector: Vector512_1<CLROf<uint>>, indices: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<uint>>;
-    static shuffle(vector: Vector512_1<CLROf<ulong>>, indices: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<ulong>>;
-    static shuffleNative(vector: Vector512_1<CLROf<byte>>, indices: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<byte>>;
-    static shuffleNative(vector: Vector512_1<CLROf<double>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<double>>;
-    static shuffleNative(vector: Vector512_1<CLROf<short>>, indices: Vector512_1<CLROf<short>>): Vector512_1<CLROf<short>>;
-    static shuffleNative(vector: Vector512_1<CLROf<int>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<int>>;
-    static shuffleNative(vector: Vector512_1<CLROf<long>>, indices: Vector512_1<CLROf<long>>): Vector512_1<CLROf<long>>;
-    static shuffleNative(vector: Vector512_1<CLROf<sbyte>>, indices: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<sbyte>>;
-    static shuffleNative(vector: Vector512_1<CLROf<float>>, indices: Vector512_1<CLROf<int>>): Vector512_1<CLROf<float>>;
-    static shuffleNative(vector: Vector512_1<CLROf<ushort>>, indices: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<ushort>>;
-    static shuffleNative(vector: Vector512_1<CLROf<uint>>, indices: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<uint>>;
-    static shuffleNative(vector: Vector512_1<CLROf<ulong>>, indices: Vector512_1<CLROf<ulong>>): Vector512_1<CLROf<ulong>>;
-    static sin(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static sin(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
-    static sinCos(vector: Vector512_1<CLROf<double>>): ValueTuple_2<Vector512_1<CLROf<double>>, Vector512_1<CLROf<double>>>;
-    static sinCos(vector: Vector512_1<CLROf<float>>): ValueTuple_2<Vector512_1<CLROf<float>>, Vector512_1<CLROf<float>>>;
+    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>;
+    static round(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
+    static round(vector: Vector512_1<System_Internal.Single>, mode: MidpointRounding): Vector512_1<System_Internal.Single>;
+    static round(vector: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Single>;
+    static shiftLeft(vector: Vector512_1<System_Internal.Byte>, shiftCount: int): Vector512_1<System_Internal.Byte>;
+    static shiftLeft(vector: Vector512_1<System_Internal.Int16>, shiftCount: int): Vector512_1<System_Internal.Int16>;
+    static shiftLeft(vector: Vector512_1<System_Internal.Int32>, shiftCount: int): Vector512_1<System_Internal.Int32>;
+    static shiftLeft(vector: Vector512_1<System_Internal.Int64>, shiftCount: int): Vector512_1<System_Internal.Int64>;
+    static shiftLeft(vector: Vector512_1<System_Internal.IntPtr>, shiftCount: int): Vector512_1<System_Internal.IntPtr>;
+    static shiftLeft(vector: Vector512_1<System_Internal.SByte>, shiftCount: int): Vector512_1<System_Internal.SByte>;
+    static shiftLeft(vector: Vector512_1<System_Internal.UInt16>, shiftCount: int): Vector512_1<System_Internal.UInt16>;
+    static shiftLeft(vector: Vector512_1<System_Internal.UInt32>, shiftCount: int): Vector512_1<System_Internal.UInt32>;
+    static shiftLeft(vector: Vector512_1<System_Internal.UInt64>, shiftCount: int): Vector512_1<System_Internal.UInt64>;
+    static shiftLeft(vector: Vector512_1<System_Internal.UIntPtr>, shiftCount: int): Vector512_1<System_Internal.UIntPtr>;
+    static shiftRightArithmetic(vector: Vector512_1<System_Internal.Int16>, shiftCount: int): Vector512_1<System_Internal.Int16>;
+    static shiftRightArithmetic(vector: Vector512_1<System_Internal.Int32>, shiftCount: int): Vector512_1<System_Internal.Int32>;
+    static shiftRightArithmetic(vector: Vector512_1<System_Internal.Int64>, shiftCount: int): Vector512_1<System_Internal.Int64>;
+    static shiftRightArithmetic(vector: Vector512_1<System_Internal.IntPtr>, shiftCount: int): Vector512_1<System_Internal.IntPtr>;
+    static shiftRightArithmetic(vector: Vector512_1<System_Internal.SByte>, shiftCount: int): Vector512_1<System_Internal.SByte>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.Byte>, shiftCount: int): Vector512_1<System_Internal.Byte>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.Int16>, shiftCount: int): Vector512_1<System_Internal.Int16>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.Int32>, shiftCount: int): Vector512_1<System_Internal.Int32>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.Int64>, shiftCount: int): Vector512_1<System_Internal.Int64>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.IntPtr>, shiftCount: int): Vector512_1<System_Internal.IntPtr>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.SByte>, shiftCount: int): Vector512_1<System_Internal.SByte>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.UInt16>, shiftCount: int): Vector512_1<System_Internal.UInt16>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.UInt32>, shiftCount: int): Vector512_1<System_Internal.UInt32>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.UInt64>, shiftCount: int): Vector512_1<System_Internal.UInt64>;
+    static shiftRightLogical(vector: Vector512_1<System_Internal.UIntPtr>, shiftCount: int): Vector512_1<System_Internal.UIntPtr>;
+    static shuffle(vector: Vector512_1<System_Internal.Byte>, indices: Vector512_1<System_Internal.Byte>): Vector512_1<System_Internal.Byte>;
+    static shuffle(vector: Vector512_1<System_Internal.Double>, indices: Vector512_1<System_Internal.Int64>): Vector512_1<System_Internal.Double>;
+    static shuffle(vector: Vector512_1<System_Internal.Int16>, indices: Vector512_1<System_Internal.Int16>): Vector512_1<System_Internal.Int16>;
+    static shuffle(vector: Vector512_1<System_Internal.Int32>, indices: Vector512_1<System_Internal.Int32>): Vector512_1<System_Internal.Int32>;
+    static shuffle(vector: Vector512_1<System_Internal.Int64>, indices: Vector512_1<System_Internal.Int64>): Vector512_1<System_Internal.Int64>;
+    static shuffle(vector: Vector512_1<System_Internal.SByte>, indices: Vector512_1<System_Internal.SByte>): Vector512_1<System_Internal.SByte>;
+    static shuffle(vector: Vector512_1<System_Internal.Single>, indices: Vector512_1<System_Internal.Int32>): Vector512_1<System_Internal.Single>;
+    static shuffle(vector: Vector512_1<System_Internal.UInt16>, indices: Vector512_1<System_Internal.UInt16>): Vector512_1<System_Internal.UInt16>;
+    static shuffle(vector: Vector512_1<System_Internal.UInt32>, indices: Vector512_1<System_Internal.UInt32>): Vector512_1<System_Internal.UInt32>;
+    static shuffle(vector: Vector512_1<System_Internal.UInt64>, indices: Vector512_1<System_Internal.UInt64>): Vector512_1<System_Internal.UInt64>;
+    static shuffleNative(vector: Vector512_1<System_Internal.Byte>, indices: Vector512_1<System_Internal.Byte>): Vector512_1<System_Internal.Byte>;
+    static shuffleNative(vector: Vector512_1<System_Internal.Double>, indices: Vector512_1<System_Internal.Int64>): Vector512_1<System_Internal.Double>;
+    static shuffleNative(vector: Vector512_1<System_Internal.Int16>, indices: Vector512_1<System_Internal.Int16>): Vector512_1<System_Internal.Int16>;
+    static shuffleNative(vector: Vector512_1<System_Internal.Int32>, indices: Vector512_1<System_Internal.Int32>): Vector512_1<System_Internal.Int32>;
+    static shuffleNative(vector: Vector512_1<System_Internal.Int64>, indices: Vector512_1<System_Internal.Int64>): Vector512_1<System_Internal.Int64>;
+    static shuffleNative(vector: Vector512_1<System_Internal.SByte>, indices: Vector512_1<System_Internal.SByte>): Vector512_1<System_Internal.SByte>;
+    static shuffleNative(vector: Vector512_1<System_Internal.Single>, indices: Vector512_1<System_Internal.Int32>): Vector512_1<System_Internal.Single>;
+    static shuffleNative(vector: Vector512_1<System_Internal.UInt16>, indices: Vector512_1<System_Internal.UInt16>): Vector512_1<System_Internal.UInt16>;
+    static shuffleNative(vector: Vector512_1<System_Internal.UInt32>, indices: Vector512_1<System_Internal.UInt32>): Vector512_1<System_Internal.UInt32>;
+    static shuffleNative(vector: Vector512_1<System_Internal.UInt64>, indices: Vector512_1<System_Internal.UInt64>): Vector512_1<System_Internal.UInt64>;
+    static sin(vector: Vector512_1<System_Internal.Double>): Vector512_1<System_Internal.Double>;
+    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: { value: ref<T> }, elementOffset: nuint): void;
-    static storeUnsafe<T>(source: Vector512_1<T>, destination: { value: ref<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 truncate(vector: Vector512_1<CLROf<double>>): Vector512_1<CLROf<double>>;
-    static truncate(vector: Vector512_1<CLROf<float>>): Vector512_1<CLROf<float>>;
+    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 widen(source: Vector512_1<CLROf<byte>>): ValueTuple_2<Vector512_1<CLROf<ushort>>, Vector512_1<CLROf<ushort>>>;
-    static widen(source: Vector512_1<CLROf<short>>): ValueTuple_2<Vector512_1<CLROf<int>>, Vector512_1<CLROf<int>>>;
-    static widen(source: Vector512_1<CLROf<int>>): ValueTuple_2<Vector512_1<CLROf<long>>, Vector512_1<CLROf<long>>>;
-    static widen(source: Vector512_1<CLROf<sbyte>>): ValueTuple_2<Vector512_1<CLROf<short>>, Vector512_1<CLROf<short>>>;
-    static widen(source: Vector512_1<CLROf<float>>): ValueTuple_2<Vector512_1<CLROf<double>>, Vector512_1<CLROf<double>>>;
-    static widen(source: Vector512_1<CLROf<ushort>>): ValueTuple_2<Vector512_1<CLROf<uint>>, Vector512_1<CLROf<uint>>>;
-    static widen(source: Vector512_1<CLROf<uint>>): ValueTuple_2<Vector512_1<CLROf<ulong>>, Vector512_1<CLROf<ulong>>>;
-    static widenLower(source: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<ushort>>;
-    static widenLower(source: Vector512_1<CLROf<short>>): Vector512_1<CLROf<int>>;
-    static widenLower(source: Vector512_1<CLROf<int>>): Vector512_1<CLROf<long>>;
-    static widenLower(source: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<short>>;
-    static widenLower(source: Vector512_1<CLROf<float>>): Vector512_1<CLROf<double>>;
-    static widenLower(source: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<uint>>;
-    static widenLower(source: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ulong>>;
-    static widenUpper(source: Vector512_1<CLROf<byte>>): Vector512_1<CLROf<ushort>>;
-    static widenUpper(source: Vector512_1<CLROf<short>>): Vector512_1<CLROf<int>>;
-    static widenUpper(source: Vector512_1<CLROf<int>>): Vector512_1<CLROf<long>>;
-    static widenUpper(source: Vector512_1<CLROf<sbyte>>): Vector512_1<CLROf<short>>;
-    static widenUpper(source: Vector512_1<CLROf<float>>): Vector512_1<CLROf<double>>;
-    static widenUpper(source: Vector512_1<CLROf<ushort>>): Vector512_1<CLROf<uint>>;
-    static widenUpper(source: Vector512_1<CLROf<uint>>): Vector512_1<CLROf<ulong>>;
+    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>>;
+    static widen(source: Vector512_1<System_Internal.SByte>): ValueTuple_2<Vector512_1<System_Internal.Int16>, Vector512_1<System_Internal.Int16>>;
+    static widen(source: Vector512_1<System_Internal.Single>): ValueTuple_2<Vector512_1<System_Internal.Double>, Vector512_1<System_Internal.Double>>;
+    static widen(source: Vector512_1<System_Internal.UInt16>): ValueTuple_2<Vector512_1<System_Internal.UInt32>, Vector512_1<System_Internal.UInt32>>;
+    static widen(source: Vector512_1<System_Internal.UInt32>): ValueTuple_2<Vector512_1<System_Internal.UInt64>, Vector512_1<System_Internal.UInt64>>;
+    static widenLower(source: Vector512_1<System_Internal.Byte>): Vector512_1<System_Internal.UInt16>;
+    static widenLower(source: Vector512_1<System_Internal.Int16>): Vector512_1<System_Internal.Int32>;
+    static widenLower(source: Vector512_1<System_Internal.Int32>): Vector512_1<System_Internal.Int64>;
+    static widenLower(source: Vector512_1<System_Internal.SByte>): Vector512_1<System_Internal.Int16>;
+    static widenLower(source: Vector512_1<System_Internal.Single>): Vector512_1<System_Internal.Double>;
+    static widenLower(source: Vector512_1<System_Internal.UInt16>): Vector512_1<System_Internal.UInt32>;
+    static widenLower(source: Vector512_1<System_Internal.UInt32>): Vector512_1<System_Internal.UInt64>;
+    static widenUpper(source: Vector512_1<System_Internal.Byte>): Vector512_1<System_Internal.UInt16>;
+    static widenUpper(source: Vector512_1<System_Internal.Int16>): Vector512_1<System_Internal.Int32>;
+    static widenUpper(source: Vector512_1<System_Internal.Int32>): Vector512_1<System_Internal.Int64>;
+    static widenUpper(source: Vector512_1<System_Internal.SByte>): Vector512_1<System_Internal.Int16>;
+    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>;
@@ -1127,110 +1102,110 @@ export abstract class Vector64$instance {
     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<CLROf<byte>>;
-    static asDouble<T>(vector: Vector64_1<T>): Vector64_1<CLROf<double>>;
-    static asInt16<T>(vector: Vector64_1<T>): Vector64_1<CLROf<short>>;
-    static asInt32<T>(vector: Vector64_1<T>): Vector64_1<CLROf<int>>;
-    static asInt64<T>(vector: Vector64_1<T>): Vector64_1<CLROf<long>>;
-    static asNInt<T>(vector: Vector64_1<T>): Vector64_1<CLROf<nint>>;
-    static asNUInt<T>(vector: Vector64_1<T>): Vector64_1<CLROf<nuint>>;
-    static asSByte<T>(vector: Vector64_1<T>): Vector64_1<CLROf<sbyte>>;
-    static asSingle<T>(vector: Vector64_1<T>): Vector64_1<CLROf<float>>;
-    static asUInt16<T>(vector: Vector64_1<T>): Vector64_1<CLROf<ushort>>;
-    static asUInt32<T>(vector: Vector64_1<T>): Vector64_1<CLROf<uint>>;
-    static asUInt64<T>(vector: Vector64_1<T>): Vector64_1<CLROf<ulong>>;
+    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 ceiling(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static ceiling(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    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 convertToDouble(vector: Vector64_1<CLROf<long>>): Vector64_1<CLROf<double>>;
-    static convertToDouble(vector: Vector64_1<CLROf<ulong>>): Vector64_1<CLROf<double>>;
-    static convertToInt32(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<int>>;
-    static convertToInt32Native(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<int>>;
-    static convertToInt64(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<long>>;
-    static convertToInt64Native(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<long>>;
-    static convertToSingle(vector: Vector64_1<CLROf<int>>): Vector64_1<CLROf<float>>;
-    static convertToSingle(vector: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<float>>;
-    static convertToUInt32(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<uint>>;
-    static convertToUInt32Native(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<uint>>;
-    static convertToUInt64(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<ulong>>;
-    static convertToUInt64Native(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<ulong>>;
+    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>;
+    static convertToInt32Native(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Int32>;
+    static convertToInt64(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Int64>;
+    static convertToInt64Native(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Int64>;
+    static convertToSingle(vector: Vector64_1<System_Internal.Int32>): Vector64_1<System_Internal.Single>;
+    static convertToSingle(vector: Vector64_1<System_Internal.UInt32>): Vector64_1<System_Internal.Single>;
+    static convertToUInt32(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.UInt32>;
+    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 cos(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static cos(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    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 create(e0: byte, e1: byte, e2: byte, e3: byte, e4: byte, e5: byte, e6: byte, e7: byte): Vector64_1<CLROf<byte>>;
-    static create(value: byte): Vector64_1<CLROf<byte>>;
-    static create(value: double): Vector64_1<CLROf<double>>;
-    static create(e0: short, e1: short, e2: short, e3: short): Vector64_1<CLROf<short>>;
-    static create(value: short): Vector64_1<CLROf<short>>;
-    static create(e0: int, e1: int): Vector64_1<CLROf<int>>;
-    static create(value: int): Vector64_1<CLROf<int>>;
-    static create(value: long): Vector64_1<CLROf<long>>;
-    static create(value: nint): Vector64_1<CLROf<nint>>;
-    static create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte): Vector64_1<CLROf<sbyte>>;
-    static create(value: sbyte): Vector64_1<CLROf<sbyte>>;
-    static create(e0: float, e1: float): Vector64_1<CLROf<float>>;
-    static create(value: float): Vector64_1<CLROf<float>>;
-    static create(e0: ushort, e1: ushort, e2: ushort, e3: ushort): Vector64_1<CLROf<ushort>>;
-    static create(value: ushort): Vector64_1<CLROf<ushort>>;
-    static create(e0: uint, e1: uint): Vector64_1<CLROf<uint>>;
-    static create(value: uint): Vector64_1<CLROf<uint>>;
-    static create(value: ulong): Vector64_1<CLROf<ulong>>;
-    static create(value: nuint): Vector64_1<CLROf<nuint>>;
+    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>;
+    static create(e0: short, e1: short, e2: short, e3: short): Vector64_1<System_Internal.Int16>;
+    static create(value: short): Vector64_1<System_Internal.Int16>;
+    static create(e0: int, e1: int): Vector64_1<System_Internal.Int32>;
+    static create(value: int): Vector64_1<System_Internal.Int32>;
+    static create(value: long): Vector64_1<System_Internal.Int64>;
+    static create(value: nint): Vector64_1<System_Internal.IntPtr>;
+    static create(e0: sbyte, e1: sbyte, e2: sbyte, e3: sbyte, e4: sbyte, e5: sbyte, e6: sbyte, e7: sbyte): Vector64_1<System_Internal.SByte>;
+    static create(value: sbyte): Vector64_1<System_Internal.SByte>;
+    static create(e0: float, e1: float): Vector64_1<System_Internal.Single>;
+    static create(value: float): Vector64_1<System_Internal.Single>;
+    static create(e0: ushort, e1: ushort, e2: ushort, e3: ushort): Vector64_1<System_Internal.UInt16>;
+    static create(value: ushort): Vector64_1<System_Internal.UInt16>;
+    static create(e0: uint, e1: uint): Vector64_1<System_Internal.UInt32>;
+    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 createScalar(value: byte): Vector64_1<CLROf<byte>>;
-    static createScalar(value: double): Vector64_1<CLROf<double>>;
-    static createScalar(value: short): Vector64_1<CLROf<short>>;
-    static createScalar(value: int): Vector64_1<CLROf<int>>;
-    static createScalar(value: long): Vector64_1<CLROf<long>>;
-    static createScalar(value: nint): Vector64_1<CLROf<nint>>;
-    static createScalar(value: sbyte): Vector64_1<CLROf<sbyte>>;
-    static createScalar(value: float): Vector64_1<CLROf<float>>;
-    static createScalar(value: ushort): Vector64_1<CLROf<ushort>>;
-    static createScalar(value: uint): Vector64_1<CLROf<uint>>;
-    static createScalar(value: ulong): Vector64_1<CLROf<ulong>>;
-    static createScalar(value: nuint): Vector64_1<CLROf<nuint>>;
+    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>;
+    static createScalar(value: int): Vector64_1<System_Internal.Int32>;
+    static createScalar(value: long): Vector64_1<System_Internal.Int64>;
+    static createScalar(value: nint): Vector64_1<System_Internal.IntPtr>;
+    static createScalar(value: sbyte): Vector64_1<System_Internal.SByte>;
+    static createScalar(value: float): Vector64_1<System_Internal.Single>;
+    static createScalar(value: ushort): Vector64_1<System_Internal.UInt16>;
+    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 createScalarUnsafe(value: byte): Vector64_1<CLROf<byte>>;
-    static createScalarUnsafe(value: double): Vector64_1<CLROf<double>>;
-    static createScalarUnsafe(value: short): Vector64_1<CLROf<short>>;
-    static createScalarUnsafe(value: int): Vector64_1<CLROf<int>>;
-    static createScalarUnsafe(value: long): Vector64_1<CLROf<long>>;
-    static createScalarUnsafe(value: nint): Vector64_1<CLROf<nint>>;
-    static createScalarUnsafe(value: sbyte): Vector64_1<CLROf<sbyte>>;
-    static createScalarUnsafe(value: float): Vector64_1<CLROf<float>>;
-    static createScalarUnsafe(value: ushort): Vector64_1<CLROf<ushort>>;
-    static createScalarUnsafe(value: uint): Vector64_1<CLROf<uint>>;
-    static createScalarUnsafe(value: ulong): Vector64_1<CLROf<ulong>>;
-    static createScalarUnsafe(value: nuint): Vector64_1<CLROf<nuint>>;
+    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>;
+    static createScalarUnsafe(value: int): Vector64_1<System_Internal.Int32>;
+    static createScalarUnsafe(value: long): Vector64_1<System_Internal.Int64>;
+    static createScalarUnsafe(value: nint): Vector64_1<System_Internal.IntPtr>;
+    static createScalarUnsafe(value: sbyte): Vector64_1<System_Internal.SByte>;
+    static createScalarUnsafe(value: float): Vector64_1<System_Internal.Single>;
+    static createScalarUnsafe(value: ushort): Vector64_1<System_Internal.UInt16>;
+    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 degreesToRadians(degrees: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static degreesToRadians(degrees: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    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 exp(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static exp(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    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 floor(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static floor(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static fusedMultiplyAdd(left: Vector64_1<CLROf<double>>, right: Vector64_1<CLROf<double>>, addend: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static fusedMultiplyAdd(left: Vector64_1<CLROf<float>>, right: Vector64_1<CLROf<float>>, addend: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    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;
@@ -1238,8 +1213,8 @@ export abstract class Vector64$instance {
     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 hypot(x: Vector64_1<CLROf<double>>, y: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static hypot(x: Vector64_1<CLROf<float>>, y: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    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>;
@@ -1257,8 +1232,8 @@ export abstract class Vector64$instance {
     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 lerp(x: Vector64_1<CLROf<double>>, y: Vector64_1<CLROf<double>>, amount: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static lerp(x: Vector64_1<CLROf<float>>, y: Vector64_1<CLROf<float>>, amount: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    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;
@@ -1268,12 +1243,12 @@ export abstract class Vector64$instance {
     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: { value: ref<T> }, elementOffset: nuint): Vector64_1<T>;
-    static loadUnsafe<T>(source: { value: ref<T> }): Vector64_1<T>;
-    static log(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static log(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static log2(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static log2(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    static loadUnsafe<T>(source: T, elementOffset: nuint): Vector64_1<T>;
+    static loadUnsafe<T>(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>;
@@ -1287,111 +1262,111 @@ export abstract class Vector64$instance {
     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 multiplyAddEstimate(left: Vector64_1<CLROf<double>>, right: Vector64_1<CLROf<double>>, addend: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static multiplyAddEstimate(left: Vector64_1<CLROf<float>>, right: Vector64_1<CLROf<float>>, addend: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static narrow(lower: Vector64_1<CLROf<double>>, upper: Vector64_1<CLROf<double>>): Vector64_1<CLROf<float>>;
-    static narrow(lower: Vector64_1<CLROf<short>>, upper: Vector64_1<CLROf<short>>): Vector64_1<CLROf<sbyte>>;
-    static narrow(lower: Vector64_1<CLROf<int>>, upper: Vector64_1<CLROf<int>>): Vector64_1<CLROf<short>>;
-    static narrow(lower: Vector64_1<CLROf<long>>, upper: Vector64_1<CLROf<long>>): Vector64_1<CLROf<int>>;
-    static narrow(lower: Vector64_1<CLROf<ushort>>, upper: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<byte>>;
-    static narrow(lower: Vector64_1<CLROf<uint>>, upper: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ushort>>;
-    static narrow(lower: Vector64_1<CLROf<ulong>>, upper: Vector64_1<CLROf<ulong>>): Vector64_1<CLROf<uint>>;
-    static narrowWithSaturation(lower: Vector64_1<CLROf<double>>, upper: Vector64_1<CLROf<double>>): Vector64_1<CLROf<float>>;
-    static narrowWithSaturation(lower: Vector64_1<CLROf<short>>, upper: Vector64_1<CLROf<short>>): Vector64_1<CLROf<sbyte>>;
-    static narrowWithSaturation(lower: Vector64_1<CLROf<int>>, upper: Vector64_1<CLROf<int>>): Vector64_1<CLROf<short>>;
-    static narrowWithSaturation(lower: Vector64_1<CLROf<long>>, upper: Vector64_1<CLROf<long>>): Vector64_1<CLROf<int>>;
-    static narrowWithSaturation(lower: Vector64_1<CLROf<ushort>>, upper: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<byte>>;
-    static narrowWithSaturation(lower: Vector64_1<CLROf<uint>>, upper: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ushort>>;
-    static narrowWithSaturation(lower: Vector64_1<CLROf<ulong>>, upper: Vector64_1<CLROf<ulong>>): Vector64_1<CLROf<uint>>;
+    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>;
+    static narrow(lower: Vector64_1<System_Internal.Int16>, upper: Vector64_1<System_Internal.Int16>): Vector64_1<System_Internal.SByte>;
+    static narrow(lower: Vector64_1<System_Internal.Int32>, upper: Vector64_1<System_Internal.Int32>): Vector64_1<System_Internal.Int16>;
+    static narrow(lower: Vector64_1<System_Internal.Int64>, upper: Vector64_1<System_Internal.Int64>): Vector64_1<System_Internal.Int32>;
+    static narrow(lower: Vector64_1<System_Internal.UInt16>, upper: Vector64_1<System_Internal.UInt16>): Vector64_1<System_Internal.Byte>;
+    static narrow(lower: Vector64_1<System_Internal.UInt32>, upper: Vector64_1<System_Internal.UInt32>): Vector64_1<System_Internal.UInt16>;
+    static narrow(lower: Vector64_1<System_Internal.UInt64>, upper: Vector64_1<System_Internal.UInt64>): Vector64_1<System_Internal.UInt32>;
+    static narrowWithSaturation(lower: Vector64_1<System_Internal.Double>, upper: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Single>;
+    static narrowWithSaturation(lower: Vector64_1<System_Internal.Int16>, upper: Vector64_1<System_Internal.Int16>): Vector64_1<System_Internal.SByte>;
+    static narrowWithSaturation(lower: Vector64_1<System_Internal.Int32>, upper: Vector64_1<System_Internal.Int32>): Vector64_1<System_Internal.Int16>;
+    static narrowWithSaturation(lower: Vector64_1<System_Internal.Int64>, upper: Vector64_1<System_Internal.Int64>): Vector64_1<System_Internal.Int32>;
+    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 radiansToDegrees(radians: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static radiansToDegrees(radians: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static round(vector: Vector64_1<CLROf<double>>, mode: MidpointRounding): Vector64_1<CLROf<double>>;
-    static round(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static round(vector: Vector64_1<CLROf<float>>, mode: MidpointRounding): Vector64_1<CLROf<float>>;
-    static round(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static shiftLeft(vector: Vector64_1<CLROf<byte>>, shiftCount: int): Vector64_1<CLROf<byte>>;
-    static shiftLeft(vector: Vector64_1<CLROf<short>>, shiftCount: int): Vector64_1<CLROf<short>>;
-    static shiftLeft(vector: Vector64_1<CLROf<int>>, shiftCount: int): Vector64_1<CLROf<int>>;
-    static shiftLeft(vector: Vector64_1<CLROf<long>>, shiftCount: int): Vector64_1<CLROf<long>>;
-    static shiftLeft(vector: Vector64_1<CLROf<nint>>, shiftCount: int): Vector64_1<CLROf<nint>>;
-    static shiftLeft(vector: Vector64_1<CLROf<sbyte>>, shiftCount: int): Vector64_1<CLROf<sbyte>>;
-    static shiftLeft(vector: Vector64_1<CLROf<ushort>>, shiftCount: int): Vector64_1<CLROf<ushort>>;
-    static shiftLeft(vector: Vector64_1<CLROf<uint>>, shiftCount: int): Vector64_1<CLROf<uint>>;
-    static shiftLeft(vector: Vector64_1<CLROf<ulong>>, shiftCount: int): Vector64_1<CLROf<ulong>>;
-    static shiftLeft(vector: Vector64_1<CLROf<nuint>>, shiftCount: int): Vector64_1<CLROf<nuint>>;
-    static shiftRightArithmetic(vector: Vector64_1<CLROf<short>>, shiftCount: int): Vector64_1<CLROf<short>>;
-    static shiftRightArithmetic(vector: Vector64_1<CLROf<int>>, shiftCount: int): Vector64_1<CLROf<int>>;
-    static shiftRightArithmetic(vector: Vector64_1<CLROf<long>>, shiftCount: int): Vector64_1<CLROf<long>>;
-    static shiftRightArithmetic(vector: Vector64_1<CLROf<nint>>, shiftCount: int): Vector64_1<CLROf<nint>>;
-    static shiftRightArithmetic(vector: Vector64_1<CLROf<sbyte>>, shiftCount: int): Vector64_1<CLROf<sbyte>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<byte>>, shiftCount: int): Vector64_1<CLROf<byte>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<short>>, shiftCount: int): Vector64_1<CLROf<short>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<int>>, shiftCount: int): Vector64_1<CLROf<int>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<long>>, shiftCount: int): Vector64_1<CLROf<long>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<nint>>, shiftCount: int): Vector64_1<CLROf<nint>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<sbyte>>, shiftCount: int): Vector64_1<CLROf<sbyte>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<ushort>>, shiftCount: int): Vector64_1<CLROf<ushort>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<uint>>, shiftCount: int): Vector64_1<CLROf<uint>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<ulong>>, shiftCount: int): Vector64_1<CLROf<ulong>>;
-    static shiftRightLogical(vector: Vector64_1<CLROf<nuint>>, shiftCount: int): Vector64_1<CLROf<nuint>>;
-    static shuffle(vector: Vector64_1<CLROf<byte>>, indices: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<byte>>;
-    static shuffle(vector: Vector64_1<CLROf<short>>, indices: Vector64_1<CLROf<short>>): Vector64_1<CLROf<short>>;
-    static shuffle(vector: Vector64_1<CLROf<int>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<int>>;
-    static shuffle(vector: Vector64_1<CLROf<sbyte>>, indices: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<sbyte>>;
-    static shuffle(vector: Vector64_1<CLROf<float>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<float>>;
-    static shuffle(vector: Vector64_1<CLROf<ushort>>, indices: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<ushort>>;
-    static shuffle(vector: Vector64_1<CLROf<uint>>, indices: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<uint>>;
-    static shuffleNative(vector: Vector64_1<CLROf<byte>>, indices: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<byte>>;
-    static shuffleNative(vector: Vector64_1<CLROf<short>>, indices: Vector64_1<CLROf<short>>): Vector64_1<CLROf<short>>;
-    static shuffleNative(vector: Vector64_1<CLROf<int>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<int>>;
-    static shuffleNative(vector: Vector64_1<CLROf<sbyte>>, indices: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<sbyte>>;
-    static shuffleNative(vector: Vector64_1<CLROf<float>>, indices: Vector64_1<CLROf<int>>): Vector64_1<CLROf<float>>;
-    static shuffleNative(vector: Vector64_1<CLROf<ushort>>, indices: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<ushort>>;
-    static shuffleNative(vector: Vector64_1<CLROf<uint>>, indices: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<uint>>;
-    static sin(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static sin(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
-    static sinCos(vector: Vector64_1<CLROf<double>>): ValueTuple_2<Vector64_1<CLROf<double>>, Vector64_1<CLROf<double>>>;
-    static sinCos(vector: Vector64_1<CLROf<float>>): ValueTuple_2<Vector64_1<CLROf<float>>, Vector64_1<CLROf<float>>>;
+    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>;
+    static round(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
+    static round(vector: Vector64_1<System_Internal.Single>, mode: MidpointRounding): Vector64_1<System_Internal.Single>;
+    static round(vector: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Single>;
+    static shiftLeft(vector: Vector64_1<System_Internal.Byte>, shiftCount: int): Vector64_1<System_Internal.Byte>;
+    static shiftLeft(vector: Vector64_1<System_Internal.Int16>, shiftCount: int): Vector64_1<System_Internal.Int16>;
+    static shiftLeft(vector: Vector64_1<System_Internal.Int32>, shiftCount: int): Vector64_1<System_Internal.Int32>;
+    static shiftLeft(vector: Vector64_1<System_Internal.Int64>, shiftCount: int): Vector64_1<System_Internal.Int64>;
+    static shiftLeft(vector: Vector64_1<System_Internal.IntPtr>, shiftCount: int): Vector64_1<System_Internal.IntPtr>;
+    static shiftLeft(vector: Vector64_1<System_Internal.SByte>, shiftCount: int): Vector64_1<System_Internal.SByte>;
+    static shiftLeft(vector: Vector64_1<System_Internal.UInt16>, shiftCount: int): Vector64_1<System_Internal.UInt16>;
+    static shiftLeft(vector: Vector64_1<System_Internal.UInt32>, shiftCount: int): Vector64_1<System_Internal.UInt32>;
+    static shiftLeft(vector: Vector64_1<System_Internal.UInt64>, shiftCount: int): Vector64_1<System_Internal.UInt64>;
+    static shiftLeft(vector: Vector64_1<System_Internal.UIntPtr>, shiftCount: int): Vector64_1<System_Internal.UIntPtr>;
+    static shiftRightArithmetic(vector: Vector64_1<System_Internal.Int16>, shiftCount: int): Vector64_1<System_Internal.Int16>;
+    static shiftRightArithmetic(vector: Vector64_1<System_Internal.Int32>, shiftCount: int): Vector64_1<System_Internal.Int32>;
+    static shiftRightArithmetic(vector: Vector64_1<System_Internal.Int64>, shiftCount: int): Vector64_1<System_Internal.Int64>;
+    static shiftRightArithmetic(vector: Vector64_1<System_Internal.IntPtr>, shiftCount: int): Vector64_1<System_Internal.IntPtr>;
+    static shiftRightArithmetic(vector: Vector64_1<System_Internal.SByte>, shiftCount: int): Vector64_1<System_Internal.SByte>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.Byte>, shiftCount: int): Vector64_1<System_Internal.Byte>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.Int16>, shiftCount: int): Vector64_1<System_Internal.Int16>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.Int32>, shiftCount: int): Vector64_1<System_Internal.Int32>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.Int64>, shiftCount: int): Vector64_1<System_Internal.Int64>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.IntPtr>, shiftCount: int): Vector64_1<System_Internal.IntPtr>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.SByte>, shiftCount: int): Vector64_1<System_Internal.SByte>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.UInt16>, shiftCount: int): Vector64_1<System_Internal.UInt16>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.UInt32>, shiftCount: int): Vector64_1<System_Internal.UInt32>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.UInt64>, shiftCount: int): Vector64_1<System_Internal.UInt64>;
+    static shiftRightLogical(vector: Vector64_1<System_Internal.UIntPtr>, shiftCount: int): Vector64_1<System_Internal.UIntPtr>;
+    static shuffle(vector: Vector64_1<System_Internal.Byte>, indices: Vector64_1<System_Internal.Byte>): Vector64_1<System_Internal.Byte>;
+    static shuffle(vector: Vector64_1<System_Internal.Int16>, indices: Vector64_1<System_Internal.Int16>): Vector64_1<System_Internal.Int16>;
+    static shuffle(vector: Vector64_1<System_Internal.Int32>, indices: Vector64_1<System_Internal.Int32>): Vector64_1<System_Internal.Int32>;
+    static shuffle(vector: Vector64_1<System_Internal.SByte>, indices: Vector64_1<System_Internal.SByte>): Vector64_1<System_Internal.SByte>;
+    static shuffle(vector: Vector64_1<System_Internal.Single>, indices: Vector64_1<System_Internal.Int32>): Vector64_1<System_Internal.Single>;
+    static shuffle(vector: Vector64_1<System_Internal.UInt16>, indices: Vector64_1<System_Internal.UInt16>): Vector64_1<System_Internal.UInt16>;
+    static shuffle(vector: Vector64_1<System_Internal.UInt32>, indices: Vector64_1<System_Internal.UInt32>): Vector64_1<System_Internal.UInt32>;
+    static shuffleNative(vector: Vector64_1<System_Internal.Byte>, indices: Vector64_1<System_Internal.Byte>): Vector64_1<System_Internal.Byte>;
+    static shuffleNative(vector: Vector64_1<System_Internal.Int16>, indices: Vector64_1<System_Internal.Int16>): Vector64_1<System_Internal.Int16>;
+    static shuffleNative(vector: Vector64_1<System_Internal.Int32>, indices: Vector64_1<System_Internal.Int32>): Vector64_1<System_Internal.Int32>;
+    static shuffleNative(vector: Vector64_1<System_Internal.SByte>, indices: Vector64_1<System_Internal.SByte>): Vector64_1<System_Internal.SByte>;
+    static shuffleNative(vector: Vector64_1<System_Internal.Single>, indices: Vector64_1<System_Internal.Int32>): Vector64_1<System_Internal.Single>;
+    static shuffleNative(vector: Vector64_1<System_Internal.UInt16>, indices: Vector64_1<System_Internal.UInt16>): Vector64_1<System_Internal.UInt16>;
+    static shuffleNative(vector: Vector64_1<System_Internal.UInt32>, indices: Vector64_1<System_Internal.UInt32>): Vector64_1<System_Internal.UInt32>;
+    static sin(vector: Vector64_1<System_Internal.Double>): Vector64_1<System_Internal.Double>;
+    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: { value: ref<T> }, elementOffset: nuint): void;
-    static storeUnsafe<T>(source: Vector64_1<T>, destination: { value: ref<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 truncate(vector: Vector64_1<CLROf<double>>): Vector64_1<CLROf<double>>;
-    static truncate(vector: Vector64_1<CLROf<float>>): Vector64_1<CLROf<float>>;
+    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 widen(source: Vector64_1<CLROf<byte>>): ValueTuple_2<Vector64_1<CLROf<ushort>>, Vector64_1<CLROf<ushort>>>;
-    static widen(source: Vector64_1<CLROf<short>>): ValueTuple_2<Vector64_1<CLROf<int>>, Vector64_1<CLROf<int>>>;
-    static widen(source: Vector64_1<CLROf<int>>): ValueTuple_2<Vector64_1<CLROf<long>>, Vector64_1<CLROf<long>>>;
-    static widen(source: Vector64_1<CLROf<sbyte>>): ValueTuple_2<Vector64_1<CLROf<short>>, Vector64_1<CLROf<short>>>;
-    static widen(source: Vector64_1<CLROf<float>>): ValueTuple_2<Vector64_1<CLROf<double>>, Vector64_1<CLROf<double>>>;
-    static widen(source: Vector64_1<CLROf<ushort>>): ValueTuple_2<Vector64_1<CLROf<uint>>, Vector64_1<CLROf<uint>>>;
-    static widen(source: Vector64_1<CLROf<uint>>): ValueTuple_2<Vector64_1<CLROf<ulong>>, Vector64_1<CLROf<ulong>>>;
-    static widenLower(source: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<ushort>>;
-    static widenLower(source: Vector64_1<CLROf<short>>): Vector64_1<CLROf<int>>;
-    static widenLower(source: Vector64_1<CLROf<int>>): Vector64_1<CLROf<long>>;
-    static widenLower(source: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<short>>;
-    static widenLower(source: Vector64_1<CLROf<float>>): Vector64_1<CLROf<double>>;
-    static widenLower(source: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<uint>>;
-    static widenLower(source: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ulong>>;
-    static widenUpper(source: Vector64_1<CLROf<byte>>): Vector64_1<CLROf<ushort>>;
-    static widenUpper(source: Vector64_1<CLROf<short>>): Vector64_1<CLROf<int>>;
-    static widenUpper(source: Vector64_1<CLROf<int>>): Vector64_1<CLROf<long>>;
-    static widenUpper(source: Vector64_1<CLROf<sbyte>>): Vector64_1<CLROf<short>>;
-    static widenUpper(source: Vector64_1<CLROf<float>>): Vector64_1<CLROf<double>>;
-    static widenUpper(source: Vector64_1<CLROf<ushort>>): Vector64_1<CLROf<uint>>;
-    static widenUpper(source: Vector64_1<CLROf<uint>>): Vector64_1<CLROf<ulong>>;
+    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>>;
+    static widen(source: Vector64_1<System_Internal.SByte>): ValueTuple_2<Vector64_1<System_Internal.Int16>, Vector64_1<System_Internal.Int16>>;
+    static widen(source: Vector64_1<System_Internal.Single>): ValueTuple_2<Vector64_1<System_Internal.Double>, Vector64_1<System_Internal.Double>>;
+    static widen(source: Vector64_1<System_Internal.UInt16>): ValueTuple_2<Vector64_1<System_Internal.UInt32>, Vector64_1<System_Internal.UInt32>>;
+    static widen(source: Vector64_1<System_Internal.UInt32>): ValueTuple_2<Vector64_1<System_Internal.UInt64>, Vector64_1<System_Internal.UInt64>>;
+    static widenLower(source: Vector64_1<System_Internal.Byte>): Vector64_1<System_Internal.UInt16>;
+    static widenLower(source: Vector64_1<System_Internal.Int16>): Vector64_1<System_Internal.Int32>;
+    static widenLower(source: Vector64_1<System_Internal.Int32>): Vector64_1<System_Internal.Int64>;
+    static widenLower(source: Vector64_1<System_Internal.SByte>): Vector64_1<System_Internal.Int16>;
+    static widenLower(source: Vector64_1<System_Internal.Single>): Vector64_1<System_Internal.Double>;
+    static widenLower(source: Vector64_1<System_Internal.UInt16>): Vector64_1<System_Internal.UInt32>;
+    static widenLower(source: Vector64_1<System_Internal.UInt32>): Vector64_1<System_Internal.UInt64>;
+    static widenUpper(source: Vector64_1<System_Internal.Byte>): Vector64_1<System_Internal.UInt16>;
+    static widenUpper(source: Vector64_1<System_Internal.Int16>): Vector64_1<System_Internal.Int32>;
+    static widenUpper(source: Vector64_1<System_Internal.Int32>): Vector64_1<System_Internal.Int64>;
+    static widenUpper(source: Vector64_1<System_Internal.SByte>): Vector64_1<System_Internal.Int16>;
+    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>;
 }