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

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

@@ -0,0 +1,129 @@
+import { createLibrary } from "#createLibrary";
+import { LibrarySymbolReference } from "@alloy-js/core";
+
+type ConstrainedExecutionLibrary = LibrarySymbolReference & {
+  Cer: LibrarySymbolReference & {
+    None: LibrarySymbolReference;
+    MayFail: LibrarySymbolReference;
+    Success: LibrarySymbolReference
+  };
+  Consistency: LibrarySymbolReference & {
+    MayCorruptProcess: LibrarySymbolReference;
+    MayCorruptAppDomain: LibrarySymbolReference;
+    MayCorruptInstance: LibrarySymbolReference;
+    WillNotCorruptState: LibrarySymbolReference
+  };
+  CriticalFinalizerObject: LibrarySymbolReference & {
+    CriticalFinalizerObject: LibrarySymbolReference;
+    Finalize: LibrarySymbolReference
+  };
+  PrePrepareMethodAttribute: LibrarySymbolReference & {
+    PrePrepareMethodAttribute: LibrarySymbolReference
+  };
+  ReliabilityContractAttribute: LibrarySymbolReference & {
+    ReliabilityContractAttribute: LibrarySymbolReference;
+    Cer: LibrarySymbolReference;
+    ConsistencyGuarantee: LibrarySymbolReference
+  }
+};
+const ConstrainedExecution: ConstrainedExecutionLibrary = createLibrary("System.Runtime.ConstrainedExecution", {
+  Cer: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return ConstrainedExecution.Cer;
+        },
+      },
+      MayFail: {
+        kind: "field",
+        type: () => {
+          return ConstrainedExecution.Cer;
+        },
+      },
+      Success: {
+        kind: "field",
+        type: () => {
+          return ConstrainedExecution.Cer;
+        },
+      },
+    },
+  },
+  Consistency: {
+    kind: "enum",
+    members: {
+      MayCorruptProcess: {
+        kind: "field",
+        type: () => {
+          return ConstrainedExecution.Consistency;
+        },
+      },
+      MayCorruptAppDomain: {
+        kind: "field",
+        type: () => {
+          return ConstrainedExecution.Consistency;
+        },
+      },
+      MayCorruptInstance: {
+        kind: "field",
+        type: () => {
+          return ConstrainedExecution.Consistency;
+        },
+      },
+      WillNotCorruptState: {
+        kind: "field",
+        type: () => {
+          return ConstrainedExecution.Consistency;
+        },
+      },
+    },
+  },
+  CriticalFinalizerObject: {
+    kind: "class",
+    members: {
+      CriticalFinalizerObject: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Finalize: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+    },
+    isAbstract: true,
+  },
+  PrePrepareMethodAttribute: {
+    kind: "class",
+    members: {
+      PrePrepareMethodAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  ReliabilityContractAttribute: {
+    kind: "class",
+    members: {
+      ReliabilityContractAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Cer: {
+        kind: "property",
+        type: () => {
+          return ConstrainedExecution.Cer;
+        },
+      },
+      ConsistencyGuarantee: {
+        kind: "property",
+        type: () => {
+          return ConstrainedExecution.Consistency;
+        },
+      },
+    },
+    isSealed: true,
+  },
+});
+export default ConstrainedExecution

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

@@ -0,0 +1,80 @@
+import System from "../../index.js";
+
+import { createLibrary } from "#createLibrary";
+import { LibrarySymbolReference } from "@alloy-js/core";
+
+type ExceptionServicesLibrary = LibrarySymbolReference & {
+  ExceptionDispatchInfo: LibrarySymbolReference & {
+    Capture: LibrarySymbolReference;
+    SetCurrentStackTrace: LibrarySymbolReference;
+    SetRemoteStackTrace: LibrarySymbolReference;
+    Throw: LibrarySymbolReference;
+    SourceException: LibrarySymbolReference
+  };
+  FirstChanceExceptionEventArgs: LibrarySymbolReference & {
+    FirstChanceExceptionEventArgs: LibrarySymbolReference;
+    Exception: LibrarySymbolReference
+  };
+  HandleProcessCorruptedStateExceptionsAttribute: LibrarySymbolReference & {
+    HandleProcessCorruptedStateExceptionsAttribute: LibrarySymbolReference
+  }
+};
+const ExceptionServices: ExceptionServicesLibrary = createLibrary("System.Runtime.ExceptionServices", {
+  ExceptionDispatchInfo: {
+    kind: "class",
+    members: {
+      Capture: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SetCurrentStackTrace: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      SetRemoteStackTrace: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      Throw: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      SourceException: {
+        kind: "property",
+        type: () => {
+          return System.Exception;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  FirstChanceExceptionEventArgs: {
+    kind: "class",
+    members: {
+      FirstChanceExceptionEventArgs: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Exception: {
+        kind: "property",
+        type: () => {
+          return System.Exception;
+        },
+      },
+    },
+  },
+  HandleProcessCorruptedStateExceptionsAttribute: {
+    kind: "class",
+    members: {
+      HandleProcessCorruptedStateExceptionsAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+});
+export default ExceptionServices

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

@@ -0,0 +1,394 @@
+import System from "../../../index.js";
+
+import { createLibrary } from "#createLibrary";
+import { LibrarySymbolReference } from "@alloy-js/core";
+
+type MarshallingLibrary = LibrarySymbolReference & {
+  ContiguousCollectionMarshallerAttribute: LibrarySymbolReference & {
+    ContiguousCollectionMarshallerAttribute: LibrarySymbolReference
+  };
+  CustomMarshallerAttribute: LibrarySymbolReference & {
+    GenericPlaceholder: LibrarySymbolReference & {
+
+    }
+  };
+  MarshalMode: LibrarySymbolReference & {
+    Default: LibrarySymbolReference;
+    ManagedToUnmanagedIn: LibrarySymbolReference;
+    ManagedToUnmanagedRef: LibrarySymbolReference;
+    ManagedToUnmanagedOut: LibrarySymbolReference;
+    UnmanagedToManagedIn: LibrarySymbolReference;
+    UnmanagedToManagedRef: LibrarySymbolReference;
+    UnmanagedToManagedOut: LibrarySymbolReference;
+    ElementIn: LibrarySymbolReference;
+    ElementRef: LibrarySymbolReference;
+    ElementOut: LibrarySymbolReference
+  };
+  NativeMarshallingAttribute: LibrarySymbolReference & {
+    NativeMarshallingAttribute: LibrarySymbolReference;
+    NativeType: LibrarySymbolReference
+  };
+  ReadOnlySpanMarshaller: LibrarySymbolReference & {
+    ManagedToUnmanagedIn: LibrarySymbolReference & {
+      Free: LibrarySymbolReference;
+      FromManaged: LibrarySymbolReference;
+      GetManagedValuesSource: LibrarySymbolReference;
+      GetPinnableReference: LibrarySymbolReference;
+      GetUnmanagedValuesDestination: LibrarySymbolReference;
+      ToUnmanaged: LibrarySymbolReference;
+      BufferSize: LibrarySymbolReference
+    };
+    ManagedToUnmanagedOut: LibrarySymbolReference & {
+      FromUnmanaged: LibrarySymbolReference;
+      ToManaged: LibrarySymbolReference;
+      GetUnmanagedValuesSource: LibrarySymbolReference;
+      GetManagedValuesDestination: LibrarySymbolReference;
+      Free: LibrarySymbolReference
+    };
+    UnmanagedToManagedOut: LibrarySymbolReference & {
+      AllocateContainerForUnmanagedElements: LibrarySymbolReference;
+      GetManagedValuesSource: LibrarySymbolReference;
+      GetUnmanagedValuesDestination: LibrarySymbolReference
+    }
+  };
+  SafeHandleMarshaller: LibrarySymbolReference & {
+    ManagedToUnmanagedIn: LibrarySymbolReference & {
+      Free: LibrarySymbolReference;
+      FromManaged: LibrarySymbolReference;
+      ToUnmanaged: LibrarySymbolReference
+    };
+    ManagedToUnmanagedOut: LibrarySymbolReference & {
+      ManagedToUnmanagedOut: LibrarySymbolReference;
+      Free: LibrarySymbolReference;
+      FromUnmanaged: LibrarySymbolReference;
+      ToManaged: LibrarySymbolReference
+    };
+    ManagedToUnmanagedRef: LibrarySymbolReference & {
+      ManagedToUnmanagedRef: LibrarySymbolReference;
+      Free: LibrarySymbolReference;
+      FromManaged: LibrarySymbolReference;
+      FromUnmanaged: LibrarySymbolReference;
+      OnInvoked: LibrarySymbolReference;
+      ToManagedFinally: LibrarySymbolReference;
+      ToUnmanaged: LibrarySymbolReference
+    }
+  };
+  SpanMarshaller: LibrarySymbolReference & {
+    ManagedToUnmanagedIn: LibrarySymbolReference & {
+      Free: LibrarySymbolReference;
+      FromManaged: LibrarySymbolReference;
+      GetManagedValuesSource: LibrarySymbolReference;
+      GetPinnableReference: LibrarySymbolReference;
+      GetUnmanagedValuesDestination: LibrarySymbolReference;
+      ToUnmanaged: LibrarySymbolReference;
+      BufferSize: LibrarySymbolReference
+    }
+  }
+};
+const Marshalling: MarshallingLibrary = createLibrary("System.Runtime.InteropServices.Marshalling", {
+  ContiguousCollectionMarshallerAttribute: {
+    kind: "class",
+    members: {
+      ContiguousCollectionMarshallerAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+    },
+    isSealed: true,
+  },
+  CustomMarshallerAttribute: {
+    kind: "class",
+    members: {
+      GenericPlaceholder: {
+        kind: "struct",
+        members: {},
+      },
+    },
+  },
+  MarshalMode: {
+    kind: "enum",
+    members: {
+      Default: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+      ManagedToUnmanagedIn: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+      ManagedToUnmanagedRef: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+      ManagedToUnmanagedOut: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+      UnmanagedToManagedIn: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+      UnmanagedToManagedRef: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+      UnmanagedToManagedOut: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+      ElementIn: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+      ElementRef: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+      ElementOut: {
+        kind: "field",
+        type: () => {
+          return Marshalling.MarshalMode;
+        },
+      },
+    },
+  },
+  NativeMarshallingAttribute: {
+    kind: "class",
+    members: {
+      NativeMarshallingAttribute: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      NativeType: {
+        kind: "property",
+        type: () => {
+          return System.Type;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  ReadOnlySpanMarshaller: {
+    kind: "class",
+    members: {
+      ManagedToUnmanagedIn: {
+        kind: "struct",
+        members: {
+          Free: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          FromManaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          GetManagedValuesSource: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          GetPinnableReference: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          GetUnmanagedValuesDestination: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          ToUnmanaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          BufferSize: {
+            kind: "property",
+            type: () => {
+              return System.Int32;
+            },
+            isStatic: true,
+          },
+        },
+      },
+      ManagedToUnmanagedOut: {
+        kind: "struct",
+        members: {
+          FromUnmanaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          ToManaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          GetUnmanagedValuesSource: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          GetManagedValuesDestination: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          Free: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+        },
+      },
+      UnmanagedToManagedOut: {
+        kind: "class",
+        members: {
+          AllocateContainerForUnmanagedElements: {
+            kind: "method",
+            methodKind: "ordinary",
+            isStatic: true,
+          },
+          GetManagedValuesSource: {
+            kind: "method",
+            methodKind: "ordinary",
+            isStatic: true,
+          },
+          GetUnmanagedValuesDestination: {
+            kind: "method",
+            methodKind: "ordinary",
+            isStatic: true,
+          },
+        },
+        isStatic: true,
+      },
+    },
+  },
+  SafeHandleMarshaller: {
+    kind: "class",
+    members: {
+      ManagedToUnmanagedIn: {
+        kind: "struct",
+        members: {
+          Free: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          FromManaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          ToUnmanaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+        },
+      },
+      ManagedToUnmanagedOut: {
+        kind: "struct",
+        members: {
+          ManagedToUnmanagedOut: {
+            kind: "method",
+            methodKind: "constructor",
+          },
+          Free: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          FromUnmanaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          ToManaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+        },
+      },
+      ManagedToUnmanagedRef: {
+        kind: "struct",
+        members: {
+          ManagedToUnmanagedRef: {
+            kind: "method",
+            methodKind: "constructor",
+          },
+          Free: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          FromManaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          FromUnmanaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          OnInvoked: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          ToManagedFinally: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          ToUnmanaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+        },
+      },
+    },
+  },
+  SpanMarshaller: {
+    kind: "class",
+    members: {
+      ManagedToUnmanagedIn: {
+        kind: "struct",
+        members: {
+          Free: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          FromManaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          GetManagedValuesSource: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          GetPinnableReference: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          GetUnmanagedValuesDestination: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          ToUnmanaged: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          BufferSize: {
+            kind: "property",
+            type: () => {
+              return System.Int32;
+            },
+            isStatic: true,
+          },
+        },
+      },
+    },
+  },
+});
+export default Marshalling

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

@@ -0,0 +1,65 @@
+import System from "../../../index.js";
+
+import { createLibrary } from "#createLibrary";
+import { LibrarySymbolReference } from "@alloy-js/core";
+
+type SwiftLibrary = LibrarySymbolReference & {
+  SwiftError: LibrarySymbolReference & {
+    SwiftError: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  SwiftIndirectResult: LibrarySymbolReference & {
+    SwiftIndirectResult: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  };
+  SwiftSelf: LibrarySymbolReference & {
+    SwiftSelf: LibrarySymbolReference;
+    Value: LibrarySymbolReference
+  }
+};
+const Swift: SwiftLibrary = createLibrary("System.Runtime.InteropServices.Swift", {
+  SwiftError: {
+    kind: "struct",
+    members: {
+      SwiftError: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.Void;
+        },
+      },
+    },
+  },
+  SwiftIndirectResult: {
+    kind: "struct",
+    members: {
+      SwiftIndirectResult: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: () => {
+          return System.Void;
+        },
+      },
+    },
+  },
+  SwiftSelf: {
+    kind: "struct",
+    members: {
+      SwiftSelf: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Value: {
+        kind: "property",
+        type: undefined,
+      },
+    },
+  },
+});
+export default Swift