@alloy-js/csharp 0.21.0-dev.12 → 0.21.0-dev.14

package/src/builtins/System/Runtime/InteropServices/index.ts

@@ -1,10 +1,16 @@
 import System from "../../index.js";
 
 import { createLibrary } from "#createLibrary";
-import { LibrarySymbolReference } from "@alloy-js/core";export { default as Marshalling } from "./Marshalling/index.js";
+import { LibrarySymbolReference } from "@alloy-js/core";export { default as ComTypes } from "./ComTypes/index.js";
+export { default as JavaScript } from "./JavaScript/index.js";
+export { default as Marshalling } from "./Marshalling/index.js";
+export { default as ObjectiveC } from "./ObjectiveC/index.js";
 export { default as Swift } from "./Swift/index.js";
 
 type InteropServicesLibrary = LibrarySymbolReference & {
+  AllowReversePInvokeCallsAttribute: LibrarySymbolReference & {
+    AllowReversePInvokeCallsAttribute: LibrarySymbolReference
+  };
   Architecture: LibrarySymbolReference & {
     X86: LibrarySymbolReference;
     X64: LibrarySymbolReference;
@@ -17,16 +23,132 @@ type InteropServicesLibrary = LibrarySymbolReference & {
     Ppc64le: LibrarySymbolReference;
     RiscV64: LibrarySymbolReference
   };
+  ArrayWithOffset: LibrarySymbolReference & {
+    ArrayWithOffset: LibrarySymbolReference;
+    Equals: LibrarySymbolReference;
+    GetArray: LibrarySymbolReference;
+    GetHashCode: LibrarySymbolReference;
+    GetOffset: LibrarySymbolReference
+  };
+  AutomationProxyAttribute: LibrarySymbolReference & {
+    AutomationProxyAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  BestFitMappingAttribute: LibrarySymbolReference & {
+    ThrowOnUnmappableChar: LibrarySymbolReference;
+    BestFitMappingAttribute: LibrarySymbolReference;
+    BestFitMapping: LibrarySymbolReference
+  };
+  CLong: LibrarySymbolReference & {
+    CLong: LibrarySymbolReference;
+    Equals: LibrarySymbolReference;
+    GetHashCode: LibrarySymbolReference;
+    ToString: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  COMException: LibrarySymbolReference & {
+    COMException: LibrarySymbolReference;
+    ToString: LibrarySymbolReference
+  };
+  CULong: LibrarySymbolReference & {
+    CULong: LibrarySymbolReference;
+    Equals: LibrarySymbolReference;
+    GetHashCode: LibrarySymbolReference;
+    ToString: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  CallingConvention: LibrarySymbolReference & {
+    Winapi: LibrarySymbolReference;
+    Cdecl: LibrarySymbolReference;
+    StdCall: LibrarySymbolReference;
+    ThisCall: LibrarySymbolReference;
+    FastCall: LibrarySymbolReference
+  };
   CharSet: LibrarySymbolReference & {
     None: LibrarySymbolReference;
     Ansi: LibrarySymbolReference;
     Unicode: LibrarySymbolReference;
     Auto: LibrarySymbolReference
   };
+  ClassInterfaceAttribute: LibrarySymbolReference & {
+    ClassInterfaceAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  ClassInterfaceType: LibrarySymbolReference & {
+    None: LibrarySymbolReference;
+    AutoDispatch: LibrarySymbolReference;
+    AutoDual: LibrarySymbolReference
+  };
+  CoClassAttribute: LibrarySymbolReference & {
+    CoClassAttribute: LibrarySymbolReference;
+    CoClass: LibrarySymbolReference
+  };
+  CollectionsMarshal: LibrarySymbolReference & {
+
+  };
+  ComAliasNameAttribute: LibrarySymbolReference & {
+    ComAliasNameAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  ComCompatibleVersionAttribute: LibrarySymbolReference & {
+    ComCompatibleVersionAttribute: LibrarySymbolReference;
+    BuildNumber: LibrarySymbolReference;
+    MajorVersion: LibrarySymbolReference;
+    MinorVersion: LibrarySymbolReference;
+    RevisionNumber: LibrarySymbolReference
+  };
+  ComConversionLossAttribute: LibrarySymbolReference & {
+    ComConversionLossAttribute: LibrarySymbolReference
+  };
+  ComDefaultInterfaceAttribute: LibrarySymbolReference & {
+    ComDefaultInterfaceAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  ComImportAttribute: LibrarySymbolReference & {
+    ComImportAttribute: LibrarySymbolReference
+  };
+  ComInterfaceType: LibrarySymbolReference & {
+    InterfaceIsDual: LibrarySymbolReference;
+    InterfaceIsIUnknown: LibrarySymbolReference;
+    InterfaceIsIDispatch: LibrarySymbolReference;
+    InterfaceIsIInspectable: LibrarySymbolReference
+  };
+  ComMemberType: LibrarySymbolReference & {
+    Method: LibrarySymbolReference;
+    PropGet: LibrarySymbolReference;
+    PropSet: LibrarySymbolReference
+  };
+  ComRegisterFunctionAttribute: LibrarySymbolReference & {
+    ComRegisterFunctionAttribute: LibrarySymbolReference
+  };
+  ComUnregisterFunctionAttribute: LibrarySymbolReference & {
+    ComUnregisterFunctionAttribute: LibrarySymbolReference
+  };
   ComVisibleAttribute: LibrarySymbolReference & {
     ComVisibleAttribute: LibrarySymbolReference;
     Value: LibrarySymbolReference
   };
+  ComWrappers: LibrarySymbolReference & {
+    ComInterfaceDispatch: LibrarySymbolReference & {
+      Vtable: LibrarySymbolReference
+    };
+    ComInterfaceEntry: LibrarySymbolReference & {
+      IID: LibrarySymbolReference;
+      Vtable: LibrarySymbolReference
+    }
+  };
+  CreateComInterfaceFlags: LibrarySymbolReference & {
+    None: LibrarySymbolReference;
+    CallerDefinedIUnknown: LibrarySymbolReference;
+    TrackerSupport: LibrarySymbolReference
+  };
+  CreateObjectFlags: LibrarySymbolReference & {
+    None: LibrarySymbolReference;
+    TrackerObject: LibrarySymbolReference;
+    UniqueInstance: LibrarySymbolReference;
+    Aggregation: LibrarySymbolReference;
+    Unwrap: LibrarySymbolReference
+  };
   CriticalHandle: LibrarySymbolReference & {
     handle: LibrarySymbolReference;
     CriticalHandle: LibrarySymbolReference;
@@ -39,6 +161,52 @@ type InteropServicesLibrary = LibrarySymbolReference & {
     IsClosed: LibrarySymbolReference;
     IsInvalid: LibrarySymbolReference
   };
+  DefaultCharSetAttribute: LibrarySymbolReference & {
+    DefaultCharSetAttribute: LibrarySymbolReference;
+    CharSet: LibrarySymbolReference
+  };
+  DefaultDllImportSearchPathsAttribute: LibrarySymbolReference & {
+    DefaultDllImportSearchPathsAttribute: LibrarySymbolReference;
+    Paths: LibrarySymbolReference
+  };
+  DefaultParameterValueAttribute: LibrarySymbolReference & {
+    DefaultParameterValueAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  DispIdAttribute: LibrarySymbolReference & {
+    DispIdAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  DllImportAttribute: LibrarySymbolReference & {
+    BestFitMapping: LibrarySymbolReference;
+    CallingConvention: LibrarySymbolReference;
+    CharSet: LibrarySymbolReference;
+    EntryPoint: LibrarySymbolReference;
+    ExactSpelling: LibrarySymbolReference;
+    PreserveSig: LibrarySymbolReference;
+    SetLastError: LibrarySymbolReference;
+    ThrowOnUnmappableChar: LibrarySymbolReference;
+    DllImportAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  DllImportResolver: LibrarySymbolReference & {
+    DllImportResolver: LibrarySymbolReference;
+    Invoke: LibrarySymbolReference;
+    BeginInvoke: LibrarySymbolReference;
+    EndInvoke: LibrarySymbolReference
+  };
+  DllImportSearchPath: LibrarySymbolReference & {
+    LegacyBehavior: LibrarySymbolReference;
+    AssemblyDirectory: LibrarySymbolReference;
+    UseDllDirectoryForDependencies: LibrarySymbolReference;
+    ApplicationDirectory: LibrarySymbolReference;
+    UserDirectories: LibrarySymbolReference;
+    System32: LibrarySymbolReference;
+    SafeDirectories: LibrarySymbolReference
+  };
+  DynamicInterfaceCastableImplementationAttribute: LibrarySymbolReference & {
+    DynamicInterfaceCastableImplementationAttribute: LibrarySymbolReference
+  };
   ExternalException: LibrarySymbolReference & {
     ExternalException: LibrarySymbolReference;
     ToString: LibrarySymbolReference;
@@ -65,19 +233,315 @@ type InteropServicesLibrary = LibrarySymbolReference & {
     Normal: LibrarySymbolReference;
     Pinned: LibrarySymbolReference
   };
+  GuidAttribute: LibrarySymbolReference & {
+    GuidAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  HandleCollector: LibrarySymbolReference & {
+    HandleCollector: LibrarySymbolReference;
+    Add: LibrarySymbolReference;
+    Remove: LibrarySymbolReference;
+    Count: LibrarySymbolReference;
+    InitialThreshold: LibrarySymbolReference;
+    MaximumThreshold: LibrarySymbolReference;
+    Name: LibrarySymbolReference
+  };
+  HandleRef: LibrarySymbolReference & {
+    HandleRef: LibrarySymbolReference;
+    ToIntPtr: LibrarySymbolReference;
+    Handle: LibrarySymbolReference;
+    Wrapper: LibrarySymbolReference
+  };
+  ICustomFactory: LibrarySymbolReference & {
+    CreateInstance: LibrarySymbolReference
+  };
+  ICustomMarshaler: LibrarySymbolReference & {
+    CleanUpManagedData: LibrarySymbolReference;
+    CleanUpNativeData: LibrarySymbolReference;
+    GetNativeDataSize: LibrarySymbolReference;
+    MarshalManagedToNative: LibrarySymbolReference;
+    MarshalNativeToManaged: LibrarySymbolReference
+  };
+  IDynamicInterfaceCastable: LibrarySymbolReference & {
+    IsInterfaceImplemented: LibrarySymbolReference;
+    GetInterfaceImplementation: LibrarySymbolReference
+  };
+  ImmutableCollectionsMarshal: LibrarySymbolReference & {
+
+  };
+  ImportedFromTypeLibAttribute: LibrarySymbolReference & {
+    ImportedFromTypeLibAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
   InAttribute: LibrarySymbolReference & {
     InAttribute: LibrarySymbolReference
   };
+  InterfaceTypeAttribute: LibrarySymbolReference & {
+    InterfaceTypeAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  InvalidComObjectException: LibrarySymbolReference & {
+    InvalidComObjectException: LibrarySymbolReference
+  };
+  InvalidOleVariantTypeException: LibrarySymbolReference & {
+    InvalidOleVariantTypeException: LibrarySymbolReference
+  };
+  JsonMarshal: LibrarySymbolReference & {
+    GetRawUtf8Value: LibrarySymbolReference
+  };
+  LCIDConversionAttribute: LibrarySymbolReference & {
+    LCIDConversionAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
   LayoutKind: LibrarySymbolReference & {
     Sequential: LibrarySymbolReference;
     Explicit: LibrarySymbolReference;
     Auto: LibrarySymbolReference
   };
+  LibraryImportAttribute: LibrarySymbolReference & {
+    LibraryImportAttribute: LibrarySymbolReference;
+    LibraryName: LibrarySymbolReference;
+    EntryPoint: LibrarySymbolReference;
+    SetLastError: LibrarySymbolReference;
+    StringMarshalling: LibrarySymbolReference;
+    StringMarshallingCustomType: LibrarySymbolReference
+  };
+  ManagedToNativeComInteropStubAttribute: LibrarySymbolReference & {
+    ManagedToNativeComInteropStubAttribute: LibrarySymbolReference;
+    ClassType: LibrarySymbolReference;
+    MethodName: LibrarySymbolReference
+  };
+  Marshal: LibrarySymbolReference & {
+    SystemDefaultCharSize: LibrarySymbolReference;
+    SystemMaxDBCSCharSize: LibrarySymbolReference;
+    AddRef: LibrarySymbolReference;
+    AllocCoTaskMem: LibrarySymbolReference;
+    AllocHGlobal: LibrarySymbolReference;
+    AreComObjectsAvailableForCleanup: LibrarySymbolReference;
+    BindToMoniker: LibrarySymbolReference;
+    ChangeWrapperHandleStrength: LibrarySymbolReference;
+    CleanupUnusedObjectsInCurrentContext: LibrarySymbolReference;
+    Copy: LibrarySymbolReference;
+    FinalReleaseComObject: LibrarySymbolReference;
+    FreeBSTR: LibrarySymbolReference;
+    FreeCoTaskMem: LibrarySymbolReference;
+    FreeHGlobal: LibrarySymbolReference;
+    GenerateGuidForType: LibrarySymbolReference;
+    GenerateProgIdForType: LibrarySymbolReference;
+    GetComObjectData: LibrarySymbolReference;
+    GetEndComSlot: LibrarySymbolReference;
+    GetExceptionForHR: LibrarySymbolReference;
+    GetExceptionPointers: LibrarySymbolReference;
+    GetHINSTANCE: LibrarySymbolReference;
+    GetHRForException: LibrarySymbolReference;
+    GetHRForLastWin32Error: LibrarySymbolReference;
+    GetIDispatchForObject: LibrarySymbolReference;
+    GetIUnknownForObject: LibrarySymbolReference;
+    GetLastPInvokeError: LibrarySymbolReference;
+    GetLastSystemError: LibrarySymbolReference;
+    GetLastWin32Error: LibrarySymbolReference;
+    GetLastPInvokeErrorMessage: LibrarySymbolReference;
+    GetPInvokeErrorMessage: LibrarySymbolReference;
+    GetObjectForIUnknown: LibrarySymbolReference;
+    GetStartComSlot: LibrarySymbolReference;
+    GetTypedObjectForIUnknown: LibrarySymbolReference;
+    GetTypeFromCLSID: LibrarySymbolReference;
+    GetTypeInfoName: LibrarySymbolReference;
+    GetUniqueObjectForIUnknown: LibrarySymbolReference;
+    InitHandle: LibrarySymbolReference;
+    IsComObject: LibrarySymbolReference;
+    IsTypeVisibleFromCom: LibrarySymbolReference;
+    Prelink: LibrarySymbolReference;
+    PrelinkAll: LibrarySymbolReference;
+    PtrToStringAnsi: LibrarySymbolReference;
+    PtrToStringAuto: LibrarySymbolReference;
+    PtrToStringBSTR: LibrarySymbolReference;
+    PtrToStringUni: LibrarySymbolReference;
+    PtrToStringUTF8: LibrarySymbolReference;
+    QueryInterface: LibrarySymbolReference;
+    ReadByte: LibrarySymbolReference;
+    ReadInt16: LibrarySymbolReference;
+    ReadInt32: LibrarySymbolReference;
+    ReadInt64: LibrarySymbolReference;
+    ReadIntPtr: LibrarySymbolReference;
+    ReAllocCoTaskMem: LibrarySymbolReference;
+    ReAllocHGlobal: LibrarySymbolReference;
+    Release: LibrarySymbolReference;
+    ReleaseComObject: LibrarySymbolReference;
+    SecureStringToBSTR: LibrarySymbolReference;
+    SecureStringToCoTaskMemAnsi: LibrarySymbolReference;
+    SecureStringToCoTaskMemUnicode: LibrarySymbolReference;
+    SecureStringToGlobalAllocAnsi: LibrarySymbolReference;
+    SecureStringToGlobalAllocUnicode: LibrarySymbolReference;
+    SetComObjectData: LibrarySymbolReference;
+    SetLastPInvokeError: LibrarySymbolReference;
+    SetLastSystemError: LibrarySymbolReference;
+    StringToBSTR: LibrarySymbolReference;
+    StringToCoTaskMemAnsi: LibrarySymbolReference;
+    StringToCoTaskMemAuto: LibrarySymbolReference;
+    StringToCoTaskMemUni: LibrarySymbolReference;
+    StringToCoTaskMemUTF8: LibrarySymbolReference;
+    StringToHGlobalAnsi: LibrarySymbolReference;
+    StringToHGlobalAuto: LibrarySymbolReference;
+    StringToHGlobalUni: LibrarySymbolReference;
+    ThrowExceptionForHR: LibrarySymbolReference;
+    WriteByte: LibrarySymbolReference;
+    WriteInt16: LibrarySymbolReference;
+    WriteInt32: LibrarySymbolReference;
+    WriteInt64: LibrarySymbolReference;
+    WriteIntPtr: LibrarySymbolReference;
+    ZeroFreeBSTR: LibrarySymbolReference;
+    ZeroFreeCoTaskMemAnsi: LibrarySymbolReference;
+    ZeroFreeCoTaskMemUnicode: LibrarySymbolReference;
+    ZeroFreeCoTaskMemUTF8: LibrarySymbolReference;
+    ZeroFreeGlobalAllocAnsi: LibrarySymbolReference;
+    ZeroFreeGlobalAllocUnicode: LibrarySymbolReference
+  };
+  MarshalAsAttribute: LibrarySymbolReference & {
+    ArraySubType: LibrarySymbolReference;
+    IidParameterIndex: LibrarySymbolReference;
+    MarshalCookie: LibrarySymbolReference;
+    MarshalType: LibrarySymbolReference;
+    MarshalTypeRef: LibrarySymbolReference;
+    SafeArraySubType: LibrarySymbolReference;
+    SafeArrayUserDefinedSubType: LibrarySymbolReference;
+    SizeConst: LibrarySymbolReference;
+    SizeParamIndex: LibrarySymbolReference;
+    MarshalAsAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  MarshalDirectiveException: LibrarySymbolReference & {
+    MarshalDirectiveException: LibrarySymbolReference
+  };
   MemoryMarshal: LibrarySymbolReference & {
     CreateReadOnlySpanFromNullTerminated: LibrarySymbolReference;
     GetArrayDataReference: LibrarySymbolReference;
     TryGetString: LibrarySymbolReference
   };
+  NFloat: LibrarySymbolReference & {
+    NFloat: LibrarySymbolReference;
+    Abs: LibrarySymbolReference;
+    Acos: LibrarySymbolReference;
+    Acosh: LibrarySymbolReference;
+    AcosPi: LibrarySymbolReference;
+    Asin: LibrarySymbolReference;
+    Asinh: LibrarySymbolReference;
+    AsinPi: LibrarySymbolReference;
+    Atan: LibrarySymbolReference;
+    Atan2: LibrarySymbolReference;
+    Atan2Pi: LibrarySymbolReference;
+    Atanh: LibrarySymbolReference;
+    AtanPi: LibrarySymbolReference;
+    BitDecrement: LibrarySymbolReference;
+    BitIncrement: LibrarySymbolReference;
+    Cbrt: LibrarySymbolReference;
+    Ceiling: LibrarySymbolReference;
+    Clamp: LibrarySymbolReference;
+    CompareTo: LibrarySymbolReference;
+    CopySign: LibrarySymbolReference;
+    Cos: LibrarySymbolReference;
+    Cosh: LibrarySymbolReference;
+    CosPi: LibrarySymbolReference;
+    DegreesToRadians: LibrarySymbolReference;
+    Equals: LibrarySymbolReference;
+    Exp: LibrarySymbolReference;
+    Exp10: LibrarySymbolReference;
+    Exp10M1: LibrarySymbolReference;
+    Exp2: LibrarySymbolReference;
+    Exp2M1: LibrarySymbolReference;
+    ExpM1: LibrarySymbolReference;
+    Floor: LibrarySymbolReference;
+    FusedMultiplyAdd: LibrarySymbolReference;
+    GetHashCode: LibrarySymbolReference;
+    Hypot: LibrarySymbolReference;
+    Ieee754Remainder: LibrarySymbolReference;
+    ILogB: LibrarySymbolReference;
+    IsEvenInteger: LibrarySymbolReference;
+    IsFinite: LibrarySymbolReference;
+    IsInfinity: LibrarySymbolReference;
+    IsInteger: LibrarySymbolReference;
+    IsNaN: LibrarySymbolReference;
+    IsNegative: LibrarySymbolReference;
+    IsNegativeInfinity: LibrarySymbolReference;
+    IsNormal: LibrarySymbolReference;
+    IsOddInteger: LibrarySymbolReference;
+    IsPositive: LibrarySymbolReference;
+    IsPositiveInfinity: LibrarySymbolReference;
+    IsPow2: LibrarySymbolReference;
+    IsRealNumber: LibrarySymbolReference;
+    IsSubnormal: LibrarySymbolReference;
+    Lerp: LibrarySymbolReference;
+    Log: LibrarySymbolReference;
+    Log10: LibrarySymbolReference;
+    Log10P1: LibrarySymbolReference;
+    Log2: LibrarySymbolReference;
+    Log2P1: LibrarySymbolReference;
+    LogP1: LibrarySymbolReference;
+    Max: LibrarySymbolReference;
+    MaxMagnitude: LibrarySymbolReference;
+    MaxMagnitudeNumber: LibrarySymbolReference;
+    MaxNumber: LibrarySymbolReference;
+    Min: LibrarySymbolReference;
+    MinMagnitude: LibrarySymbolReference;
+    MinMagnitudeNumber: LibrarySymbolReference;
+    MinNumber: LibrarySymbolReference;
+    MultiplyAddEstimate: LibrarySymbolReference;
+    Parse: LibrarySymbolReference;
+    Pow: LibrarySymbolReference;
+    RadiansToDegrees: LibrarySymbolReference;
+    ReciprocalEstimate: LibrarySymbolReference;
+    ReciprocalSqrtEstimate: LibrarySymbolReference;
+    RootN: LibrarySymbolReference;
+    Round: LibrarySymbolReference;
+    ScaleB: LibrarySymbolReference;
+    Sign: LibrarySymbolReference;
+    Sin: LibrarySymbolReference;
+    SinCos: LibrarySymbolReference;
+    SinCosPi: LibrarySymbolReference;
+    Sinh: LibrarySymbolReference;
+    SinPi: LibrarySymbolReference;
+    Sqrt: LibrarySymbolReference;
+    Tan: LibrarySymbolReference;
+    Tanh: LibrarySymbolReference;
+    TanPi: LibrarySymbolReference;
+    ToString: LibrarySymbolReference;
+    Truncate: LibrarySymbolReference;
+    TryFormat: LibrarySymbolReference;
+    TryParse: LibrarySymbolReference;
+    E: LibrarySymbolReference;
+    Epsilon: LibrarySymbolReference;
+    MaxValue: LibrarySymbolReference;
+    MinValue: LibrarySymbolReference;
+    NaN: LibrarySymbolReference;
+    NegativeInfinity: LibrarySymbolReference;
+    NegativeZero: LibrarySymbolReference;
+    Pi: LibrarySymbolReference;
+    PositiveInfinity: LibrarySymbolReference;
+    Size: LibrarySymbolReference;
+    Tau: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  NativeLibrary: LibrarySymbolReference & {
+    Free: LibrarySymbolReference;
+    GetMainProgramHandle: LibrarySymbolReference;
+    GetExport: LibrarySymbolReference;
+    Load: LibrarySymbolReference;
+    SetDllImportResolver: LibrarySymbolReference;
+    TryGetExport: LibrarySymbolReference;
+    TryLoad: LibrarySymbolReference
+  };
+  NativeMemory: LibrarySymbolReference & {
+    AlignedAlloc: LibrarySymbolReference;
+    AlignedFree: LibrarySymbolReference;
+    AlignedRealloc: LibrarySymbolReference;
+    Alloc: LibrarySymbolReference;
+    AllocZeroed: LibrarySymbolReference;
+    Free: LibrarySymbolReference;
+    Realloc: LibrarySymbolReference;
+    Clear: LibrarySymbolReference;
+    Copy: LibrarySymbolReference;
+    Fill: LibrarySymbolReference
+  };
   OSPlatform: LibrarySymbolReference & {
     Create: LibrarySymbolReference;
     Equals: LibrarySymbolReference;
@@ -88,9 +552,54 @@ type InteropServicesLibrary = LibrarySymbolReference & {
     OSX: LibrarySymbolReference;
     Windows: LibrarySymbolReference
   };
+  OptionalAttribute: LibrarySymbolReference & {
+    OptionalAttribute: LibrarySymbolReference
+  };
   OutAttribute: LibrarySymbolReference & {
     OutAttribute: LibrarySymbolReference
   };
+  PosixSignal: LibrarySymbolReference & {
+    SIGTSTP: LibrarySymbolReference;
+    SIGTTOU: LibrarySymbolReference;
+    SIGTTIN: LibrarySymbolReference;
+    SIGWINCH: LibrarySymbolReference;
+    SIGCONT: LibrarySymbolReference;
+    SIGCHLD: LibrarySymbolReference;
+    SIGTERM: LibrarySymbolReference;
+    SIGQUIT: LibrarySymbolReference;
+    SIGINT: LibrarySymbolReference;
+    SIGHUP: LibrarySymbolReference
+  };
+  PosixSignalContext: LibrarySymbolReference & {
+    PosixSignalContext: LibrarySymbolReference;
+    Cancel: LibrarySymbolReference;
+    Signal: LibrarySymbolReference
+  };
+  PosixSignalRegistration: LibrarySymbolReference & {
+    Create: LibrarySymbolReference;
+    Dispose: LibrarySymbolReference;
+    Finalize: LibrarySymbolReference
+  };
+  PreserveSigAttribute: LibrarySymbolReference & {
+    PreserveSigAttribute: LibrarySymbolReference
+  };
+  PrimaryInteropAssemblyAttribute: LibrarySymbolReference & {
+    PrimaryInteropAssemblyAttribute: LibrarySymbolReference;
+    MajorVersion: LibrarySymbolReference;
+    MinorVersion: LibrarySymbolReference
+  };
+  ProgIdAttribute: LibrarySymbolReference & {
+    ProgIdAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  RuntimeEnvironment: LibrarySymbolReference & {
+    FromGlobalAccessCache: LibrarySymbolReference;
+    GetRuntimeDirectory: LibrarySymbolReference;
+    GetRuntimeInterfaceAsIntPtr: LibrarySymbolReference;
+    GetRuntimeInterfaceAsObject: LibrarySymbolReference;
+    GetSystemVersion: LibrarySymbolReference;
+    SystemConfigurationFile: LibrarySymbolReference
+  };
   RuntimeInformation: LibrarySymbolReference & {
     IsOSPlatform: LibrarySymbolReference;
     FrameworkDescription: LibrarySymbolReference;
@@ -99,6 +608,16 @@ type InteropServicesLibrary = LibrarySymbolReference & {
     ProcessArchitecture: LibrarySymbolReference;
     RuntimeIdentifier: LibrarySymbolReference
   };
+  SEHException: LibrarySymbolReference & {
+    SEHException: LibrarySymbolReference;
+    CanResume: LibrarySymbolReference
+  };
+  SafeArrayRankMismatchException: LibrarySymbolReference & {
+    SafeArrayRankMismatchException: LibrarySymbolReference
+  };
+  SafeArrayTypeMismatchException: LibrarySymbolReference & {
+    SafeArrayTypeMismatchException: LibrarySymbolReference
+  };
   SafeBuffer: LibrarySymbolReference & {
     SafeBuffer: LibrarySymbolReference;
     AcquirePointer: LibrarySymbolReference;
@@ -121,6 +640,17 @@ type InteropServicesLibrary = LibrarySymbolReference & {
     IsClosed: LibrarySymbolReference;
     IsInvalid: LibrarySymbolReference
   };
+  SequenceMarshal: LibrarySymbolReference & {
+
+  };
+  StandardOleMarshalObject: LibrarySymbolReference & {
+    StandardOleMarshalObject: LibrarySymbolReference
+  };
+  StringMarshalling: LibrarySymbolReference & {
+    Custom: LibrarySymbolReference;
+    Utf8: LibrarySymbolReference;
+    Utf16: LibrarySymbolReference
+  };
   StructLayoutAttribute: LibrarySymbolReference & {
     CharSet: LibrarySymbolReference;
     Pack: LibrarySymbolReference;
@@ -131,6 +661,95 @@ type InteropServicesLibrary = LibrarySymbolReference & {
   SuppressGCTransitionAttribute: LibrarySymbolReference & {
     SuppressGCTransitionAttribute: LibrarySymbolReference
   };
+  TypeIdentifierAttribute: LibrarySymbolReference & {
+    TypeIdentifierAttribute: LibrarySymbolReference;
+    Identifier: LibrarySymbolReference;
+    Scope: LibrarySymbolReference
+  };
+  TypeLibFuncAttribute: LibrarySymbolReference & {
+    TypeLibFuncAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  TypeLibFuncFlags: LibrarySymbolReference & {
+    FRestricted: LibrarySymbolReference;
+    FSource: LibrarySymbolReference;
+    FBindable: LibrarySymbolReference;
+    FRequestEdit: LibrarySymbolReference;
+    FDisplayBind: LibrarySymbolReference;
+    FDefaultBind: LibrarySymbolReference;
+    FHidden: LibrarySymbolReference;
+    FUsesGetLastError: LibrarySymbolReference;
+    FDefaultCollelem: LibrarySymbolReference;
+    FUiDefault: LibrarySymbolReference;
+    FNonBrowsable: LibrarySymbolReference;
+    FReplaceable: LibrarySymbolReference;
+    FImmediateBind: LibrarySymbolReference
+  };
+  TypeLibImportClassAttribute: LibrarySymbolReference & {
+    TypeLibImportClassAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  TypeLibTypeAttribute: LibrarySymbolReference & {
+    TypeLibTypeAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  TypeLibTypeFlags: LibrarySymbolReference & {
+    FAppObject: LibrarySymbolReference;
+    FCanCreate: LibrarySymbolReference;
+    FLicensed: LibrarySymbolReference;
+    FPreDeclId: LibrarySymbolReference;
+    FHidden: LibrarySymbolReference;
+    FControl: LibrarySymbolReference;
+    FDual: LibrarySymbolReference;
+    FNonExtensible: LibrarySymbolReference;
+    FOleAutomation: LibrarySymbolReference;
+    FRestricted: LibrarySymbolReference;
+    FAggregatable: LibrarySymbolReference;
+    FReplaceable: LibrarySymbolReference;
+    FDispatchable: LibrarySymbolReference;
+    FReverseBind: LibrarySymbolReference
+  };
+  TypeLibVarAttribute: LibrarySymbolReference & {
+    TypeLibVarAttribute: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  TypeLibVarFlags: LibrarySymbolReference & {
+    FReadOnly: LibrarySymbolReference;
+    FSource: LibrarySymbolReference;
+    FBindable: LibrarySymbolReference;
+    FRequestEdit: LibrarySymbolReference;
+    FDisplayBind: LibrarySymbolReference;
+    FDefaultBind: LibrarySymbolReference;
+    FHidden: LibrarySymbolReference;
+    FRestricted: LibrarySymbolReference;
+    FDefaultCollelem: LibrarySymbolReference;
+    FUiDefault: LibrarySymbolReference;
+    FNonBrowsable: LibrarySymbolReference;
+    FReplaceable: LibrarySymbolReference;
+    FImmediateBind: LibrarySymbolReference
+  };
+  TypeLibVersionAttribute: LibrarySymbolReference & {
+    TypeLibVersionAttribute: LibrarySymbolReference;
+    MajorVersion: LibrarySymbolReference;
+    MinorVersion: LibrarySymbolReference
+  };
+  UnmanagedCallConvAttribute: LibrarySymbolReference & {
+    CallConvs: LibrarySymbolReference;
+    UnmanagedCallConvAttribute: LibrarySymbolReference
+  };
+  UnmanagedCallersOnlyAttribute: LibrarySymbolReference & {
+    CallConvs: LibrarySymbolReference;
+    EntryPoint: LibrarySymbolReference;
+    UnmanagedCallersOnlyAttribute: LibrarySymbolReference
+  };
+  UnmanagedFunctionPointerAttribute: LibrarySymbolReference & {
+    BestFitMapping: LibrarySymbolReference;
+    CharSet: LibrarySymbolReference;
+    SetLastError: LibrarySymbolReference;
+    ThrowOnUnmappableChar: LibrarySymbolReference;
+    UnmanagedFunctionPointerAttribute: LibrarySymbolReference;
+    CallingConvention: LibrarySymbolReference
+  };
   UnmanagedType: LibrarySymbolReference & {
     Bool: LibrarySymbolReference;
     I1: LibrarySymbolReference;
@@ -161,9 +780,22 @@ type InteropServicesLibrary = LibrarySymbolReference & {
     IInspectable: LibrarySymbolReference;
     HString: LibrarySymbolReference;
     LPUTF8Str: LibrarySymbolReference
+  };
+  WasmImportLinkageAttribute: LibrarySymbolReference & {
+    WasmImportLinkageAttribute: LibrarySymbolReference
   }
 };
 const InteropServices: InteropServicesLibrary = createLibrary("System.Runtime.InteropServices", {
+  AllowReversePInvokeCallsAttribute: {
+    kind: "class",
+    members: {
+      AllowReversePInvokeCallsAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
   Architecture: {
     kind: "enum",
     members: {
@@ -229,39 +861,37 @@ const InteropServices: InteropServicesLibrary = createLibrary("System.Runtime.In
       },
     },
   },
-  CharSet: {
-    kind: "enum",
+  ArrayWithOffset: {
+    kind: "struct",
     members: {
-      None: {
-        kind: "field",
-        type: () => {
-          return InteropServices.CharSet;
-        },
+      ArrayWithOffset: {
+        kind: "method",
+        methodKind: "constructor",
       },
-      Ansi: {
-        kind: "field",
-        type: () => {
-          return InteropServices.CharSet;
-        },
+      Equals: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
       },
-      Unicode: {
-        kind: "field",
-        type: () => {
-          return InteropServices.CharSet;
-        },
+      GetArray: {
+        kind: "method",
+        methodKind: "ordinary",
       },
-      Auto: {
-        kind: "field",
-        type: () => {
-          return InteropServices.CharSet;
-        },
+      GetHashCode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      GetOffset: {
+        kind: "method",
+        methodKind: "ordinary",
       },
     },
   },
-  ComVisibleAttribute: {
+  AutomationProxyAttribute: {
     kind: "class",
     members: {
-      ComVisibleAttribute: {
+      AutomationProxyAttribute: {
         kind: "method",
         methodKind: "constructor",
       },
@@ -274,64 +904,62 @@ const InteropServices: InteropServicesLibrary = createLibrary("System.Runtime.In
     },
     isSealed: true,
   },
-  CriticalHandle: {
+  BestFitMappingAttribute: {
     kind: "class",
     members: {
-      handle: {
+      ThrowOnUnmappableChar: {
         kind: "field",
         type: () => {
-          return System.IntPtr;
+          return System.Boolean;
         },
       },
-      CriticalHandle: {
+      BestFitMappingAttribute: {
         kind: "method",
         methodKind: "constructor",
       },
-      Close: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      Dispose: {
-        kind: "method",
-        methodKind: "ordinary",
+      BestFitMapping: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
       },
-      Finalize: {
+    },
+    isSealed: true,
+  },
+  CLong: {
+    kind: "struct",
+    members: {
+      CLong: {
         kind: "method",
-        methodKind: "ordinary",
+        methodKind: "constructor",
       },
-      ReleaseHandle: {
+      Equals: {
         kind: "method",
         methodKind: "ordinary",
-        isAbstract: true,
+        isOverride: true,
       },
-      SetHandle: {
+      GetHashCode: {
         kind: "method",
         methodKind: "ordinary",
+        isOverride: true,
       },
-      SetHandleAsInvalid: {
+      ToString: {
         kind: "method",
         methodKind: "ordinary",
+        isOverride: true,
       },
-      IsClosed: {
-        kind: "property",
-        type: () => {
-          return System.Boolean;
-        },
-      },
-      IsInvalid: {
+      Value: {
         kind: "property",
         type: () => {
-          return System.Boolean;
+          return System.IntPtr;
         },
-        isAbstract: true,
       },
     },
-    isAbstract: true,
   },
-  ExternalException: {
+  COMException: {
     kind: "class",
     members: {
-      ExternalException: {
+      COMException: {
         kind: "method",
         methodKind: "constructor",
       },
@@ -340,417 +968,3250 @@ const InteropServices: InteropServicesLibrary = createLibrary("System.Runtime.In
         methodKind: "ordinary",
         isOverride: true,
       },
-      ErrorCode: {
-        kind: "property",
-        type: () => {
-          return System.Int32;
-        },
-        isVirtual: true,
-      },
     },
   },
-  FieldOffsetAttribute: {
-    kind: "class",
+  CULong: {
+    kind: "struct",
     members: {
-      FieldOffsetAttribute: {
+      CULong: {
         kind: "method",
         methodKind: "constructor",
       },
-      Value: {
-        kind: "property",
-        type: () => {
-          return System.Int32;
-        },
-      },
-    },
-    isSealed: true,
-  },
-  GCHandle: {
-    kind: "struct",
-    members: {
-      AddrOfPinnedObject: {
+      Equals: {
         kind: "method",
         methodKind: "ordinary",
-        isReadOnly: true,
+        isOverride: true,
       },
-      Alloc: {
+      GetHashCode: {
         kind: "method",
         methodKind: "ordinary",
-        isStatic: true,
+        isOverride: true,
       },
-      Equals: {
+      ToString: {
         kind: "method",
         methodKind: "ordinary",
         isOverride: true,
-        isReadOnly: true,
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.UIntPtr;
+        },
+      },
+    },
+  },
+  CallingConvention: {
+    kind: "enum",
+    members: {
+      Winapi: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CallingConvention;
+        },
+      },
+      Cdecl: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CallingConvention;
+        },
+      },
+      StdCall: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CallingConvention;
+        },
+      },
+      ThisCall: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CallingConvention;
+        },
+      },
+      FastCall: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CallingConvention;
+        },
+      },
+    },
+  },
+  CharSet: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CharSet;
+        },
+      },
+      Ansi: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CharSet;
+        },
+      },
+      Unicode: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CharSet;
+        },
+      },
+      Auto: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CharSet;
+        },
+      },
+    },
+  },
+  ClassInterfaceAttribute: {
+    kind: "class",
+    members: {
+      ClassInterfaceAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return InteropServices.ClassInterfaceType;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  ClassInterfaceType: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ClassInterfaceType;
+        },
+      },
+      AutoDispatch: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ClassInterfaceType;
+        },
+      },
+      AutoDual: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ClassInterfaceType;
+        },
+      },
+    },
+  },
+  CoClassAttribute: {
+    kind: "class",
+    members: {
+      CoClassAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      CoClass: {
+        kind: "property",
+        type: () => {
+          return System.Type;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  CollectionsMarshal: {
+    kind: "class",
+    members: {},
+    isStatic: true,
+  },
+  ComAliasNameAttribute: {
+    kind: "class",
+    members: {
+      ComAliasNameAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  ComCompatibleVersionAttribute: {
+    kind: "class",
+    members: {
+      ComCompatibleVersionAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      BuildNumber: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      MajorVersion: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      MinorVersion: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      RevisionNumber: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  ComConversionLossAttribute: {
+    kind: "class",
+    members: {
+      ComConversionLossAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  ComDefaultInterfaceAttribute: {
+    kind: "class",
+    members: {
+      ComDefaultInterfaceAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.Type;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  ComImportAttribute: {
+    kind: "class",
+    members: {
+      ComImportAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  ComInterfaceType: {
+    kind: "enum",
+    members: {
+      InterfaceIsDual: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ComInterfaceType;
+        },
+      },
+      InterfaceIsIUnknown: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ComInterfaceType;
+        },
+      },
+      InterfaceIsIDispatch: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ComInterfaceType;
+        },
+      },
+      InterfaceIsIInspectable: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ComInterfaceType;
+        },
+      },
+    },
+  },
+  ComMemberType: {
+    kind: "enum",
+    members: {
+      Method: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ComMemberType;
+        },
+      },
+      PropGet: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ComMemberType;
+        },
+      },
+      PropSet: {
+        kind: "field",
+        type: () => {
+          return InteropServices.ComMemberType;
+        },
+      },
+    },
+  },
+  ComRegisterFunctionAttribute: {
+    kind: "class",
+    members: {
+      ComRegisterFunctionAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  ComUnregisterFunctionAttribute: {
+    kind: "class",
+    members: {
+      ComUnregisterFunctionAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  ComVisibleAttribute: {
+    kind: "class",
+    members: {
+      ComVisibleAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  ComWrappers: {
+    kind: "class",
+    members: {
+      ComInterfaceDispatch: {
+        kind: "struct",
+        members: {
+          Vtable: {
+            kind: "field",
+            type: () => {
+              return System.IntPtr;
+            },
+          },
+        },
+      },
+      ComInterfaceEntry: {
+        kind: "struct",
+        members: {
+          IID: {
+            kind: "field",
+            type: () => {
+              return System.Guid;
+            },
+          },
+          Vtable: {
+            kind: "field",
+            type: () => {
+              return System.IntPtr;
+            },
+          },
+        },
+      },
+    },
+  },
+  CreateComInterfaceFlags: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CreateComInterfaceFlags;
+        },
+      },
+      CallerDefinedIUnknown: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CreateComInterfaceFlags;
+        },
+      },
+      TrackerSupport: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CreateComInterfaceFlags;
+        },
+      },
+    },
+  },
+  CreateObjectFlags: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CreateObjectFlags;
+        },
+      },
+      TrackerObject: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CreateObjectFlags;
+        },
+      },
+      UniqueInstance: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CreateObjectFlags;
+        },
+      },
+      Aggregation: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CreateObjectFlags;
+        },
+      },
+      Unwrap: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CreateObjectFlags;
+        },
+      },
+    },
+  },
+  CriticalHandle: {
+    kind: "class",
+    members: {
+      handle: {
+        kind: "field",
+        type: () => {
+          return System.IntPtr;
+        },
+      },
+      CriticalHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Close: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Dispose: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Finalize: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      ReleaseHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isAbstract: true,
+      },
+      SetHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      SetHandleAsInvalid: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      IsClosed: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      IsInvalid: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isAbstract: true,
+      },
+    },
+    isAbstract: true,
+  },
+  DefaultCharSetAttribute: {
+    kind: "class",
+    members: {
+      DefaultCharSetAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      CharSet: {
+        kind: "property",
+        type: () => {
+          return InteropServices.CharSet;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  DefaultDllImportSearchPathsAttribute: {
+    kind: "class",
+    members: {
+      DefaultDllImportSearchPathsAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Paths: {
+        kind: "property",
+        type: () => {
+          return InteropServices.DllImportSearchPath;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  DefaultParameterValueAttribute: {
+    kind: "class",
+    members: {
+      DefaultParameterValueAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.Object;
+        },
+        isNullable: true,
+      },
+    },
+    isSealed: true,
+  },
+  DispIdAttribute: {
+    kind: "class",
+    members: {
+      DispIdAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  DllImportAttribute: {
+    kind: "class",
+    members: {
+      BestFitMapping: {
+        kind: "field",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      CallingConvention: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CallingConvention;
+        },
+      },
+      CharSet: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CharSet;
+        },
+      },
+      EntryPoint: {
+        kind: "field",
+        type: () => {
+          return System.String;
+        },
+        isNullable: true,
+      },
+      ExactSpelling: {
+        kind: "field",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      PreserveSig: {
+        kind: "field",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      SetLastError: {
+        kind: "field",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      ThrowOnUnmappableChar: {
+        kind: "field",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      DllImportAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  DllImportResolver: {
+    kind: "generic",
+    members: {
+      DllImportResolver: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Invoke: {
+        kind: "method",
+        methodKind: "ordinary",
+        isVirtual: true,
+      },
+      BeginInvoke: {
+        kind: "method",
+        methodKind: "ordinary",
+        isVirtual: true,
+      },
+      EndInvoke: {
+        kind: "method",
+        methodKind: "ordinary",
+        isVirtual: true,
+      },
+    },
+  },
+  DllImportSearchPath: {
+    kind: "enum",
+    members: {
+      LegacyBehavior: {
+        kind: "field",
+        type: () => {
+          return InteropServices.DllImportSearchPath;
+        },
+      },
+      AssemblyDirectory: {
+        kind: "field",
+        type: () => {
+          return InteropServices.DllImportSearchPath;
+        },
+      },
+      UseDllDirectoryForDependencies: {
+        kind: "field",
+        type: () => {
+          return InteropServices.DllImportSearchPath;
+        },
+      },
+      ApplicationDirectory: {
+        kind: "field",
+        type: () => {
+          return InteropServices.DllImportSearchPath;
+        },
+      },
+      UserDirectories: {
+        kind: "field",
+        type: () => {
+          return InteropServices.DllImportSearchPath;
+        },
+      },
+      System32: {
+        kind: "field",
+        type: () => {
+          return InteropServices.DllImportSearchPath;
+        },
+      },
+      SafeDirectories: {
+        kind: "field",
+        type: () => {
+          return InteropServices.DllImportSearchPath;
+        },
+      },
+    },
+  },
+  DynamicInterfaceCastableImplementationAttribute: {
+    kind: "class",
+    members: {
+      DynamicInterfaceCastableImplementationAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  ExternalException: {
+    kind: "class",
+    members: {
+      ExternalException: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ToString: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      ErrorCode: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+        isVirtual: true,
+      },
+    },
+  },
+  FieldOffsetAttribute: {
+    kind: "class",
+    members: {
+      FieldOffsetAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  GCHandle: {
+    kind: "struct",
+    members: {
+      AddrOfPinnedObject: {
+        kind: "method",
+        methodKind: "ordinary",
+        isReadOnly: true,
+      },
+      Alloc: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Equals: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+        isReadOnly: true,
+      },
+      Free: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      FromIntPtr: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetHashCode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+        isReadOnly: true,
+      },
+      ToIntPtr: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsAllocated: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isReadOnly: true,
+      },
+      Target: {
+        kind: "property",
+        type: () => {
+          return System.Object;
+        },
+        isNullable: true,
+        isReadOnly: true,
+      },
+    },
+  },
+  GCHandleType: {
+    kind: "enum",
+    members: {
+      Weak: {
+        kind: "field",
+        type: () => {
+          return InteropServices.GCHandleType;
+        },
+      },
+      WeakTrackResurrection: {
+        kind: "field",
+        type: () => {
+          return InteropServices.GCHandleType;
+        },
+      },
+      Normal: {
+        kind: "field",
+        type: () => {
+          return InteropServices.GCHandleType;
+        },
+      },
+      Pinned: {
+        kind: "field",
+        type: () => {
+          return InteropServices.GCHandleType;
+        },
+      },
+    },
+  },
+  GuidAttribute: {
+    kind: "class",
+    members: {
+      GuidAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  HandleCollector: {
+    kind: "class",
+    members: {
+      HandleCollector: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Add: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Remove: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Count: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      InitialThreshold: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      MaximumThreshold: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      Name: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  HandleRef: {
+    kind: "struct",
+    members: {
+      HandleRef: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ToIntPtr: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Handle: {
+        kind: "property",
+        type: () => {
+          return System.IntPtr;
+        },
+      },
+      Wrapper: {
+        kind: "property",
+        type: () => {
+          return System.Object;
+        },
+        isNullable: true,
+      },
+    },
+  },
+  ICustomFactory: {
+    kind: "interface",
+    members: {
+      CreateInstance: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+    },
+  },
+  ICustomMarshaler: {
+    kind: "interface",
+    members: {
+      CleanUpManagedData: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      CleanUpNativeData: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetNativeDataSize: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      MarshalManagedToNative: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      MarshalNativeToManaged: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+    },
+  },
+  IDynamicInterfaceCastable: {
+    kind: "interface",
+    members: {
+      IsInterfaceImplemented: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetInterfaceImplementation: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+    },
+  },
+  ImmutableCollectionsMarshal: {
+    kind: "class",
+    members: {},
+    isStatic: true,
+  },
+  ImportedFromTypeLibAttribute: {
+    kind: "class",
+    members: {
+      ImportedFromTypeLibAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  InAttribute: {
+    kind: "class",
+    members: {
+      InAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  InterfaceTypeAttribute: {
+    kind: "class",
+    members: {
+      InterfaceTypeAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return InteropServices.ComInterfaceType;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  InvalidComObjectException: {
+    kind: "class",
+    members: {
+      InvalidComObjectException: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+  },
+  InvalidOleVariantTypeException: {
+    kind: "class",
+    members: {
+      InvalidOleVariantTypeException: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+  },
+  JsonMarshal: {
+    kind: "class",
+    members: {
+      GetRawUtf8Value: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+    },
+    isStatic: true,
+  },
+  LCIDConversionAttribute: {
+    kind: "class",
+    members: {
+      LCIDConversionAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  LayoutKind: {
+    kind: "enum",
+    members: {
+      Sequential: {
+        kind: "field",
+        type: () => {
+          return InteropServices.LayoutKind;
+        },
+      },
+      Explicit: {
+        kind: "field",
+        type: () => {
+          return InteropServices.LayoutKind;
+        },
+      },
+      Auto: {
+        kind: "field",
+        type: () => {
+          return InteropServices.LayoutKind;
+        },
+      },
+    },
+  },
+  LibraryImportAttribute: {
+    kind: "class",
+    members: {
+      LibraryImportAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      LibraryName: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+      EntryPoint: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+        isNullable: true,
+      },
+      SetLastError: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      StringMarshalling: {
+        kind: "property",
+        type: () => {
+          return InteropServices.StringMarshalling;
+        },
+      },
+      StringMarshallingCustomType: {
+        kind: "property",
+        type: () => {
+          return System.Type;
+        },
+        isNullable: true,
+      },
+    },
+    isSealed: true,
+  },
+  ManagedToNativeComInteropStubAttribute: {
+    kind: "class",
+    members: {
+      ManagedToNativeComInteropStubAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ClassType: {
+        kind: "property",
+        type: () => {
+          return System.Type;
+        },
+      },
+      MethodName: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  Marshal: {
+    kind: "class",
+    members: {
+      SystemDefaultCharSize: {
+        kind: "field",
+        type: () => {
+          return System.Int32;
+        },
+        isStatic: true,
+        isReadOnly: true,
+      },
+      SystemMaxDBCSCharSize: {
+        kind: "field",
+        type: () => {
+          return System.Int32;
+        },
+        isStatic: true,
+        isReadOnly: true,
+      },
+      AddRef: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      AllocCoTaskMem: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      AllocHGlobal: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      AreComObjectsAvailableForCleanup: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      BindToMoniker: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ChangeWrapperHandleStrength: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      CleanupUnusedObjectsInCurrentContext: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Copy: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      FinalReleaseComObject: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      FreeBSTR: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      FreeCoTaskMem: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      FreeHGlobal: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GenerateGuidForType: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GenerateProgIdForType: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetComObjectData: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetEndComSlot: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetExceptionForHR: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetExceptionPointers: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetHINSTANCE: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetHRForException: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetHRForLastWin32Error: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetIDispatchForObject: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetIUnknownForObject: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetLastPInvokeError: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetLastSystemError: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetLastWin32Error: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetLastPInvokeErrorMessage: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetPInvokeErrorMessage: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetObjectForIUnknown: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetStartComSlot: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetTypedObjectForIUnknown: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetTypeFromCLSID: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetTypeInfoName: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetUniqueObjectForIUnknown: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      InitHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsComObject: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsTypeVisibleFromCom: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Prelink: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      PrelinkAll: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      PtrToStringAnsi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      PtrToStringAuto: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      PtrToStringBSTR: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      PtrToStringUni: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      PtrToStringUTF8: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      QueryInterface: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReadByte: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReadInt16: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReadInt32: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReadInt64: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReadIntPtr: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReAllocCoTaskMem: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReAllocHGlobal: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Release: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReleaseComObject: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SecureStringToBSTR: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SecureStringToCoTaskMemAnsi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SecureStringToCoTaskMemUnicode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SecureStringToGlobalAllocAnsi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SecureStringToGlobalAllocUnicode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SetComObjectData: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SetLastPInvokeError: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SetLastSystemError: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      StringToBSTR: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      StringToCoTaskMemAnsi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      StringToCoTaskMemAuto: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      StringToCoTaskMemUni: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      StringToCoTaskMemUTF8: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      StringToHGlobalAnsi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      StringToHGlobalAuto: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      StringToHGlobalUni: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ThrowExceptionForHR: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      WriteByte: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      WriteInt16: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      WriteInt32: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      WriteInt64: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      WriteIntPtr: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ZeroFreeBSTR: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ZeroFreeCoTaskMemAnsi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ZeroFreeCoTaskMemUnicode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ZeroFreeCoTaskMemUTF8: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ZeroFreeGlobalAllocAnsi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ZeroFreeGlobalAllocUnicode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+    },
+    isStatic: true,
+  },
+  MarshalAsAttribute: {
+    kind: "class",
+    members: {
+      ArraySubType: {
+        kind: "field",
+        type: () => {
+          return InteropServices.UnmanagedType;
+        },
+      },
+      IidParameterIndex: {
+        kind: "field",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      MarshalCookie: {
+        kind: "field",
+        type: () => {
+          return System.String;
+        },
+        isNullable: true,
+      },
+      MarshalType: {
+        kind: "field",
+        type: () => {
+          return System.String;
+        },
+        isNullable: true,
+      },
+      MarshalTypeRef: {
+        kind: "field",
+        type: () => {
+          return System.Type;
+        },
+        isNullable: true,
+      },
+      SafeArraySubType: {
+        kind: "field",
+        type: undefined,
+      },
+      SafeArrayUserDefinedSubType: {
+        kind: "field",
+        type: () => {
+          return System.Type;
+        },
+        isNullable: true,
+      },
+      SizeConst: {
+        kind: "field",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      SizeParamIndex: {
+        kind: "field",
+        type: () => {
+          return System.Int16;
+        },
+      },
+      MarshalAsAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return InteropServices.UnmanagedType;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  MarshalDirectiveException: {
+    kind: "class",
+    members: {
+      MarshalDirectiveException: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+  },
+  MemoryMarshal: {
+    kind: "class",
+    members: {
+      CreateReadOnlySpanFromNullTerminated: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetArrayDataReference: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      TryGetString: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+    },
+    isStatic: true,
+  },
+  NFloat: {
+    kind: "struct",
+    members: {
+      NFloat: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Abs: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Acos: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Acosh: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      AcosPi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Asin: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Asinh: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      AsinPi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Atan: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Atan2: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Atan2Pi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Atanh: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      AtanPi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      BitDecrement: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      BitIncrement: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Cbrt: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Ceiling: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Clamp: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      CompareTo: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      CopySign: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Cos: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Cosh: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      CosPi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      DegreesToRadians: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Equals: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      Exp: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Exp10: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Exp10M1: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Exp2: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Exp2M1: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ExpM1: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Floor: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      FusedMultiplyAdd: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetHashCode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      Hypot: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Ieee754Remainder: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ILogB: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsEvenInteger: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsFinite: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsInfinity: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsInteger: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsNaN: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsNegative: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsNegativeInfinity: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsNormal: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsOddInteger: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsPositive: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsPositiveInfinity: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsPow2: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsRealNumber: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      IsSubnormal: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Lerp: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Log: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Log10: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Log10P1: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Log2: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Log2P1: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      LogP1: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Max: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      MaxMagnitude: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      MaxMagnitudeNumber: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      MaxNumber: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Min: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      MinMagnitude: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      MinMagnitudeNumber: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      MinNumber: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      MultiplyAddEstimate: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Parse: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Pow: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      RadiansToDegrees: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReciprocalEstimate: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ReciprocalSqrtEstimate: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      RootN: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Round: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ScaleB: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Sign: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Sin: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SinCos: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SinCosPi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Sinh: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SinPi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Sqrt: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Tan: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Tanh: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      TanPi: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ToString: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      Truncate: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      TryFormat: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      TryParse: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      E: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      Epsilon: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      MaxValue: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      MinValue: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      NaN: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      NegativeInfinity: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      NegativeZero: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      Pi: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      PositiveInfinity: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      Size: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+        isStatic: true,
+      },
+      Tau: {
+        kind: "property",
+        type: () => {
+          return InteropServices.NFloat;
+        },
+        isStatic: true,
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.Double;
+        },
+      },
+    },
+  },
+  NativeLibrary: {
+    kind: "class",
+    members: {
+      Free: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetMainProgramHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetExport: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Load: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SetDllImportResolver: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      TryGetExport: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      TryLoad: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+    },
+    isStatic: true,
+  },
+  NativeMemory: {
+    kind: "class",
+    members: {
+      AlignedAlloc: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      AlignedFree: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      AlignedRealloc: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Alloc: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      AllocZeroed: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
       },
       Free: {
         kind: "method",
         methodKind: "ordinary",
+        isStatic: true,
+      },
+      Realloc: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Clear: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Copy: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Fill: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+    },
+    isStatic: true,
+  },
+  OSPlatform: {
+    kind: "struct",
+    members: {
+      Create: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Equals: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      GetHashCode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      ToString: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      FreeBSD: {
+        kind: "property",
+        type: () => {
+          return InteropServices.OSPlatform;
+        },
+        isStatic: true,
+      },
+      Linux: {
+        kind: "property",
+        type: () => {
+          return InteropServices.OSPlatform;
+        },
+        isStatic: true,
+      },
+      OSX: {
+        kind: "property",
+        type: () => {
+          return InteropServices.OSPlatform;
+        },
+        isStatic: true,
+      },
+      Windows: {
+        kind: "property",
+        type: () => {
+          return InteropServices.OSPlatform;
+        },
+        isStatic: true,
+      },
+    },
+  },
+  OptionalAttribute: {
+    kind: "class",
+    members: {
+      OptionalAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  OutAttribute: {
+    kind: "class",
+    members: {
+      OutAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  PosixSignal: {
+    kind: "enum",
+    members: {
+      SIGTSTP: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+      SIGTTOU: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+      SIGTTIN: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+      SIGWINCH: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+      SIGCONT: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+      SIGCHLD: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+      SIGTERM: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+      SIGQUIT: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+      SIGINT: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+      SIGHUP: {
+        kind: "field",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+    },
+  },
+  PosixSignalContext: {
+    kind: "class",
+    members: {
+      PosixSignalContext: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Cancel: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      Signal: {
+        kind: "property",
+        type: () => {
+          return InteropServices.PosixSignal;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  PosixSignalRegistration: {
+    kind: "class",
+    members: {
+      Create: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Dispose: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Finalize: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+    },
+    isSealed: true,
+  },
+  PreserveSigAttribute: {
+    kind: "class",
+    members: {
+      PreserveSigAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  PrimaryInteropAssemblyAttribute: {
+    kind: "class",
+    members: {
+      PrimaryInteropAssemblyAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      MajorVersion: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      MinorVersion: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  ProgIdAttribute: {
+    kind: "class",
+    members: {
+      ProgIdAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  RuntimeEnvironment: {
+    kind: "class",
+    members: {
+      FromGlobalAccessCache: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetRuntimeDirectory: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetRuntimeInterfaceAsIntPtr: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetRuntimeInterfaceAsObject: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetSystemVersion: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SystemConfigurationFile: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+        isStatic: true,
+      },
+    },
+    isStatic: true,
+  },
+  RuntimeInformation: {
+    kind: "class",
+    members: {
+      IsOSPlatform: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      FrameworkDescription: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+        isStatic: true,
+      },
+      OSArchitecture: {
+        kind: "property",
+        type: () => {
+          return InteropServices.Architecture;
+        },
+        isStatic: true,
+      },
+      OSDescription: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+        isStatic: true,
+      },
+      ProcessArchitecture: {
+        kind: "property",
+        type: () => {
+          return InteropServices.Architecture;
+        },
+        isStatic: true,
+      },
+      RuntimeIdentifier: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+        isStatic: true,
+      },
+    },
+    isStatic: true,
+  },
+  SEHException: {
+    kind: "class",
+    members: {
+      SEHException: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      CanResume: {
+        kind: "method",
+        methodKind: "ordinary",
+        isVirtual: true,
+      },
+    },
+  },
+  SafeArrayRankMismatchException: {
+    kind: "class",
+    members: {
+      SafeArrayRankMismatchException: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+  },
+  SafeArrayTypeMismatchException: {
+    kind: "class",
+    members: {
+      SafeArrayTypeMismatchException: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+  },
+  SafeBuffer: {
+    kind: "class",
+    members: {
+      SafeBuffer: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      AcquirePointer: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Initialize: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      ReleasePointer: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      ByteLength: {
+        kind: "property",
+        type: () => {
+          return System.UInt64;
+        },
+      },
+    },
+    isAbstract: true,
+  },
+  SafeHandle: {
+    kind: "class",
+    members: {
+      handle: {
+        kind: "field",
+        type: () => {
+          return System.IntPtr;
+        },
+      },
+      SafeHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Close: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      DangerousAddRef: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      DangerousGetHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      DangerousRelease: {
+        kind: "method",
+        methodKind: "ordinary",
       },
-      FromIntPtr: {
+      Dispose: {
         kind: "method",
         methodKind: "ordinary",
-        isStatic: true,
       },
-      GetHashCode: {
+      Finalize: {
         kind: "method",
         methodKind: "ordinary",
-        isOverride: true,
-        isReadOnly: true,
       },
-      ToIntPtr: {
+      ReleaseHandle: {
         kind: "method",
         methodKind: "ordinary",
-        isStatic: true,
+        isAbstract: true,
       },
-      IsAllocated: {
+      SetHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      SetHandleAsInvalid: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      IsClosed: {
         kind: "property",
         type: () => {
           return System.Boolean;
         },
-        isReadOnly: true,
       },
-      Target: {
+      IsInvalid: {
         kind: "property",
         type: () => {
-          return System.Object;
+          return System.Boolean;
+        },
+        isAbstract: true,
+      },
+    },
+    isAbstract: true,
+  },
+  SequenceMarshal: {
+    kind: "class",
+    members: {},
+    isStatic: true,
+  },
+  StandardOleMarshalObject: {
+    kind: "class",
+    members: {
+      StandardOleMarshalObject: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+  },
+  StringMarshalling: {
+    kind: "enum",
+    members: {
+      Custom: {
+        kind: "field",
+        type: () => {
+          return InteropServices.StringMarshalling;
+        },
+      },
+      Utf8: {
+        kind: "field",
+        type: () => {
+          return InteropServices.StringMarshalling;
+        },
+      },
+      Utf16: {
+        kind: "field",
+        type: () => {
+          return InteropServices.StringMarshalling;
+        },
+      },
+    },
+  },
+  StructLayoutAttribute: {
+    kind: "class",
+    members: {
+      CharSet: {
+        kind: "field",
+        type: () => {
+          return InteropServices.CharSet;
+        },
+      },
+      Pack: {
+        kind: "field",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      Size: {
+        kind: "field",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      StructLayoutAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return InteropServices.LayoutKind;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  SuppressGCTransitionAttribute: {
+    kind: "class",
+    members: {
+      SuppressGCTransitionAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  TypeIdentifierAttribute: {
+    kind: "class",
+    members: {
+      TypeIdentifierAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Identifier: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+        isNullable: true,
+      },
+      Scope: {
+        kind: "property",
+        type: () => {
+          return System.String;
         },
         isNullable: true,
-        isReadOnly: true,
       },
     },
+    isSealed: true,
   },
-  GCHandleType: {
+  TypeLibFuncAttribute: {
+    kind: "class",
+    members: {
+      TypeLibFuncAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  TypeLibFuncFlags: {
     kind: "enum",
     members: {
-      Weak: {
+      FRestricted: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FSource: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FBindable: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FRequestEdit: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FDisplayBind: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FDefaultBind: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FHidden: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FUsesGetLastError: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FDefaultCollelem: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FUiDefault: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FNonBrowsable: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FReplaceable: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+      FImmediateBind: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibFuncFlags;
+        },
+      },
+    },
+  },
+  TypeLibImportClassAttribute: {
+    kind: "class",
+    members: {
+      TypeLibImportClassAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  TypeLibTypeAttribute: {
+    kind: "class",
+    members: {
+      TypeLibTypeAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  TypeLibTypeFlags: {
+    kind: "enum",
+    members: {
+      FAppObject: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FCanCreate: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FLicensed: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FPreDeclId: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FHidden: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FControl: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FDual: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FNonExtensible: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FOleAutomation: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FRestricted: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibTypeFlags;
+        },
+      },
+      FAggregatable: {
         kind: "field",
         type: () => {
-          return InteropServices.GCHandleType;
+          return InteropServices.TypeLibTypeFlags;
         },
       },
-      WeakTrackResurrection: {
+      FReplaceable: {
         kind: "field",
         type: () => {
-          return InteropServices.GCHandleType;
+          return InteropServices.TypeLibTypeFlags;
         },
       },
-      Normal: {
+      FDispatchable: {
         kind: "field",
         type: () => {
-          return InteropServices.GCHandleType;
+          return InteropServices.TypeLibTypeFlags;
         },
       },
-      Pinned: {
+      FReverseBind: {
         kind: "field",
         type: () => {
-          return InteropServices.GCHandleType;
+          return InteropServices.TypeLibTypeFlags;
         },
       },
     },
   },
-  InAttribute: {
+  TypeLibVarAttribute: {
     kind: "class",
     members: {
-      InAttribute: {
+      TypeLibVarAttribute: {
         kind: "method",
         methodKind: "constructor",
       },
+      Value: {
+        kind: "property",
+        type: () => {
+          return InteropServices.TypeLibVarFlags;
+        },
+      },
     },
     isSealed: true,
   },
-  LayoutKind: {
+  TypeLibVarFlags: {
     kind: "enum",
     members: {
-      Sequential: {
+      FReadOnly: {
         kind: "field",
         type: () => {
-          return InteropServices.LayoutKind;
+          return InteropServices.TypeLibVarFlags;
         },
       },
-      Explicit: {
+      FSource: {
         kind: "field",
         type: () => {
-          return InteropServices.LayoutKind;
+          return InteropServices.TypeLibVarFlags;
         },
       },
-      Auto: {
+      FBindable: {
         kind: "field",
         type: () => {
-          return InteropServices.LayoutKind;
+          return InteropServices.TypeLibVarFlags;
         },
       },
-    },
-  },
-  MemoryMarshal: {
-    kind: "class",
-    members: {
-      CreateReadOnlySpanFromNullTerminated: {
-        kind: "method",
-        methodKind: "ordinary",
-        isStatic: true,
-      },
-      GetArrayDataReference: {
-        kind: "method",
-        methodKind: "ordinary",
-        isStatic: true,
-      },
-      TryGetString: {
-        kind: "method",
-        methodKind: "ordinary",
-        isStatic: true,
-      },
-    },
-    isStatic: true,
-  },
-  OSPlatform: {
-    kind: "struct",
-    members: {
-      Create: {
-        kind: "method",
-        methodKind: "ordinary",
-        isStatic: true,
-      },
-      Equals: {
-        kind: "method",
-        methodKind: "ordinary",
-        isOverride: true,
-      },
-      GetHashCode: {
-        kind: "method",
-        methodKind: "ordinary",
-        isOverride: true,
-      },
-      ToString: {
-        kind: "method",
-        methodKind: "ordinary",
-        isOverride: true,
-      },
-      FreeBSD: {
-        kind: "property",
+      FRequestEdit: {
+        kind: "field",
         type: () => {
-          return InteropServices.OSPlatform;
+          return InteropServices.TypeLibVarFlags;
         },
-        isStatic: true,
       },
-      Linux: {
-        kind: "property",
+      FDisplayBind: {
+        kind: "field",
         type: () => {
-          return InteropServices.OSPlatform;
+          return InteropServices.TypeLibVarFlags;
         },
-        isStatic: true,
       },
-      OSX: {
-        kind: "property",
+      FDefaultBind: {
+        kind: "field",
         type: () => {
-          return InteropServices.OSPlatform;
+          return InteropServices.TypeLibVarFlags;
         },
-        isStatic: true,
       },
-      Windows: {
-        kind: "property",
+      FHidden: {
+        kind: "field",
         type: () => {
-          return InteropServices.OSPlatform;
+          return InteropServices.TypeLibVarFlags;
         },
-        isStatic: true,
-      },
-    },
-  },
-  OutAttribute: {
-    kind: "class",
-    members: {
-      OutAttribute: {
-        kind: "method",
-        methodKind: "constructor",
       },
-    },
-    isSealed: true,
-  },
-  RuntimeInformation: {
-    kind: "class",
-    members: {
-      IsOSPlatform: {
-        kind: "method",
-        methodKind: "ordinary",
-        isStatic: true,
+      FRestricted: {
+        kind: "field",
+        type: () => {
+          return InteropServices.TypeLibVarFlags;
+        },
       },
-      FrameworkDescription: {
-        kind: "property",
+      FDefaultCollelem: {
+        kind: "field",
         type: () => {
-          return System.String;
+          return InteropServices.TypeLibVarFlags;
         },
-        isStatic: true,
       },
-      OSArchitecture: {
-        kind: "property",
+      FUiDefault: {
+        kind: "field",
         type: () => {
-          return InteropServices.Architecture;
+          return InteropServices.TypeLibVarFlags;
         },
-        isStatic: true,
       },
-      OSDescription: {
-        kind: "property",
+      FNonBrowsable: {
+        kind: "field",
         type: () => {
-          return System.String;
+          return InteropServices.TypeLibVarFlags;
         },
-        isStatic: true,
       },
-      ProcessArchitecture: {
-        kind: "property",
+      FReplaceable: {
+        kind: "field",
         type: () => {
-          return InteropServices.Architecture;
+          return InteropServices.TypeLibVarFlags;
         },
-        isStatic: true,
       },
-      RuntimeIdentifier: {
-        kind: "property",
+      FImmediateBind: {
+        kind: "field",
         type: () => {
-          return System.String;
+          return InteropServices.TypeLibVarFlags;
         },
-        isStatic: true,
       },
     },
-    isStatic: true,
   },
-  SafeBuffer: {
+  TypeLibVersionAttribute: {
     kind: "class",
     members: {
-      SafeBuffer: {
+      TypeLibVersionAttribute: {
         kind: "method",
         methodKind: "constructor",
       },
-      AcquirePointer: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      Initialize: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      ReleasePointer: {
-        kind: "method",
-        methodKind: "ordinary",
+      MajorVersion: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
       },
-      ByteLength: {
+      MinorVersion: {
         kind: "property",
         type: () => {
-          return System.UInt64;
+          return System.Int32;
         },
       },
     },
-    isAbstract: true,
+    isSealed: true,
   },
-  SafeHandle: {
+  UnmanagedCallConvAttribute: {
     kind: "class",
     members: {
-      handle: {
+      CallConvs: {
         kind: "field",
         type: () => {
-          return System.IntPtr;
+          return System.Array;
         },
+        isNullable: true,
       },
-      SafeHandle: {
+      UnmanagedCallConvAttribute: {
         kind: "method",
         methodKind: "constructor",
       },
-      Close: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      DangerousAddRef: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      DangerousGetHandle: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      DangerousRelease: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      Dispose: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      Finalize: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      ReleaseHandle: {
-        kind: "method",
-        methodKind: "ordinary",
-        isAbstract: true,
-      },
-      SetHandle: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      SetHandleAsInvalid: {
-        kind: "method",
-        methodKind: "ordinary",
-      },
-      IsClosed: {
-        kind: "property",
+    },
+    isSealed: true,
+  },
+  UnmanagedCallersOnlyAttribute: {
+    kind: "class",
+    members: {
+      CallConvs: {
+        kind: "field",
         type: () => {
-          return System.Boolean;
+          return System.Array;
         },
+        isNullable: true,
       },
-      IsInvalid: {
-        kind: "property",
+      EntryPoint: {
+        kind: "field",
         type: () => {
-          return System.Boolean;
+          return System.String;
         },
-        isAbstract: true,
+        isNullable: true,
+      },
+      UnmanagedCallersOnlyAttribute: {
+        kind: "method",
+        methodKind: "constructor",
       },
     },
-    isAbstract: true,
+    isSealed: true,
   },
-  StructLayoutAttribute: {
+  UnmanagedFunctionPointerAttribute: {
     kind: "class",
     members: {
+      BestFitMapping: {
+        kind: "field",
+        type: () => {
+          return System.Boolean;
+        },
+      },
       CharSet: {
         kind: "field",
         type: () => {
           return InteropServices.CharSet;
         },
       },
-      Pack: {
+      SetLastError: {
         kind: "field",
         type: () => {
-          return System.Int32;
+          return System.Boolean;
         },
       },
-      Size: {
+      ThrowOnUnmappableChar: {
         kind: "field",
         type: () => {
-          return System.Int32;
+          return System.Boolean;
         },
       },
-      StructLayoutAttribute: {
+      UnmanagedFunctionPointerAttribute: {
         kind: "method",
         methodKind: "constructor",
       },
-      Value: {
+      CallingConvention: {
         kind: "property",
         type: () => {
-          return InteropServices.LayoutKind;
+          return InteropServices.CallingConvention;
         },
       },
     },
     isSealed: true,
   },
-  SuppressGCTransitionAttribute: {
-    kind: "class",
-    members: {
-      SuppressGCTransitionAttribute: {
-        kind: "method",
-        methodKind: "constructor",
-      },
-    },
-    isSealed: true,
-  },
   UnmanagedType: {
     kind: "enum",
     members: {
@@ -930,5 +4391,15 @@ const InteropServices: InteropServicesLibrary = createLibrary("System.Runtime.In
       },
     },
   },
+  WasmImportLinkageAttribute: {
+    kind: "class",
+    members: {
+      WasmImportLinkageAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
 });
 export default InteropServices