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

package/src/builtins/Microsoft/Win32/SafeHandles/index.ts

@@ -12,6 +12,12 @@ type SafeHandlesLibrary = LibrarySymbolReference & {
     CriticalHandleZeroOrMinusOneIsInvalid: LibrarySymbolReference;
     IsInvalid: LibrarySymbolReference
   };
+  SafeAccessTokenHandle: LibrarySymbolReference & {
+    SafeAccessTokenHandle: LibrarySymbolReference;
+    ReleaseHandle: LibrarySymbolReference;
+    InvalidHandle: LibrarySymbolReference;
+    IsInvalid: LibrarySymbolReference
+  };
   SafeFileHandle: LibrarySymbolReference & {
     SafeFileHandle: LibrarySymbolReference;
     ReleaseHandle: LibrarySymbolReference;
@@ -26,9 +32,53 @@ type SafeHandlesLibrary = LibrarySymbolReference & {
     SafeHandleZeroOrMinusOneIsInvalid: LibrarySymbolReference;
     IsInvalid: LibrarySymbolReference
   };
+  SafeMemoryMappedFileHandle: LibrarySymbolReference & {
+    SafeMemoryMappedFileHandle: LibrarySymbolReference;
+    ReleaseHandle: LibrarySymbolReference;
+    IsInvalid: LibrarySymbolReference
+  };
+  SafeMemoryMappedViewHandle: LibrarySymbolReference & {
+    SafeMemoryMappedViewHandle: LibrarySymbolReference;
+    ReleaseHandle: LibrarySymbolReference
+  };
+  SafeNCryptHandle: LibrarySymbolReference & {
+    SafeNCryptHandle: LibrarySymbolReference;
+    ReleaseHandle: LibrarySymbolReference;
+    ReleaseNativeHandle: LibrarySymbolReference
+  };
+  SafeNCryptKeyHandle: LibrarySymbolReference & {
+    SafeNCryptKeyHandle: LibrarySymbolReference;
+    ReleaseNativeHandle: LibrarySymbolReference
+  };
+  SafeNCryptProviderHandle: LibrarySymbolReference & {
+    SafeNCryptProviderHandle: LibrarySymbolReference;
+    ReleaseNativeHandle: LibrarySymbolReference
+  };
+  SafeNCryptSecretHandle: LibrarySymbolReference & {
+    SafeNCryptSecretHandle: LibrarySymbolReference;
+    ReleaseNativeHandle: LibrarySymbolReference
+  };
+  SafePipeHandle: LibrarySymbolReference & {
+    SafePipeHandle: LibrarySymbolReference;
+    ReleaseHandle: LibrarySymbolReference;
+    IsInvalid: LibrarySymbolReference
+  };
+  SafeProcessHandle: LibrarySymbolReference & {
+    SafeProcessHandle: LibrarySymbolReference;
+    ReleaseHandle: LibrarySymbolReference
+  };
+  SafeRegistryHandle: LibrarySymbolReference & {
+    SafeRegistryHandle: LibrarySymbolReference;
+    ReleaseHandle: LibrarySymbolReference
+  };
   SafeWaitHandle: LibrarySymbolReference & {
     SafeWaitHandle: LibrarySymbolReference;
     ReleaseHandle: LibrarySymbolReference
+  };
+  SafeX509ChainHandle: LibrarySymbolReference & {
+    SafeX509ChainHandle: LibrarySymbolReference;
+    Dispose: LibrarySymbolReference;
+    ReleaseHandle: LibrarySymbolReference
   }
 };
 const SafeHandles: SafeHandlesLibrary = createLibrary("Microsoft.Win32.SafeHandles", {
@@ -66,6 +116,35 @@ const SafeHandles: SafeHandlesLibrary = createLibrary("Microsoft.Win32.SafeHandl
     },
     isAbstract: true,
   },
+  SafeAccessTokenHandle: {
+    kind: "class",
+    members: {
+      SafeAccessTokenHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      InvalidHandle: {
+        kind: "property",
+        type: () => {
+          return SafeHandles.SafeAccessTokenHandle;
+        },
+        isStatic: true,
+      },
+      IsInvalid: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
   SafeFileHandle: {
     kind: "class",
     members: {
@@ -128,6 +207,160 @@ const SafeHandles: SafeHandlesLibrary = createLibrary("Microsoft.Win32.SafeHandl
     },
     isAbstract: true,
   },
+  SafeMemoryMappedFileHandle: {
+    kind: "class",
+    members: {
+      SafeMemoryMappedFileHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      IsInvalid: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
+  SafeMemoryMappedViewHandle: {
+    kind: "class",
+    members: {
+      SafeMemoryMappedViewHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
+  SafeNCryptHandle: {
+    kind: "class",
+    members: {
+      SafeNCryptHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      ReleaseNativeHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isAbstract: true,
+      },
+    },
+    isAbstract: true,
+  },
+  SafeNCryptKeyHandle: {
+    kind: "class",
+    members: {
+      SafeNCryptKeyHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseNativeHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
+  SafeNCryptProviderHandle: {
+    kind: "class",
+    members: {
+      SafeNCryptProviderHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseNativeHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
+  SafeNCryptSecretHandle: {
+    kind: "class",
+    members: {
+      SafeNCryptSecretHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseNativeHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
+  SafePipeHandle: {
+    kind: "class",
+    members: {
+      SafePipeHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      IsInvalid: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
+  SafeProcessHandle: {
+    kind: "class",
+    members: {
+      SafeProcessHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
+  SafeRegistryHandle: {
+    kind: "class",
+    members: {
+      SafeRegistryHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      ReleaseHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
   SafeWaitHandle: {
     kind: "class",
     members: {
@@ -143,5 +376,25 @@ const SafeHandles: SafeHandlesLibrary = createLibrary("Microsoft.Win32.SafeHandl
     },
     isSealed: true,
   },
+  SafeX509ChainHandle: {
+    kind: "class",
+    members: {
+      SafeX509ChainHandle: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Dispose: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      ReleaseHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+    },
+    isSealed: true,
+  },
 });
 export default SafeHandles

package/src/builtins/Microsoft/Win32/index.ts

@@ -1,8 +1,437 @@
+import SafeHandles from "./SafeHandles/index.js";
+import System from "../../System/index.js";
+
 import { createLibrary } from "#createLibrary";
 import { LibrarySymbolReference } from "@alloy-js/core";export { default as SafeHandles } from "./SafeHandles/index.js";
 
 type Win32Library = LibrarySymbolReference & {
-
+  Registry: LibrarySymbolReference & {
+    ClassesRoot: LibrarySymbolReference;
+    CurrentConfig: LibrarySymbolReference;
+    CurrentUser: LibrarySymbolReference;
+    LocalMachine: LibrarySymbolReference;
+    PerformanceData: LibrarySymbolReference;
+    Users: LibrarySymbolReference;
+    GetValue: LibrarySymbolReference;
+    SetValue: LibrarySymbolReference
+  };
+  RegistryHive: LibrarySymbolReference & {
+    ClassesRoot: LibrarySymbolReference;
+    CurrentUser: LibrarySymbolReference;
+    LocalMachine: LibrarySymbolReference;
+    Users: LibrarySymbolReference;
+    PerformanceData: LibrarySymbolReference;
+    CurrentConfig: LibrarySymbolReference
+  };
+  RegistryKey: LibrarySymbolReference & {
+    Close: LibrarySymbolReference;
+    CreateSubKey: LibrarySymbolReference;
+    DeleteSubKey: LibrarySymbolReference;
+    DeleteSubKeyTree: LibrarySymbolReference;
+    DeleteValue: LibrarySymbolReference;
+    Dispose: LibrarySymbolReference;
+    Flush: LibrarySymbolReference;
+    FromHandle: LibrarySymbolReference;
+    GetAccessControl: LibrarySymbolReference;
+    GetSubKeyNames: LibrarySymbolReference;
+    GetValue: LibrarySymbolReference;
+    GetValueKind: LibrarySymbolReference;
+    GetValueNames: LibrarySymbolReference;
+    OpenBaseKey: LibrarySymbolReference;
+    OpenRemoteBaseKey: LibrarySymbolReference;
+    OpenSubKey: LibrarySymbolReference;
+    SetAccessControl: LibrarySymbolReference;
+    SetValue: LibrarySymbolReference;
+    ToString: LibrarySymbolReference;
+    Handle: LibrarySymbolReference;
+    Name: LibrarySymbolReference;
+    SubKeyCount: LibrarySymbolReference;
+    ValueCount: LibrarySymbolReference;
+    View: LibrarySymbolReference
+  };
+  RegistryKeyPermissionCheck: LibrarySymbolReference & {
+    Default: LibrarySymbolReference;
+    ReadSubTree: LibrarySymbolReference;
+    ReadWriteSubTree: LibrarySymbolReference
+  };
+  RegistryOptions: LibrarySymbolReference & {
+    None: LibrarySymbolReference;
+    Volatile: LibrarySymbolReference
+  };
+  RegistryValueKind: LibrarySymbolReference & {
+    None: LibrarySymbolReference;
+    Unknown: LibrarySymbolReference;
+    String: LibrarySymbolReference;
+    ExpandString: LibrarySymbolReference;
+    Binary: LibrarySymbolReference;
+    DWord: LibrarySymbolReference;
+    MultiString: LibrarySymbolReference;
+    QWord: LibrarySymbolReference
+  };
+  RegistryValueOptions: LibrarySymbolReference & {
+    None: LibrarySymbolReference;
+    DoNotExpandEnvironmentNames: LibrarySymbolReference
+  };
+  RegistryView: LibrarySymbolReference & {
+    Default: LibrarySymbolReference;
+    Registry64: LibrarySymbolReference;
+    Registry32: LibrarySymbolReference
+  }
 };
-const Win32: Win32Library = createLibrary("Microsoft.Win32", {});
+const Win32: Win32Library = createLibrary("Microsoft.Win32", {
+  Registry: {
+    kind: "class",
+    members: {
+      ClassesRoot: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryKey;
+        },
+        isStatic: true,
+        isReadOnly: true,
+      },
+      CurrentConfig: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryKey;
+        },
+        isStatic: true,
+        isReadOnly: true,
+      },
+      CurrentUser: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryKey;
+        },
+        isStatic: true,
+        isReadOnly: true,
+      },
+      LocalMachine: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryKey;
+        },
+        isStatic: true,
+        isReadOnly: true,
+      },
+      PerformanceData: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryKey;
+        },
+        isStatic: true,
+        isReadOnly: true,
+      },
+      Users: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryKey;
+        },
+        isStatic: true,
+        isReadOnly: true,
+      },
+      GetValue: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SetValue: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+    },
+    isStatic: true,
+  },
+  RegistryHive: {
+    kind: "enum",
+    members: {
+      ClassesRoot: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryHive;
+        },
+      },
+      CurrentUser: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryHive;
+        },
+      },
+      LocalMachine: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryHive;
+        },
+      },
+      Users: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryHive;
+        },
+      },
+      PerformanceData: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryHive;
+        },
+      },
+      CurrentConfig: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryHive;
+        },
+      },
+    },
+  },
+  RegistryKey: {
+    kind: "class",
+    members: {
+      Close: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      CreateSubKey: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      DeleteSubKey: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      DeleteSubKeyTree: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      DeleteValue: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Dispose: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Flush: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      FromHandle: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetAccessControl: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetSubKeyNames: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetValue: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetValueKind: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetValueNames: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      OpenBaseKey: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      OpenRemoteBaseKey: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      OpenSubKey: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      SetAccessControl: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      SetValue: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      ToString: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      Handle: {
+        kind: "property",
+        type: () => {
+          return SafeHandles.SafeRegistryHandle;
+        },
+      },
+      Name: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+      SubKeyCount: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      ValueCount: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      View: {
+        kind: "property",
+        type: () => {
+          return Win32.RegistryView;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  RegistryKeyPermissionCheck: {
+    kind: "enum",
+    members: {
+      Default: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryKeyPermissionCheck;
+        },
+      },
+      ReadSubTree: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryKeyPermissionCheck;
+        },
+      },
+      ReadWriteSubTree: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryKeyPermissionCheck;
+        },
+      },
+    },
+  },
+  RegistryOptions: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryOptions;
+        },
+      },
+      Volatile: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryOptions;
+        },
+      },
+    },
+  },
+  RegistryValueKind: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueKind;
+        },
+      },
+      Unknown: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueKind;
+        },
+      },
+      String: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueKind;
+        },
+      },
+      ExpandString: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueKind;
+        },
+      },
+      Binary: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueKind;
+        },
+      },
+      DWord: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueKind;
+        },
+      },
+      MultiString: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueKind;
+        },
+      },
+      QWord: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueKind;
+        },
+      },
+    },
+  },
+  RegistryValueOptions: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueOptions;
+        },
+      },
+      DoNotExpandEnvironmentNames: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryValueOptions;
+        },
+      },
+    },
+  },
+  RegistryView: {
+    kind: "enum",
+    members: {
+      Default: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryView;
+        },
+      },
+      Registry64: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryView;
+        },
+      },
+      Registry32: {
+        kind: "field",
+        type: () => {
+          return Win32.RegistryView;
+        },
+      },
+    },
+  },
+});
 export default Win32