@alloy-js/csharp 0.23.0-dev.1 → 0.23.0-dev.11

package/dist/dev/src/builtins/System/Threading/Tasks/index.js

@@ -0,0 +1,721 @@
+import System from "../../index.js";
+import Threading from "../index.js";
+import { createLibrary } from "#createLibrary";
+export { default as Dataflow } from "./Dataflow/index.js";
+export { default as Sources } from "./Sources/index.js";
+const Tasks = createLibrary("System.Threading.Tasks", {
+  ConcurrentExclusiveSchedulerPair: {
+    kind: "class",
+    members: {
+      ConcurrentExclusiveSchedulerPair: {
+        kind: "method",
+        methodKind: "constructor"
+      },
+      Complete: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      Completion: {
+        kind: "property",
+        type: () => {
+          return Tasks.Task;
+        }
+      },
+      ConcurrentScheduler: {
+        kind: "property",
+        type: () => {
+          return Tasks.TaskScheduler;
+        }
+      },
+      ExclusiveScheduler: {
+        kind: "property",
+        type: () => {
+          return Tasks.TaskScheduler;
+        }
+      }
+    }
+  },
+  ConfigureAwaitOptions: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return Tasks.ConfigureAwaitOptions;
+        }
+      },
+      ContinueOnCapturedContext: {
+        kind: "field",
+        type: () => {
+          return Tasks.ConfigureAwaitOptions;
+        }
+      },
+      SuppressThrowing: {
+        kind: "field",
+        type: () => {
+          return Tasks.ConfigureAwaitOptions;
+        }
+      },
+      ForceYielding: {
+        kind: "field",
+        type: () => {
+          return Tasks.ConfigureAwaitOptions;
+        }
+      }
+    }
+  },
+  Parallel: {
+    kind: "class",
+    members: {
+      For: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true
+      },
+      Invoke: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true
+      }
+    },
+    isStatic: true
+  },
+  ParallelLoopResult: {
+    kind: "struct",
+    members: {
+      IsCompleted: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        }
+      },
+      LowestBreakIteration: {
+        kind: "property",
+        type: () => {
+          return System.Int64;
+        },
+        isNullable: true
+      }
+    }
+  },
+  ParallelLoopState: {
+    kind: "class",
+    members: {
+      Break: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      Stop: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      IsExceptional: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        }
+      },
+      IsStopped: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        }
+      },
+      LowestBreakIteration: {
+        kind: "property",
+        type: () => {
+          return System.Int64;
+        },
+        isNullable: true
+      },
+      ShouldExitCurrentIteration: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        }
+      }
+    }
+  },
+  ParallelOptions: {
+    kind: "class",
+    members: {
+      ParallelOptions: {
+        kind: "method",
+        methodKind: "constructor"
+      },
+      CancellationToken: {
+        kind: "property",
+        type: () => {
+          return Threading.CancellationToken;
+        }
+      },
+      MaxDegreeOfParallelism: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        }
+      },
+      TaskScheduler: {
+        kind: "property",
+        type: () => {
+          return Tasks.TaskScheduler;
+        }
+      }
+    }
+  },
+  Task: {
+    kind: "class",
+    members: {
+      Task: {
+        kind: "method",
+        methodKind: "constructor"
+      },
+      ConfigureAwait: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      ContinueWith: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      GetAwaiter: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      WaitAsync: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      Factory: {
+        kind: "property",
+        type: () => {
+          return Tasks.TaskFactory;
+        },
+        isStatic: true
+      },
+      Result: {
+        kind: "property",
+        type: undefined
+      }
+    }
+  },
+  TaskAsyncEnumerableExtensions: {
+    kind: "class",
+    members: {
+      ConfigureAwait: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true
+      }
+    },
+    isStatic: true
+  },
+  TaskCanceledException: {
+    kind: "class",
+    members: {
+      TaskCanceledException: {
+        kind: "method",
+        methodKind: "constructor"
+      },
+      Task: {
+        kind: "property",
+        type: () => {
+          return Tasks.Task;
+        }
+      }
+    }
+  },
+  TaskCompletionSource: {
+    kind: "class",
+    members: {
+      TaskCompletionSource: {
+        kind: "method",
+        methodKind: "constructor"
+      },
+      SetCanceled: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      SetException: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      SetFromTask: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      SetResult: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      TrySetCanceled: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      TrySetException: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      TrySetFromTask: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      TrySetResult: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      Task: {
+        kind: "property",
+        type: () => {
+          return Tasks.Task;
+        }
+      }
+    }
+  },
+  TaskContinuationOptions: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      PreferFairness: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      LongRunning: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      AttachedToParent: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      DenyChildAttach: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      HideScheduler: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      LazyCancellation: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      RunContinuationsAsynchronously: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      NotOnRanToCompletion: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      NotOnFaulted: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      OnlyOnCanceled: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      NotOnCanceled: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      OnlyOnFaulted: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      OnlyOnRanToCompletion: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      ExecuteSynchronously: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      }
+    }
+  },
+  TaskCreationOptions: {
+    kind: "enum",
+    members: {
+      None: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskCreationOptions;
+        }
+      },
+      PreferFairness: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskCreationOptions;
+        }
+      },
+      LongRunning: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskCreationOptions;
+        }
+      },
+      AttachedToParent: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskCreationOptions;
+        }
+      },
+      DenyChildAttach: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskCreationOptions;
+        }
+      },
+      HideScheduler: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskCreationOptions;
+        }
+      },
+      RunContinuationsAsynchronously: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskCreationOptions;
+        }
+      }
+    }
+  },
+  TaskExtensions: {
+    kind: "class",
+    members: {
+      Unwrap: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true
+      }
+    },
+    isStatic: true
+  },
+  TaskFactory: {
+    kind: "class",
+    members: {
+      TaskFactory: {
+        kind: "method",
+        methodKind: "constructor"
+      },
+      ContinueWhenAll: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      ContinueWhenAny: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      FromAsync: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      StartNew: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      CancellationToken: {
+        kind: "property",
+        type: () => {
+          return Threading.CancellationToken;
+        }
+      },
+      ContinuationOptions: {
+        kind: "property",
+        type: () => {
+          return Tasks.TaskContinuationOptions;
+        }
+      },
+      CreationOptions: {
+        kind: "property",
+        type: () => {
+          return Tasks.TaskCreationOptions;
+        }
+      },
+      Scheduler: {
+        kind: "property",
+        type: () => {
+          return Tasks.TaskScheduler;
+        }
+      }
+    }
+  },
+  TaskScheduler: {
+    kind: "class",
+    members: {
+      TaskScheduler: {
+        kind: "method",
+        methodKind: "constructor"
+      },
+      FromCurrentSynchronizationContext: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true
+      },
+      GetScheduledTasks: {
+        kind: "method",
+        methodKind: "ordinary",
+        isAbstract: true
+      },
+      QueueTask: {
+        kind: "method",
+        methodKind: "ordinary",
+        isAbstract: true
+      },
+      TryDequeue: {
+        kind: "method",
+        methodKind: "ordinary",
+        isVirtual: true
+      },
+      TryExecuteTask: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      TryExecuteTaskInline: {
+        kind: "method",
+        methodKind: "ordinary",
+        isAbstract: true
+      },
+      Current: {
+        kind: "property",
+        type: () => {
+          return Tasks.TaskScheduler;
+        },
+        isStatic: true
+      },
+      Default: {
+        kind: "property",
+        type: () => {
+          return Tasks.TaskScheduler;
+        },
+        isStatic: true
+      },
+      Id: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        }
+      },
+      MaximumConcurrencyLevel: {
+        kind: "property",
+        type: () => {
+          return System.Int32;
+        },
+        isVirtual: true
+      }
+    },
+    isAbstract: true
+  },
+  TaskSchedulerException: {
+    kind: "class",
+    members: {
+      TaskSchedulerException: {
+        kind: "method",
+        methodKind: "constructor"
+      }
+    }
+  },
+  TaskStatus: {
+    kind: "enum",
+    members: {
+      Created: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskStatus;
+        }
+      },
+      WaitingForActivation: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskStatus;
+        }
+      },
+      WaitingToRun: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskStatus;
+        }
+      },
+      Running: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskStatus;
+        }
+      },
+      WaitingForChildrenToComplete: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskStatus;
+        }
+      },
+      RanToCompletion: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskStatus;
+        }
+      },
+      Canceled: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskStatus;
+        }
+      },
+      Faulted: {
+        kind: "field",
+        type: () => {
+          return Tasks.TaskStatus;
+        }
+      }
+    }
+  },
+  TaskToAsyncResult: {
+    kind: "class",
+    members: {
+      Begin: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true
+      },
+      End: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true
+      },
+      Unwrap: {
+        kind: "method",
+        methodKind: "ordinary",
+        isStatic: true
+      }
+    },
+    isStatic: true
+  },
+  UnobservedTaskExceptionEventArgs: {
+    kind: "class",
+    members: {
+      UnobservedTaskExceptionEventArgs: {
+        kind: "method",
+        methodKind: "constructor"
+      },
+      SetObserved: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      Exception: {
+        kind: "property",
+        type: () => {
+          return System.AggregateException;
+        }
+      },
+      Observed: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        }
+      }
+    }
+  },
+  ValueTask: {
+    kind: "struct",
+    members: {
+      ValueTask: {
+        kind: "method",
+        methodKind: "constructor"
+      },
+      AsTask: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      ConfigureAwait: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      Equals: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true
+      },
+      GetAwaiter: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      GetHashCode: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true
+      },
+      Preserve: {
+        kind: "method",
+        methodKind: "ordinary"
+      },
+      ToString: {
+        kind: "method",
+        methodKind: "ordinary",
+        isOverride: true
+      },
+      IsCanceled: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        }
+      },
+      IsCompleted: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        }
+      },
+      IsCompletedSuccessfully: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        }
+      },
+      IsFaulted: {
+        kind: "property",
+        type: () => {
+          return System.Boolean;
+        }
+      },
+      Result: {
+        kind: "property",
+        type: undefined
+      }
+    }
+  }
+});
+export default Tasks;
+//# sourceMappingURL=index.js.map