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

package/src/builtins/System/Buffers/index.ts

@@ -1,9 +1,23 @@
 import System from "../index.js";
 
 import { createLibrary } from "#createLibrary";
-import { LibrarySymbolReference } from "@alloy-js/core";export { default as Text } from "./Text/index.js";
+import { LibrarySymbolReference } from "@alloy-js/core";export { default as Binary } from "./Binary/index.js";
+export { default as Text } from "./Text/index.js";
 
 type BuffersLibrary = LibrarySymbolReference & {
+  ArrayBufferWriter: LibrarySymbolReference & {
+    ArrayBufferWriter: LibrarySymbolReference;
+    Advance: LibrarySymbolReference;
+    Clear: LibrarySymbolReference;
+    ResetWrittenCount: LibrarySymbolReference;
+    GetMemory: LibrarySymbolReference;
+    GetSpan: LibrarySymbolReference;
+    Capacity: LibrarySymbolReference;
+    FreeCapacity: LibrarySymbolReference;
+    WrittenCount: LibrarySymbolReference;
+    WrittenMemory: LibrarySymbolReference;
+    WrittenSpan: LibrarySymbolReference
+  };
   ArrayPool: LibrarySymbolReference & {
     ArrayPool: LibrarySymbolReference;
     Create: LibrarySymbolReference;
@@ -11,6 +25,14 @@ type BuffersLibrary = LibrarySymbolReference & {
     Return: LibrarySymbolReference;
     Shared: LibrarySymbolReference
   };
+  BuffersExtensions: LibrarySymbolReference & {
+
+  };
+  IBufferWriter: LibrarySymbolReference & {
+    Advance: LibrarySymbolReference;
+    GetMemory: LibrarySymbolReference;
+    GetSpan: LibrarySymbolReference
+  };
   IMemoryOwner: LibrarySymbolReference & {
     Memory: LibrarySymbolReference
   };
@@ -33,12 +55,32 @@ type BuffersLibrary = LibrarySymbolReference & {
     Unpin: LibrarySymbolReference;
     Memory: LibrarySymbolReference
   };
+  MemoryPool: LibrarySymbolReference & {
+    MemoryPool: LibrarySymbolReference;
+    Dispose: LibrarySymbolReference;
+    Rent: LibrarySymbolReference;
+    MaxBufferSize: LibrarySymbolReference;
+    Shared: LibrarySymbolReference
+  };
   OperationStatus: LibrarySymbolReference & {
     Done: LibrarySymbolReference;
     DestinationTooSmall: LibrarySymbolReference;
     NeedMoreData: LibrarySymbolReference;
     InvalidData: LibrarySymbolReference
   };
+  ReadOnlySequence: LibrarySymbolReference & {
+    Enumerator: LibrarySymbolReference & {
+      Enumerator: LibrarySymbolReference;
+      MoveNext: LibrarySymbolReference;
+      Current: LibrarySymbolReference
+    }
+  };
+  ReadOnlySequenceSegment: LibrarySymbolReference & {
+    ReadOnlySequenceSegment: LibrarySymbolReference;
+    Memory: LibrarySymbolReference;
+    Next: LibrarySymbolReference;
+    RunningIndex: LibrarySymbolReference
+  };
   ReadOnlySpanAction: LibrarySymbolReference & {
     ReadOnlySpanAction: LibrarySymbolReference;
     Invoke: LibrarySymbolReference;
@@ -48,14 +90,119 @@ type BuffersLibrary = LibrarySymbolReference & {
   SearchValues: LibrarySymbolReference & {
     Contains: LibrarySymbolReference
   };
+  SequenceReader: LibrarySymbolReference & {
+    SequenceReader: LibrarySymbolReference;
+    Advance: LibrarySymbolReference;
+    AdvancePast: LibrarySymbolReference;
+    AdvancePastAny: LibrarySymbolReference;
+    AdvanceToEnd: LibrarySymbolReference;
+    IsNext: LibrarySymbolReference;
+    Rewind: LibrarySymbolReference;
+    TryAdvanceTo: LibrarySymbolReference;
+    TryAdvanceToAny: LibrarySymbolReference;
+    TryCopyTo: LibrarySymbolReference;
+    TryPeek: LibrarySymbolReference;
+    TryRead: LibrarySymbolReference;
+    TryReadTo: LibrarySymbolReference;
+    TryReadToAny: LibrarySymbolReference;
+    TryReadExact: LibrarySymbolReference;
+    Consumed: LibrarySymbolReference;
+    CurrentSpan: LibrarySymbolReference;
+    CurrentSpanIndex: LibrarySymbolReference;
+    End: LibrarySymbolReference;
+    Length: LibrarySymbolReference;
+    Position: LibrarySymbolReference;
+    Remaining: LibrarySymbolReference;
+    Sequence: LibrarySymbolReference;
+    UnreadSequence: LibrarySymbolReference;
+    UnreadSpan: LibrarySymbolReference
+  };
+  SequenceReaderExtensions: LibrarySymbolReference & {
+    TryReadBigEndian: LibrarySymbolReference;
+    TryReadLittleEndian: LibrarySymbolReference
+  };
   SpanAction: LibrarySymbolReference & {
     SpanAction: LibrarySymbolReference;
     Invoke: LibrarySymbolReference;
     BeginInvoke: LibrarySymbolReference;
     EndInvoke: LibrarySymbolReference
+  };
+  StandardFormat: LibrarySymbolReference & {
+    MaxPrecision: LibrarySymbolReference;
+    NoPrecision: LibrarySymbolReference;
+    StandardFormat: LibrarySymbolReference;
+    Equals: LibrarySymbolReference;
+    GetHashCode: LibrarySymbolReference;
+    Parse: LibrarySymbolReference;
+    ToString: LibrarySymbolReference;
+    TryParse: LibrarySymbolReference;
+    HasPrecision: LibrarySymbolReference;
+    IsDefault: LibrarySymbolReference;
+    Precision: LibrarySymbolReference;
+    Symbol: LibrarySymbolReference
   }
 };
 const Buffers: BuffersLibrary = createLibrary("System.Buffers", {
+  ArrayBufferWriter: {
+    kind: "class",
+    members: {
+      ArrayBufferWriter: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Advance: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Clear: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      ResetWrittenCount: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetMemory: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetSpan: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Capacity: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      FreeCapacity: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      WrittenCount: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+      },
+      WrittenMemory: {
+        kind: "property",
+        type: () => {
+          return System.ReadOnlyMemory;
+        },
+      },
+      WrittenSpan: {
+        kind: "property",
+        type: () => {
+          return System.ReadOnlySpan;
+        },
+      },
+    },
+    isSealed: true,
+  },
   ArrayPool: {
     kind: "class",
     members: {
@@ -88,6 +235,28 @@ const Buffers: BuffersLibrary = createLibrary("System.Buffers", {
     },
     isAbstract: true,
   },
+  BuffersExtensions: {
+    kind: "class",
+    members: {},
+    isStatic: true,
+  },
+  IBufferWriter: {
+    kind: "interface",
+    members: {
+      Advance: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetMemory: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetSpan: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+    },
+  },
   IMemoryOwner: {
     kind: "interface",
     members: {
@@ -177,6 +346,39 @@ const Buffers: BuffersLibrary = createLibrary("System.Buffers", {
     },
     isAbstract: true,
   },
+  MemoryPool: {
+    kind: "class",
+    members: {
+      MemoryPool: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Dispose: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Rent: {
+        kind: "method",
+        methodKind: "ordinary",
+        isAbstract: true,
+      },
+      MaxBufferSize: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+        isAbstract: true,
+      },
+      Shared: {
+        kind: "property",
+        type: () => {
+          return Buffers.MemoryPool;
+        },
+        isStatic: true,
+      },
+    },
+    isAbstract: true,
+  },
   OperationStatus: {
     kind: "enum",
     members: {
@@ -206,6 +408,59 @@ const Buffers: BuffersLibrary = createLibrary("System.Buffers", {
       },
     },
   },
+  ReadOnlySequence: {
+    kind: "class",
+    members: {
+      Enumerator: {
+        kind: "struct",
+        members: {
+          Enumerator: {
+            kind: "method",
+            methodKind: "constructor",
+          },
+          MoveNext: {
+            kind: "method",
+            methodKind: "ordinary",
+          },
+          Current: {
+            kind: "property",
+            type: () => {
+              return System.ReadOnlyMemory;
+            },
+          },
+        },
+      },
+    },
+  },
+  ReadOnlySequenceSegment: {
+    kind: "class",
+    members: {
+      ReadOnlySequenceSegment: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Memory: {
+        kind: "property",
+        type: () => {
+          return System.ReadOnlyMemory;
+        },
+      },
+      Next: {
+        kind: "property",
+        type: () => {
+          return Buffers.ReadOnlySequenceSegment;
+        },
+        isNullable: true,
+      },
+      RunningIndex: {
+        kind: "property",
+        type: () => {
+          return System.Int64;
+        },
+      },
+    },
+    isAbstract: true,
+  },
   ReadOnlySpanAction: {
     kind: "generic",
     members: {
@@ -239,6 +494,159 @@ const Buffers: BuffersLibrary = createLibrary("System.Buffers", {
       },
     },
   },
+  SequenceReader: {
+    kind: "struct",
+    members: {
+      SequenceReader: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Advance: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      AdvancePast: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      AdvancePastAny: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      AdvanceToEnd: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      IsNext: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Rewind: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      TryAdvanceTo: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      TryAdvanceToAny: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      TryCopyTo: {
+        kind: "method",
+        methodKind: "ordinary",
+        isReadOnly: true,
+      },
+      TryPeek: {
+        kind: "method",
+        methodKind: "ordinary",
+        isReadOnly: true,
+      },
+      TryRead: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      TryReadTo: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      TryReadToAny: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      TryReadExact: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      Consumed: {
+        kind: "property",
+        type: () => {
+          return System.Int64;
+        },
+        isReadOnly: true,
+      },
+      CurrentSpan: {
+        kind: "property",
+        type: () => {
+          return System.ReadOnlySpan;
+        },
+        isReadOnly: true,
+      },
+      CurrentSpanIndex: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+        isReadOnly: true,
+      },
+      End: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+        isReadOnly: true,
+      },
+      Length: {
+        kind: "property",
+        type: () => {
+          return System.Int64;
+        },
+        isReadOnly: true,
+      },
+      Position: {
+        kind: "property",
+        type: () => {
+          return System.SequencePosition;
+        },
+        isReadOnly: true,
+      },
+      Remaining: {
+        kind: "property",
+        type: () => {
+          return System.Int64;
+        },
+        isReadOnly: true,
+      },
+      Sequence: {
+        kind: "property",
+        type: () => {
+          return Buffers.ReadOnlySequence;
+        },
+        isReadOnly: true,
+      },
+      UnreadSequence: {
+        kind: "property",
+        type: () => {
+          return Buffers.ReadOnlySequence;
+        },
+        isReadOnly: true,
+      },
+      UnreadSpan: {
+        kind: "property",
+        type: () => {
+          return System.ReadOnlySpan;
+        },
+        isReadOnly: true,
+      },
+    },
+  },
+  SequenceReaderExtensions: {
+    kind: "class",
+    members: {
+      TryReadBigEndian: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      TryReadLittleEndian: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+    },
+    isStatic: true,
+  },
   SpanAction: {
     kind: "generic",
     members: {
@@ -263,5 +671,74 @@ const Buffers: BuffersLibrary = createLibrary("System.Buffers", {
       },
     },
   },
+  StandardFormat: {
+    kind: "struct",
+    members: {
+      MaxPrecision: {
+        kind: "field",
+        type: () => {
+          return System.Byte;
+        },
+      },
+      NoPrecision: {
+        kind: "field",
+        type: () => {
+          return System.Byte;
+        },
+      },
+      StandardFormat: {
+        kind: "method",
+        methodKind: "constructor",
+      },
+      Equals: {
+        kind: "method",
+        methodKind: "ordinary",
+      },
+      GetHashCode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      Parse: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      ToString: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true,
+      },
+      TryParse: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true,
+      },
+      HasPrecision: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      IsDefault: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        },
+      },
+      Precision: {
+        kind: "property",
+        type: () => {
+          return System.Byte;
+        },
+      },
+      Symbol: {
+        kind: "property",
+        type: () => {
+          return System.Char;
+        },
+      },
+    },
+  },
 });
 export default Buffers