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

package/src/builtins/System/Runtime/Serialization/DataContracts/index.ts

@@ -0,0 +1,314 @@
+import Generic from "../../../Collections/Generic/index.js";
+import Collections from "../../../Collections/index.js";
+import ObjectModel from "../../../Collections/ObjectModel/index.js";
+import System from "../../../index.js";
+import Xml from "../../../Xml/index.js";
+import Schema from "../../../Xml/Schema/index.js";
+
+import { createLibrary } from "#createLibrary";
+import { LibrarySymbolReference } from "@alloy-js/core";
+
+type DataContractsLibrary = LibrarySymbolReference & {
+  DataContract: LibrarySymbolReference & {
+    GetBuiltInDataContract: LibrarySymbolReference;
+    GetXmlName: LibrarySymbolReference;
+    GetArrayTypeName: LibrarySymbolReference;
+    IsDictionaryLike: LibrarySymbolReference;
+    BaseContract: LibrarySymbolReference;
+    ContractType: LibrarySymbolReference;
+    IsBuiltInDataContract: LibrarySymbolReference;
+    IsISerializable: LibrarySymbolReference;
+    IsReference: LibrarySymbolReference;
+    IsValueType: LibrarySymbolReference;
+    KnownDataContracts: LibrarySymbolReference;
+    DataMembers: LibrarySymbolReference;
+    OriginalUnderlyingType: LibrarySymbolReference;
+    XmlName: LibrarySymbolReference;
+    UnderlyingType: LibrarySymbolReference;
+    TopLevelElementName: LibrarySymbolReference;
+    TopLevelElementNamespace: LibrarySymbolReference
+  };
+  DataContractSet: LibrarySymbolReference & {
+    DataContractSet: LibrarySymbolReference;
+    GetDataContract: LibrarySymbolReference;
+    GetReferencedType: LibrarySymbolReference;
+    ImportSchemaSet: LibrarySymbolReference;
+    Contracts: LibrarySymbolReference;
+    KnownTypesForObject: LibrarySymbolReference;
+    ProcessedContracts: LibrarySymbolReference;
+    SurrogateData: LibrarySymbolReference
+  };
+  DataMember: LibrarySymbolReference & {
+    EmitDefaultValue: LibrarySymbolReference;
+    IsNullable: LibrarySymbolReference;
+    IsRequired: LibrarySymbolReference;
+    MemberTypeContract: LibrarySymbolReference;
+    Name: LibrarySymbolReference;
+    Order: LibrarySymbolReference
+  };
+  XmlDataContract: LibrarySymbolReference & {
+    HasRoot: LibrarySymbolReference;
+    IsAnonymous: LibrarySymbolReference;
+    IsTopLevelElementNullable: LibrarySymbolReference;
+    IsTypeDefinedOnImport: LibrarySymbolReference;
+    IsValueType: LibrarySymbolReference;
+    XsdType: LibrarySymbolReference
+  }
+};
+const DataContracts: DataContractsLibrary = createLibrary("System.Runtime.Serialization.DataContracts", {
+  DataContract: {
+    kind: "class",
+    members: {
+      GetBuiltInDataContract: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetXmlName: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      GetArrayTypeName: {
+        kind: "method",
+        methodKind: "ordinary",
+        isVirtual: true,
+      },
+      IsDictionaryLike: {
+        kind: "method",
+        methodKind: "ordinary",
+        isVirtual: true,
+      },
+      BaseContract: {
+        kind: "property",
+        type: () => {
+          return DataContracts.DataContract;
+        },
+        isNullable: true,
+        isVirtual: true,
+      },
+      ContractType: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+        isNullable: true,
+        isVirtual: true,
+      },
+      IsBuiltInDataContract: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isVirtual: true,
+      },
+      IsISerializable: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isVirtual: true,
+      },
+      IsReference: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isVirtual: true,
+      },
+      IsValueType: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isVirtual: true,
+      },
+      KnownDataContracts: {
+        kind: "property",
+        type: () => {
+          return Generic.Dictionary;
+        },
+        isNullable: true,
+        isVirtual: true,
+      },
+      DataMembers: {
+        kind: "property",
+        type: () => {
+          return ObjectModel.ReadOnlyCollection;
+        },
+        isVirtual: true,
+      },
+      OriginalUnderlyingType: {
+        kind: "property",
+        type: () => {
+          return System.Type;
+        },
+        isVirtual: true,
+      },
+      XmlName: {
+        kind: "property",
+        type: () => {
+          return Xml.XmlQualifiedName;
+        },
+        isVirtual: true,
+      },
+      UnderlyingType: {
+        kind: "property",
+        type: () => {
+          return System.Type;
+        },
+        isVirtual: true,
+      },
+      TopLevelElementName: {
+        kind: "property",
+        type: () => {
+          return Xml.XmlDictionaryString;
+        },
+        isNullable: true,
+        isVirtual: true,
+      },
+      TopLevelElementNamespace: {
+        kind: "property",
+        type: () => {
+          return Xml.XmlDictionaryString;
+        },
+        isNullable: true,
+        isVirtual: true,
+      },
+    },
+    isAbstract: true,
+  },
+  DataContractSet: {
+    kind: "class",
+    members: {
+      DataContractSet: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      GetDataContract: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetReferencedType: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      ImportSchemaSet: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Contracts: {
+        kind: "property",
+        type: () => {
+          return Generic.Dictionary;
+        },
+      },
+      KnownTypesForObject: {
+        kind: "property",
+        type: () => {
+          return Generic.Dictionary;
+        },
+        isNullable: true,
+      },
+      ProcessedContracts: {
+        kind: "property",
+        type: () => {
+          return Generic.Dictionary;
+        },
+      },
+      SurrogateData: {
+        kind: "property",
+        type: () => {
+          return Collections.Hashtable;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  DataMember: {
+    kind: "class",
+    members: {
+      EmitDefaultValue: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      IsNullable: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      IsRequired: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      MemberTypeContract: {
+        kind: "property",
+        type: () => {
+          return DataContracts.DataContract;
+        },
+      },
+      Name: {
+        kind: "property",
+        type: () => {
+          return System.String;
+        },
+      },
+      Order: {
+        kind: "property",
+        type: () => {
+          return System.Int64;
+        },
+      },
+    },
+    isSealed: true,
+  },
+  XmlDataContract: {
+    kind: "class",
+    members: {
+      HasRoot: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      IsAnonymous: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      IsTopLevelElementNullable: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      IsTypeDefinedOnImport: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      IsValueType: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      XsdType: {
+        kind: "property",
+        type: () => {
+          return Schema.XmlSchemaType;
+        },
+        isNullable: true,
+      },
+    },
+    isSealed: true,
+  },
+});
+export default DataContracts

package/src/builtins/System/Runtime/Serialization/Formatters/Binary/index.ts

@@ -0,0 +1,76 @@
+import Formatters from "../index.js";
+import Serialization from "../../index.js";
+
+import { createLibrary } from "#createLibrary";
+import { LibrarySymbolReference } from "@alloy-js/core";
+
+type BinaryLibrary = LibrarySymbolReference & {
+  BinaryFormatter: LibrarySymbolReference & {
+    BinaryFormatter: LibrarySymbolReference;
+    Deserialize: LibrarySymbolReference;
+    Serialize: LibrarySymbolReference;
+    AssemblyFormat: LibrarySymbolReference;
+    Binder: LibrarySymbolReference;
+    Context: LibrarySymbolReference;
+    FilterLevel: LibrarySymbolReference;
+    SurrogateSelector: LibrarySymbolReference;
+    TypeFormat: LibrarySymbolReference
+  }
+};
+const Binary: BinaryLibrary = createLibrary("System.Runtime.Serialization.Formatters.Binary", {
+  BinaryFormatter: {
+    kind: "class",
+    members: {
+      BinaryFormatter: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Deserialize: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Serialize: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      AssemblyFormat: {
+        kind: "property",
+        type: () => {
+          return Formatters.FormatterAssemblyStyle;
+        },
+      },
+      Binder: {
+        kind: "property",
+        type: () => {
+          return Serialization.SerializationBinder;
+        },
+      },
+      Context: {
+        kind: "property",
+        type: () => {
+          return Serialization.StreamingContext;
+        },
+      },
+      FilterLevel: {
+        kind: "property",
+        type: () => {
+          return Formatters.TypeFilterLevel;
+        },
+      },
+      SurrogateSelector: {
+        kind: "property",
+        type: () => {
+          return Serialization.ISurrogateSelector;
+        },
+      },
+      TypeFormat: {
+        kind: "property",
+        type: () => {
+          return Formatters.FormatterTypeStyle;
+        },
+      },
+    },
+    isSealed: true,
+  },
+});
+export default Binary

package/src/builtins/System/Runtime/Serialization/Formatters/index.ts

@@ -0,0 +1,103 @@
+import System from "../../../index.js";
+
+import { createLibrary } from "#createLibrary";
+import { LibrarySymbolReference } from "@alloy-js/core";export { default as Binary } from "./Binary/index.js";
+
+type FormattersLibrary = LibrarySymbolReference & {
+  FormatterAssemblyStyle: LibrarySymbolReference & {
+    Simple: LibrarySymbolReference;
+    Full: LibrarySymbolReference
+  };
+  FormatterTypeStyle: LibrarySymbolReference & {
+    TypesWhenNeeded: LibrarySymbolReference;
+    TypesAlways: LibrarySymbolReference;
+    XsdString: LibrarySymbolReference
+  };
+  IFieldInfo: LibrarySymbolReference & {
+    FieldNames: LibrarySymbolReference;
+    FieldTypes: LibrarySymbolReference
+  };
+  TypeFilterLevel: LibrarySymbolReference & {
+    Low: LibrarySymbolReference;
+    Full: LibrarySymbolReference
+  }
+};
+const Formatters: FormattersLibrary = createLibrary("System.Runtime.Serialization.Formatters", {
+  FormatterAssemblyStyle: {
+    kind: "enum",
+    members: {
+      Simple: {
+        kind: "field",
+        type: () => {
+          return Formatters.FormatterAssemblyStyle;
+        },
+      },
+      Full: {
+        kind: "field",
+        type: () => {
+          return Formatters.FormatterAssemblyStyle;
+        },
+      },
+    },
+  },
+  FormatterTypeStyle: {
+    kind: "enum",
+    members: {
+      TypesWhenNeeded: {
+        kind: "field",
+        type: () => {
+          return Formatters.FormatterTypeStyle;
+        },
+      },
+      TypesAlways: {
+        kind: "field",
+        type: () => {
+          return Formatters.FormatterTypeStyle;
+        },
+      },
+      XsdString: {
+        kind: "field",
+        type: () => {
+          return Formatters.FormatterTypeStyle;
+        },
+      },
+    },
+  },
+  IFieldInfo: {
+    kind: "interface",
+    members: {
+      FieldNames: {
+        kind: "property",
+        type: () => {
+          return System.Array;
+        },
+        isNullable: true,
+      },
+      FieldTypes: {
+        kind: "property",
+        type: () => {
+          return System.Array;
+        },
+        isNullable: true,
+      },
+    },
+  },
+  TypeFilterLevel: {
+    kind: "enum",
+    members: {
+      Low: {
+        kind: "field",
+        type: () => {
+          return Formatters.TypeFilterLevel;
+        },
+      },
+      Full: {
+        kind: "field",
+        type: () => {
+          return Formatters.TypeFilterLevel;
+        },
+      },
+    },
+  },
+});
+export default Formatters