@tsonic/dotnet/System.Threading.Tasks/internal/index.d.ts

TypeScript type definitions for .NET 10 BCL (Base Class Library)

// Generated by tsbindgen - Architecture
// Namespace: System.Threading.Tasks
// Assembly: System.Private.CoreLib, System.Threading.Tasks.Parallel

// Branded primitive types are sourced from @tsonic/types
import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/types';

// Import types from other namespaces
import type { OrderablePartitioner_1, Partitioner_1 } from "../../System.Collections.Concurrent/internal/index.js";
import type { IAsyncEnumerable_1, IEnumerable_1 } from "../../System.Collections.Generic/internal/index.js";
import type { IDictionary } from "../../System.Collections/internal/index.js";
import type { IBinaryInteger_1 } from "../../System.Numerics/internal/index.js";
import type { MethodBase } from "../../System.Reflection/internal/index.js";
import type { ConfiguredAsyncDisposable, ConfiguredCancelableAsyncEnumerable_1, ConfiguredTaskAwaitable, ConfiguredTaskAwaitable_1, ConfiguredValueTaskAwaitable, ConfiguredValueTaskAwaitable_1, TaskAwaiter, TaskAwaiter_1, ValueTaskAwaiter, ValueTaskAwaiter_1, YieldAwaitable } from "../../System.Runtime.CompilerServices/internal/index.js";
import * as System_Runtime_Serialization_Internal from "../../System.Runtime.Serialization/internal/index.js";
import type { ISerializable, SerializationInfo, StreamingContext } from "../../System.Runtime.Serialization/internal/index.js";
import type { IValueTaskSource, IValueTaskSource_1 } from "../../System.Threading.Tasks.Sources/internal/index.js";
import type { CancellationToken, WaitHandle } from "../../System.Threading/internal/index.js";
import * as System_Internal from "../../System/internal/index.js";
import type { Action, Action_1, Action_2, Action_3, AggregateException, AsyncCallback, Boolean as ClrBoolean, Enum, EventArgs, EventHandler_1, Exception, Func_1, Func_2, Func_3, Func_4, Func_5, Func_6, IAsyncDisposable, IAsyncResult, IComparable, IConvertible, IDisposable, IEquatable_1, IFormatProvider, IFormattable, Int16, Int32, Int64, ISpanFormattable, Nullable_1, Object as ClrObject, OperationCanceledException, ReadOnlySpan_1, String as ClrString, TimeProvider, TimeSpan, Type, TypeCode, ValueType, Void } from "../../System/internal/index.js";

// CLROf<T> - Maps ergonomic primitives to their CLR types for generic constraints
// This utility is used ONLY in generic type arguments to satisfy CLR interface constraints
// Value positions (parameters, return types) use lowercase primitives for ergonomics
export type CLROf<T> =
    T extends sbyte ? System_Internal.SByte :
    T extends short ? System_Internal.Int16 :
    T extends int ? System_Internal.Int32 :
    T extends long ? System_Internal.Int64 :
    T extends int128 ? System_Internal.Int128 :
    T extends nint ? System_Internal.IntPtr :
    T extends byte ? System_Internal.Byte :
    T extends ushort ? System_Internal.UInt16 :
    T extends uint ? System_Internal.UInt32 :
    T extends ulong ? System_Internal.UInt64 :
    T extends uint128 ? System_Internal.UInt128 :
    T extends nuint ? System_Internal.UIntPtr :
    T extends half ? System_Internal.Half :
    T extends float ? System_Internal.Single :
    T extends double ? System_Internal.Double :
    T extends decimal ? System_Internal.Decimal :
    T extends char ? System_Internal.Char :
    T extends boolean ? System_Internal.Boolean :
    T extends string ? System_Internal.String :
    T; // Identity fallback for non-primitive types

export enum ConfigureAwaitOptions {
    none = 0,
    continueOnCapturedContext = 1,
    suppressThrowing = 2,
    forceYielding = 4
}


export enum TaskContinuationOptions {
    none = 0,
    preferFairness = 1,
    longRunning = 2,
    attachedToParent = 4,
    denyChildAttach = 8,
    hideScheduler = 16,
    lazyCancellation = 32,
    runContinuationsAsynchronously = 64,
    notOnRanToCompletion = 65536,
    notOnFaulted = 131072,
    notOnCanceled = 262144,
    onlyOnRanToCompletion = 393216,
    onlyOnFaulted = 327680,
    onlyOnCanceled = 196608,
    executeSynchronously = 524288
}


export enum TaskCreationOptions {
    none = 0,
    preferFairness = 1,
    longRunning = 2,
    attachedToParent = 4,
    denyChildAttach = 8,
    hideScheduler = 16,
    runContinuationsAsynchronously = 64
}


export enum TaskStatus {
    created = 0,
    waitingForActivation = 1,
    waitingToRun = 2,
    running = 3,
    waitingForChildrenToComplete = 4,
    ranToCompletion = 5,
    canceled = 6,
    faulted = 7
}


export interface ParallelLoopResult$instance {
    readonly isCompleted: boolean;
    readonly lowestBreakIteration: Nullable_1<CLROf<long>>;
}


export const ParallelLoopResult: {
    new(): ParallelLoopResult$instance;
};


export type ParallelLoopResult = ParallelLoopResult$instance;

export interface ValueTask$instance {
    readonly isCanceled: boolean;
    readonly isCompleted: boolean;
    readonly isCompletedSuccessfully: boolean;
    readonly isFaulted: boolean;
    asTask(): Task;
    configureAwait(continueOnCapturedContext: boolean): ConfiguredValueTaskAwaitable;
    equals(obj: unknown): boolean;
    equals(other: ValueTask): boolean;
    getAwaiter(): ValueTaskAwaiter;
    getHashCode(): int;
    preserve(): ValueTask;
}


export const ValueTask: {
    new(task: Task): ValueTask$instance;
    new(source: IValueTaskSource, token: short): ValueTask$instance;
    readonly completedTask: ValueTask;
    fromCanceled(cancellationToken: CancellationToken): ValueTask;
    fromCanceled<TResult>(cancellationToken: CancellationToken): ValueTask_1<TResult>;
    fromException(exception: Exception): ValueTask;
    fromException<TResult>(exception: Exception): ValueTask_1<TResult>;
    fromResult<TResult>(result: TResult): ValueTask_1<TResult>;
};


export interface __ValueTask$views {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<ValueTask>;

    // Structural method bridges for numeric interface constraints
    Equals(other: ValueTask): boolean;
}

export type ValueTask = ValueTask$instance & __ValueTask$views;


export interface ValueTask_1$instance<TResult> {
    readonly isCanceled: boolean;
    readonly isCompleted: boolean;
    readonly isCompletedSuccessfully: boolean;
    readonly isFaulted: boolean;
    readonly result: TResult;
    asTask(): Task_1<TResult>;
    configureAwait(continueOnCapturedContext: boolean): ConfiguredValueTaskAwaitable_1<TResult>;
    equals(obj: unknown): boolean;
    equals(other: ValueTask_1<TResult>): boolean;
    getAwaiter(): ValueTaskAwaiter_1<TResult>;
    getHashCode(): int;
    preserve(): ValueTask_1<TResult>;
    toString(): string;
}


export const ValueTask_1: {
    new<TResult>(result: TResult): ValueTask_1$instance<TResult>;
    new<TResult>(task: Task_1<TResult>): ValueTask_1$instance<TResult>;
    new<TResult>(source: IValueTaskSource_1<TResult>, token: short): ValueTask_1$instance<TResult>;
};


export interface __ValueTask_1$views<TResult> {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<ValueTask_1<TResult>>;

    // Structural method bridges for numeric interface constraints
    Equals(other: ValueTask_1<TResult>): boolean;
}

export type ValueTask_1<TResult> = ValueTask_1$instance<TResult> & __ValueTask_1$views<TResult>;


export interface ConcurrentExclusiveSchedulerPair$instance {
    readonly completion: Task;
    readonly concurrentScheduler: TaskScheduler;
    readonly exclusiveScheduler: TaskScheduler;
    complete(): void;
}


export const ConcurrentExclusiveSchedulerPair: {
    new(): ConcurrentExclusiveSchedulerPair$instance;
    new(taskScheduler: TaskScheduler): ConcurrentExclusiveSchedulerPair$instance;
    new(taskScheduler: TaskScheduler, maxConcurrencyLevel: int): ConcurrentExclusiveSchedulerPair$instance;
    new(taskScheduler: TaskScheduler, maxConcurrencyLevel: int, maxItemsPerTask: int): ConcurrentExclusiveSchedulerPair$instance;
};


export type ConcurrentExclusiveSchedulerPair = ConcurrentExclusiveSchedulerPair$instance;

export interface ParallelLoopState$instance {
    readonly isExceptional: boolean;
    readonly isStopped: boolean;
    readonly lowestBreakIteration: Nullable_1<CLROf<long>>;
    readonly shouldExitCurrentIteration: boolean;
    break_(): void;
    stop(): void;
}


export const ParallelLoopState: {
    new(): ParallelLoopState$instance;
};


export type ParallelLoopState = ParallelLoopState$instance;

export interface ParallelOptions$instance {
    cancellationToken: CancellationToken;
    maxDegreeOfParallelism: int;
    taskScheduler: TaskScheduler;
}


export const ParallelOptions: {
    new(): ParallelOptions$instance;
};


export type ParallelOptions = ParallelOptions$instance;

export interface Task$instance {
    readonly asyncState: unknown;
    readonly creationOptions: TaskCreationOptions;
    readonly exception: AggregateException;
    readonly id: int;
    readonly isCanceled: boolean;
    readonly isCompleted: boolean;
    readonly isCompletedSuccessfully: boolean;
    readonly isFaulted: boolean;
    readonly status: TaskStatus;
    configureAwait(continueOnCapturedContext: boolean): ConfiguredTaskAwaitable;
    configureAwait(options: ConfigureAwaitOptions): ConfiguredTaskAwaitable;
    continueWith(continuationAction: Action_1<Task>): Task;
    continueWith(continuationAction: Action_1<Task>, cancellationToken: CancellationToken): Task;
    continueWith(continuationAction: Action_1<Task>, scheduler: TaskScheduler): Task;
    continueWith(continuationAction: Action_1<Task>, continuationOptions: TaskContinuationOptions): Task;
    continueWith(continuationAction: Action_1<Task>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown, cancellationToken: CancellationToken): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown, scheduler: TaskScheduler): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown, continuationOptions: TaskContinuationOptions): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>, scheduler: TaskScheduler): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown, scheduler: TaskScheduler): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    dispose(): void;
    getAwaiter(): TaskAwaiter;
    runSynchronously(): void;
    runSynchronously(scheduler: TaskScheduler): void;
    start(): void;
    start(scheduler: TaskScheduler): void;
    wait(): void;
    wait(timeout: TimeSpan): boolean;
    wait(timeout: TimeSpan, cancellationToken: CancellationToken): boolean;
    wait(cancellationToken: CancellationToken): void;
    wait(millisecondsTimeout: int): boolean;
    wait(millisecondsTimeout: int, cancellationToken: CancellationToken): boolean;
    waitAsync(cancellationToken: CancellationToken): Task;
    waitAsync(timeout: TimeSpan): Task;
    waitAsync(timeout: TimeSpan, timeProvider: TimeProvider): Task;
    waitAsync(timeout: TimeSpan, cancellationToken: CancellationToken): Task;
    waitAsync(timeout: TimeSpan, timeProvider: TimeProvider, cancellationToken: CancellationToken): Task;
}


export const Task: {
    new(action: Action): Task$instance;
    new(action: Action, cancellationToken: CancellationToken): Task$instance;
    new(action: Action, creationOptions: TaskCreationOptions): Task$instance;
    new(action: Action, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions): Task$instance;
    new(action: Action_1<unknown>, state: unknown): Task$instance;
    new(action: Action_1<unknown>, state: unknown, cancellationToken: CancellationToken): Task$instance;
    new(action: Action_1<unknown>, state: unknown, creationOptions: TaskCreationOptions): Task$instance;
    new(action: Action_1<unknown>, state: unknown, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions): Task$instance;
    readonly currentId: Nullable_1<CLROf<int>>;
    readonly factory: TaskFactory;
    readonly completedTask: Task;
    delay(millisecondsDelay: int, cancellationToken: CancellationToken): Task;
    delay(millisecondsDelay: int): Task;
    delay(delay: TimeSpan, cancellationToken: CancellationToken): Task;
    delay(delay: TimeSpan, timeProvider: TimeProvider, cancellationToken: CancellationToken): Task;
    delay(delay: TimeSpan, timeProvider: TimeProvider): Task;
    delay(delay: TimeSpan): Task;
    fromCanceled(cancellationToken: CancellationToken): Task;
    fromCanceled<TResult>(cancellationToken: CancellationToken): Task_1<TResult>;
    fromException(exception: Exception): Task;
    fromException<TResult>(exception: Exception): Task_1<TResult>;
    fromResult<TResult>(result: TResult): Task_1<TResult>;
    run<TResult>(function_: Func_1<TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    run<TResult>(function_: Func_1<TResult>): Task_1<TResult>;
    run(action: Action, cancellationToken: CancellationToken): Task;
    run(action: Action): Task;
    run(function_: Func_1<Task>, cancellationToken: CancellationToken): Task;
    run(function_: Func_1<Task>): Task;
    waitAll(tasks: IEnumerable_1<Task>, cancellationToken?: CancellationToken): void;
    waitAll(tasks: ReadOnlySpan_1<Task>): void;
    waitAll(tasks: Task[], millisecondsTimeout: int, cancellationToken: CancellationToken): boolean;
    waitAll(tasks: Task[], millisecondsTimeout: int): boolean;
    waitAll(tasks: Task[], cancellationToken: CancellationToken): void;
    waitAll(tasks: Task[], timeout: TimeSpan): boolean;
    waitAll(tasks: Task[]): void;
    waitAny(tasks: Task[], millisecondsTimeout: int, cancellationToken: CancellationToken): int;
    waitAny(tasks: Task[], millisecondsTimeout: int): int;
    waitAny(tasks: Task[], cancellationToken: CancellationToken): int;
    waitAny(tasks: Task[], timeout: TimeSpan): int;
    waitAny(tasks: Task[]): int;
    whenAll<TResult>(tasks: IEnumerable_1<Task_1<TResult>>): Task_1<TResult[]>;
    whenAll<TResult>(tasks: ReadOnlySpan_1<Task_1<TResult>>): Task_1<TResult[]>;
    whenAll(tasks: IEnumerable_1<Task>): Task;
    whenAll(tasks: ReadOnlySpan_1<Task>): Task;
    whenAll(tasks: Task[]): Task;
    whenAll<TResult>(tasks: Task_1<TResult>[]): Task_1<TResult[]>;
    whenAny<TResult>(tasks: IEnumerable_1<Task_1<TResult>>): Task_1<Task_1<TResult>>;
    whenAny<TResult>(tasks: ReadOnlySpan_1<Task_1<TResult>>): Task_1<Task_1<TResult>>;
    whenAny(tasks: IEnumerable_1<Task>): Task_1<Task>;
    whenAny(tasks: ReadOnlySpan_1<Task>): Task_1<Task>;
    whenAny(task1: Task, task2: Task): Task_1<Task>;
    whenAny(tasks: Task[]): Task_1<Task>;
    whenAny<TResult>(task1: Task_1<TResult>, task2: Task_1<TResult>): Task_1<Task_1<TResult>>;
    whenAny<TResult>(tasks: Task_1<TResult>[]): Task_1<Task_1<TResult>>;
    whenEach<TResult>(tasks: IEnumerable_1<Task_1<TResult>>): IAsyncEnumerable_1<Task_1<TResult>>;
    whenEach<TResult>(tasks: ReadOnlySpan_1<Task_1<TResult>>): IAsyncEnumerable_1<Task_1<TResult>>;
    whenEach(tasks: IEnumerable_1<Task>): IAsyncEnumerable_1<Task>;
    whenEach(tasks: ReadOnlySpan_1<Task>): IAsyncEnumerable_1<Task>;
    whenEach(tasks: Task[]): IAsyncEnumerable_1<Task>;
    whenEach<TResult>(tasks: Task_1<TResult>[]): IAsyncEnumerable_1<Task_1<TResult>>;
    yield_(): YieldAwaitable;
};


export interface __Task$views {
    As_IAsyncResult(): System_Internal.IAsyncResult$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface Task$instance extends System_Internal.IAsyncResult$instance, System_Internal.IDisposable$instance {}

export type Task = Task$instance & __Task$views;


export interface Task_1$instance<TResult> extends Task$instance {
    readonly result: TResult;
    configureAwait(options: ConfigureAwaitOptions): ConfiguredTaskAwaitable_1<TResult>;
    configureAwait(continueOnCapturedContext: boolean): ConfiguredTaskAwaitable;
    configureAwait(options: ConfigureAwaitOptions): ConfiguredTaskAwaitable;
    continueWith(continuationAction: Action_1<Task_1<TResult>>): Task;
    continueWith(continuationAction: Action_1<Task_1<TResult>>, cancellationToken: CancellationToken): Task;
    continueWith(continuationAction: Action_1<Task_1<TResult>>, scheduler: TaskScheduler): Task;
    continueWith(continuationAction: Action_1<Task_1<TResult>>, continuationOptions: TaskContinuationOptions): Task;
    continueWith(continuationAction: Action_1<Task_1<TResult>>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    continueWith(continuationAction: Action_2<Task_1<TResult>, unknown>, state: unknown): Task;
    continueWith(continuationAction: Action_2<Task_1<TResult>, unknown>, state: unknown, cancellationToken: CancellationToken): Task;
    continueWith(continuationAction: Action_2<Task_1<TResult>, unknown>, state: unknown, scheduler: TaskScheduler): Task;
    continueWith(continuationAction: Action_2<Task_1<TResult>, unknown>, state: unknown, continuationOptions: TaskContinuationOptions): Task;
    continueWith(continuationAction: Action_2<Task_1<TResult>, unknown>, state: unknown, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    continueWith<TNewResult>(continuationFunction: Func_2<Task_1<TResult>, TNewResult>): Task_1<TNewResult>;
    continueWith<TNewResult>(continuationFunction: Func_2<Task_1<TResult>, TNewResult>, cancellationToken: CancellationToken): Task_1<TNewResult>;
    continueWith<TNewResult>(continuationFunction: Func_2<Task_1<TResult>, TNewResult>, scheduler: TaskScheduler): Task_1<TNewResult>;
    continueWith<TNewResult>(continuationFunction: Func_2<Task_1<TResult>, TNewResult>, continuationOptions: TaskContinuationOptions): Task_1<TNewResult>;
    continueWith<TNewResult>(continuationFunction: Func_2<Task_1<TResult>, TNewResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TNewResult>;
    continueWith<TNewResult>(continuationFunction: Func_3<Task_1<TResult>, unknown, TNewResult>, state: unknown): Task_1<TNewResult>;
    continueWith<TNewResult>(continuationFunction: Func_3<Task_1<TResult>, unknown, TNewResult>, state: unknown, cancellationToken: CancellationToken): Task_1<TNewResult>;
    continueWith<TNewResult>(continuationFunction: Func_3<Task_1<TResult>, unknown, TNewResult>, state: unknown, scheduler: TaskScheduler): Task_1<TNewResult>;
    continueWith<TNewResult>(continuationFunction: Func_3<Task_1<TResult>, unknown, TNewResult>, state: unknown, continuationOptions: TaskContinuationOptions): Task_1<TNewResult>;
    continueWith<TNewResult>(continuationFunction: Func_3<Task_1<TResult>, unknown, TNewResult>, state: unknown, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TNewResult>;
    continueWith(continuationAction: Action_1<Task>): Task;
    continueWith(continuationAction: Action_1<Task>, cancellationToken: CancellationToken): Task;
    continueWith(continuationAction: Action_1<Task>, scheduler: TaskScheduler): Task;
    continueWith(continuationAction: Action_1<Task>, continuationOptions: TaskContinuationOptions): Task;
    continueWith(continuationAction: Action_1<Task>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown, cancellationToken: CancellationToken): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown, scheduler: TaskScheduler): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown, continuationOptions: TaskContinuationOptions): Task;
    continueWith(continuationAction: Action_2<Task, unknown>, state: unknown, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>, scheduler: TaskScheduler): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_2<Task, TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown, scheduler: TaskScheduler): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWith<TResult>(continuationFunction: Func_3<Task, unknown, TResult>, state: unknown, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    dispose(): void;
    getAwaiter(): TaskAwaiter;
    waitAsync(timeout: TimeSpan): Task_1<TResult>;
    waitAsync(timeout: TimeSpan, timeProvider: TimeProvider): Task_1<TResult>;
    waitAsync(cancellationToken: CancellationToken): Task;
    waitAsync(timeout: TimeSpan): Task;
    waitAsync(timeout: TimeSpan, timeProvider: TimeProvider): Task;
    waitAsync(timeout: TimeSpan, cancellationToken: CancellationToken): Task;
    waitAsync(timeout: TimeSpan, timeProvider: TimeProvider, cancellationToken: CancellationToken): Task;
}


export const Task_1: {
    new<TResult>(function_: Func_1<TResult>): Task_1$instance<TResult>;
    new<TResult>(function_: Func_1<TResult>, cancellationToken: CancellationToken): Task_1$instance<TResult>;
    new<TResult>(function_: Func_1<TResult>, creationOptions: TaskCreationOptions): Task_1$instance<TResult>;
    new<TResult>(function_: Func_1<TResult>, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions): Task_1$instance<TResult>;
    new<TResult>(function_: Func_2<unknown, TResult>, state: unknown): Task_1$instance<TResult>;
    new<TResult>(function_: Func_2<unknown, TResult>, state: unknown, cancellationToken: CancellationToken): Task_1$instance<TResult>;
    new<TResult>(function_: Func_2<unknown, TResult>, state: unknown, creationOptions: TaskCreationOptions): Task_1$instance<TResult>;
    new<TResult>(function_: Func_2<unknown, TResult>, state: unknown, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions): Task_1$instance<TResult>;
};


export interface __Task_1$views<TResult> {
    As_IAsyncResult(): System_Internal.IAsyncResult$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface Task_1$instance<TResult> extends System_Internal.IAsyncResult$instance {}

export type Task_1<TResult> = Task_1$instance<TResult> & __Task_1$views<TResult>;


export interface TaskCanceledException$instance extends OperationCanceledException {
    readonly task: Task;
    getObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const TaskCanceledException: {
    new(): TaskCanceledException$instance;
    new(message: string): TaskCanceledException$instance;
    new(message: string, innerException: Exception): TaskCanceledException$instance;
    new(message: string, innerException: Exception, token: CancellationToken): TaskCanceledException$instance;
    new(task: Task): TaskCanceledException$instance;
};


export interface __TaskCanceledException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type TaskCanceledException = TaskCanceledException$instance & __TaskCanceledException$views;


export interface TaskCompletionSource$instance {
    readonly task: Task;
    setCanceled(): void;
    setCanceled(cancellationToken: CancellationToken): void;
    setException(exception: Exception): void;
    setException(exceptions: IEnumerable_1<Exception>): void;
    setFromTask(completedTask: Task): void;
    setResult(): void;
    trySetCanceled(): boolean;
    trySetCanceled(cancellationToken: CancellationToken): boolean;
    trySetException(exception: Exception): boolean;
    trySetException(exceptions: IEnumerable_1<Exception>): boolean;
    trySetFromTask(completedTask: Task): boolean;
    trySetResult(): boolean;
}


export const TaskCompletionSource: {
    new(): TaskCompletionSource$instance;
    new(creationOptions: TaskCreationOptions): TaskCompletionSource$instance;
    new(state: unknown): TaskCompletionSource$instance;
    new(state: unknown, creationOptions: TaskCreationOptions): TaskCompletionSource$instance;
};


export type TaskCompletionSource = TaskCompletionSource$instance;

export interface TaskCompletionSource_1$instance<TResult> {
    readonly task: Task_1<TResult>;
    setCanceled(): void;
    setCanceled(cancellationToken: CancellationToken): void;
    setException(exception: Exception): void;
    setException(exceptions: IEnumerable_1<Exception>): void;
    setFromTask(completedTask: Task_1<TResult>): void;
    setResult(result: TResult): void;
    trySetCanceled(): boolean;
    trySetCanceled(cancellationToken: CancellationToken): boolean;
    trySetException(exception: Exception): boolean;
    trySetException(exceptions: IEnumerable_1<Exception>): boolean;
    trySetFromTask(completedTask: Task_1<TResult>): boolean;
    trySetResult(result: TResult): boolean;
}


export const TaskCompletionSource_1: {
    new<TResult>(): TaskCompletionSource_1$instance<TResult>;
    new<TResult>(creationOptions: TaskCreationOptions): TaskCompletionSource_1$instance<TResult>;
    new<TResult>(state: unknown): TaskCompletionSource_1$instance<TResult>;
    new<TResult>(state: unknown, creationOptions: TaskCreationOptions): TaskCompletionSource_1$instance<TResult>;
};


export type TaskCompletionSource_1<TResult> = TaskCompletionSource_1$instance<TResult>;

export interface TaskFactory$instance {
    readonly cancellationToken: CancellationToken;
    readonly continuationOptions: TaskContinuationOptions;
    readonly creationOptions: TaskCreationOptions;
    readonly scheduler: TaskScheduler;
    continueWhenAll(tasks: Task[], continuationAction: Action_1<Task[]>): Task;
    continueWhenAll(tasks: Task[], continuationAction: Action_1<Task[]>, cancellationToken: CancellationToken): Task;
    continueWhenAll(tasks: Task[], continuationAction: Action_1<Task[]>, continuationOptions: TaskContinuationOptions): Task;
    continueWhenAll(tasks: Task[], continuationAction: Action_1<Task[]>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    continueWhenAll<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationAction: Action_1<Task_1<TAntecedentResult>[]>): Task;
    continueWhenAll<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationAction: Action_1<Task_1<TAntecedentResult>[]>, cancellationToken: CancellationToken): Task;
    continueWhenAll<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationAction: Action_1<Task_1<TAntecedentResult>[]>, continuationOptions: TaskContinuationOptions): Task;
    continueWhenAll<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationAction: Action_1<Task_1<TAntecedentResult>[]>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    continueWhenAll<TResult>(tasks: Task[], continuationFunction: Func_2<Task[], TResult>): Task_1<TResult>;
    continueWhenAll<TResult>(tasks: Task[], continuationFunction: Func_2<Task[], TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWhenAll<TResult>(tasks: Task[], continuationFunction: Func_2<Task[], TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWhenAll<TResult>(tasks: Task[], continuationFunction: Func_2<Task[], TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    continueWhenAll<TAntecedentResult, TResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>[], TResult>): Task_1<TResult>;
    continueWhenAll<TAntecedentResult, TResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>[], TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWhenAll<TAntecedentResult, TResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>[], TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWhenAll<TAntecedentResult, TResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>[], TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    continueWhenAny(tasks: Task[], continuationAction: Action_1<Task>): Task;
    continueWhenAny(tasks: Task[], continuationAction: Action_1<Task>, cancellationToken: CancellationToken): Task;
    continueWhenAny(tasks: Task[], continuationAction: Action_1<Task>, continuationOptions: TaskContinuationOptions): Task;
    continueWhenAny(tasks: Task[], continuationAction: Action_1<Task>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    continueWhenAny<TResult>(tasks: Task[], continuationFunction: Func_2<Task, TResult>): Task_1<TResult>;
    continueWhenAny<TResult>(tasks: Task[], continuationFunction: Func_2<Task, TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWhenAny<TResult>(tasks: Task[], continuationFunction: Func_2<Task, TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWhenAny<TResult>(tasks: Task[], continuationFunction: Func_2<Task, TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    continueWhenAny<TAntecedentResult, TResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>, TResult>): Task_1<TResult>;
    continueWhenAny<TAntecedentResult, TResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>, TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWhenAny<TAntecedentResult, TResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>, TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWhenAny<TAntecedentResult, TResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>, TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    continueWhenAny<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationAction: Action_1<Task_1<TAntecedentResult>>): Task;
    continueWhenAny<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationAction: Action_1<Task_1<TAntecedentResult>>, cancellationToken: CancellationToken): Task;
    continueWhenAny<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationAction: Action_1<Task_1<TAntecedentResult>>, continuationOptions: TaskContinuationOptions): Task;
    continueWhenAny<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationAction: Action_1<Task_1<TAntecedentResult>>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task;
    fromAsync(asyncResult: IAsyncResult, endMethod: Action_1<IAsyncResult>): Task;
    fromAsync(asyncResult: IAsyncResult, endMethod: Action_1<IAsyncResult>, creationOptions: TaskCreationOptions): Task;
    fromAsync(asyncResult: IAsyncResult, endMethod: Action_1<IAsyncResult>, creationOptions: TaskCreationOptions, scheduler: TaskScheduler): Task;
    fromAsync(beginMethod: Func_3<AsyncCallback, unknown, IAsyncResult>, endMethod: Action_1<IAsyncResult>, state: unknown): Task;
    fromAsync(beginMethod: Func_3<AsyncCallback, unknown, IAsyncResult>, endMethod: Action_1<IAsyncResult>, state: unknown, creationOptions: TaskCreationOptions): Task;
    fromAsync<TArg1>(beginMethod: Func_4<TArg1, AsyncCallback, unknown, IAsyncResult>, endMethod: Action_1<IAsyncResult>, arg1: TArg1, state: unknown): Task;
    fromAsync<TArg1>(beginMethod: Func_4<TArg1, AsyncCallback, unknown, IAsyncResult>, endMethod: Action_1<IAsyncResult>, arg1: TArg1, state: unknown, creationOptions: TaskCreationOptions): Task;
    fromAsync<TArg1, TArg2>(beginMethod: Func_5<TArg1, TArg2, AsyncCallback, unknown, IAsyncResult>, endMethod: Action_1<IAsyncResult>, arg1: TArg1, arg2: TArg2, state: unknown): Task;
    fromAsync<TArg1, TArg2>(beginMethod: Func_5<TArg1, TArg2, AsyncCallback, unknown, IAsyncResult>, endMethod: Action_1<IAsyncResult>, arg1: TArg1, arg2: TArg2, state: unknown, creationOptions: TaskCreationOptions): Task;
    fromAsync<TArg1, TArg2, TArg3>(beginMethod: Func_6<TArg1, TArg2, TArg3, AsyncCallback, unknown, IAsyncResult>, endMethod: Action_1<IAsyncResult>, arg1: TArg1, arg2: TArg2, arg3: TArg3, state: unknown): Task;
    fromAsync<TArg1, TArg2, TArg3>(beginMethod: Func_6<TArg1, TArg2, TArg3, AsyncCallback, unknown, IAsyncResult>, endMethod: Action_1<IAsyncResult>, arg1: TArg1, arg2: TArg2, arg3: TArg3, state: unknown, creationOptions: TaskCreationOptions): Task;
    fromAsync<TResult>(asyncResult: IAsyncResult, endMethod: Func_2<IAsyncResult, TResult>): Task_1<TResult>;
    fromAsync<TResult>(asyncResult: IAsyncResult, endMethod: Func_2<IAsyncResult, TResult>, creationOptions: TaskCreationOptions): Task_1<TResult>;
    fromAsync<TResult>(asyncResult: IAsyncResult, endMethod: Func_2<IAsyncResult, TResult>, creationOptions: TaskCreationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    fromAsync<TResult>(beginMethod: Func_3<AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, state: unknown): Task_1<TResult>;
    fromAsync<TResult>(beginMethod: Func_3<AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    fromAsync<TArg1, TResult>(beginMethod: Func_4<TArg1, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, state: unknown): Task_1<TResult>;
    fromAsync<TArg1, TResult>(beginMethod: Func_4<TArg1, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    fromAsync<TArg1, TArg2, TResult>(beginMethod: Func_5<TArg1, TArg2, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, arg2: TArg2, state: unknown): Task_1<TResult>;
    fromAsync<TArg1, TArg2, TResult>(beginMethod: Func_5<TArg1, TArg2, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, arg2: TArg2, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    fromAsync<TArg1, TArg2, TArg3, TResult>(beginMethod: Func_6<TArg1, TArg2, TArg3, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, arg2: TArg2, arg3: TArg3, state: unknown): Task_1<TResult>;
    fromAsync<TArg1, TArg2, TArg3, TResult>(beginMethod: Func_6<TArg1, TArg2, TArg3, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, arg2: TArg2, arg3: TArg3, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    startNew(action: Action): Task;
    startNew(action: Action, cancellationToken: CancellationToken): Task;
    startNew(action: Action, creationOptions: TaskCreationOptions): Task;
    startNew(action: Action, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, scheduler: TaskScheduler): Task;
    startNew(action: Action_1<unknown>, state: unknown): Task;
    startNew(action: Action_1<unknown>, state: unknown, cancellationToken: CancellationToken): Task;
    startNew(action: Action_1<unknown>, state: unknown, creationOptions: TaskCreationOptions): Task;
    startNew(action: Action_1<unknown>, state: unknown, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, scheduler: TaskScheduler): Task;
    startNew<TResult>(function_: Func_1<TResult>): Task_1<TResult>;
    startNew<TResult>(function_: Func_1<TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    startNew<TResult>(function_: Func_1<TResult>, creationOptions: TaskCreationOptions): Task_1<TResult>;
    startNew<TResult>(function_: Func_1<TResult>, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    startNew<TResult>(function_: Func_2<unknown, TResult>, state: unknown): Task_1<TResult>;
    startNew<TResult>(function_: Func_2<unknown, TResult>, state: unknown, cancellationToken: CancellationToken): Task_1<TResult>;
    startNew<TResult>(function_: Func_2<unknown, TResult>, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    startNew<TResult>(function_: Func_2<unknown, TResult>, state: unknown, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, scheduler: TaskScheduler): Task_1<TResult>;
}


export const TaskFactory: {
    new(): TaskFactory$instance;
    new(cancellationToken: CancellationToken): TaskFactory$instance;
    new(scheduler: TaskScheduler): TaskFactory$instance;
    new(creationOptions: TaskCreationOptions, continuationOptions: TaskContinuationOptions): TaskFactory$instance;
    new(cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): TaskFactory$instance;
};


export type TaskFactory = TaskFactory$instance;

export interface TaskFactory_1$instance<TResult> {
    readonly cancellationToken: CancellationToken;
    readonly continuationOptions: TaskContinuationOptions;
    readonly creationOptions: TaskCreationOptions;
    readonly scheduler: TaskScheduler;
    continueWhenAll(tasks: Task[], continuationFunction: Func_2<Task[], TResult>): Task_1<TResult>;
    continueWhenAll(tasks: Task[], continuationFunction: Func_2<Task[], TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWhenAll(tasks: Task[], continuationFunction: Func_2<Task[], TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWhenAll(tasks: Task[], continuationFunction: Func_2<Task[], TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    continueWhenAll<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>[], TResult>): Task_1<TResult>;
    continueWhenAll<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>[], TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWhenAll<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>[], TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWhenAll<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>[], TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    continueWhenAny(tasks: Task[], continuationFunction: Func_2<Task, TResult>): Task_1<TResult>;
    continueWhenAny(tasks: Task[], continuationFunction: Func_2<Task, TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWhenAny(tasks: Task[], continuationFunction: Func_2<Task, TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWhenAny(tasks: Task[], continuationFunction: Func_2<Task, TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    continueWhenAny<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>, TResult>): Task_1<TResult>;
    continueWhenAny<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>, TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    continueWhenAny<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>, TResult>, continuationOptions: TaskContinuationOptions): Task_1<TResult>;
    continueWhenAny<TAntecedentResult>(tasks: Task_1<TAntecedentResult>[], continuationFunction: Func_2<Task_1<TAntecedentResult>, TResult>, cancellationToken: CancellationToken, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    fromAsync(asyncResult: IAsyncResult, endMethod: Func_2<IAsyncResult, TResult>): Task_1<TResult>;
    fromAsync(asyncResult: IAsyncResult, endMethod: Func_2<IAsyncResult, TResult>, creationOptions: TaskCreationOptions): Task_1<TResult>;
    fromAsync(asyncResult: IAsyncResult, endMethod: Func_2<IAsyncResult, TResult>, creationOptions: TaskCreationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    fromAsync(beginMethod: Func_3<AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, state: unknown): Task_1<TResult>;
    fromAsync(beginMethod: Func_3<AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    fromAsync<TArg1>(beginMethod: Func_4<TArg1, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, state: unknown): Task_1<TResult>;
    fromAsync<TArg1>(beginMethod: Func_4<TArg1, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    fromAsync<TArg1, TArg2>(beginMethod: Func_5<TArg1, TArg2, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, arg2: TArg2, state: unknown): Task_1<TResult>;
    fromAsync<TArg1, TArg2>(beginMethod: Func_5<TArg1, TArg2, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, arg2: TArg2, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    fromAsync<TArg1, TArg2, TArg3>(beginMethod: Func_6<TArg1, TArg2, TArg3, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, arg2: TArg2, arg3: TArg3, state: unknown): Task_1<TResult>;
    fromAsync<TArg1, TArg2, TArg3>(beginMethod: Func_6<TArg1, TArg2, TArg3, AsyncCallback, unknown, IAsyncResult>, endMethod: Func_2<IAsyncResult, TResult>, arg1: TArg1, arg2: TArg2, arg3: TArg3, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    startNew(function_: Func_1<TResult>): Task_1<TResult>;
    startNew(function_: Func_1<TResult>, cancellationToken: CancellationToken): Task_1<TResult>;
    startNew(function_: Func_1<TResult>, creationOptions: TaskCreationOptions): Task_1<TResult>;
    startNew(function_: Func_1<TResult>, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, scheduler: TaskScheduler): Task_1<TResult>;
    startNew(function_: Func_2<unknown, TResult>, state: unknown): Task_1<TResult>;
    startNew(function_: Func_2<unknown, TResult>, state: unknown, cancellationToken: CancellationToken): Task_1<TResult>;
    startNew(function_: Func_2<unknown, TResult>, state: unknown, creationOptions: TaskCreationOptions): Task_1<TResult>;
    startNew(function_: Func_2<unknown, TResult>, state: unknown, cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, scheduler: TaskScheduler): Task_1<TResult>;
}


export const TaskFactory_1: {
    new<TResult>(): TaskFactory_1$instance<TResult>;
    new<TResult>(cancellationToken: CancellationToken): TaskFactory_1$instance<TResult>;
    new<TResult>(scheduler: TaskScheduler): TaskFactory_1$instance<TResult>;
    new<TResult>(creationOptions: TaskCreationOptions, continuationOptions: TaskContinuationOptions): TaskFactory_1$instance<TResult>;
    new<TResult>(cancellationToken: CancellationToken, creationOptions: TaskCreationOptions, continuationOptions: TaskContinuationOptions, scheduler: TaskScheduler): TaskFactory_1$instance<TResult>;
};


export type TaskFactory_1<TResult> = TaskFactory_1$instance<TResult>;

export interface TaskScheduler$instance {
    readonly id: int;
    readonly maximumConcurrencyLevel: int;
}


export const TaskScheduler: {
    readonly default_: TaskScheduler;
    readonly current: TaskScheduler;
    fromCurrentSynchronizationContext(): TaskScheduler;
};


export type TaskScheduler = TaskScheduler$instance;

export interface TaskSchedulerException$instance extends Exception {
    getObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const TaskSchedulerException: {
    new(): TaskSchedulerException$instance;
    new(message: string): TaskSchedulerException$instance;
    new(innerException: Exception): TaskSchedulerException$instance;
    new(message: string, innerException: Exception): TaskSchedulerException$instance;
};


export interface __TaskSchedulerException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type TaskSchedulerException = TaskSchedulerException$instance & __TaskSchedulerException$views;


export interface UnobservedTaskExceptionEventArgs$instance extends EventArgs {
    readonly exception: AggregateException;
    readonly observed: boolean;
    setObserved(): void;
}


export const UnobservedTaskExceptionEventArgs: {
    new(exception: AggregateException): UnobservedTaskExceptionEventArgs$instance;
};


export type UnobservedTaskExceptionEventArgs = UnobservedTaskExceptionEventArgs$instance;

export abstract class Parallel$instance {
    static for_<TLocal>(fromInclusive: int, toExclusive: int, localInit: Func_1<TLocal>, body: Func_4<CLROf<int>, ParallelLoopState, TLocal, TLocal>, localFinally: Action_1<TLocal>): ParallelLoopResult;
    static for_(fromInclusive: int, toExclusive: int, body: Action_1<CLROf<int>>): ParallelLoopResult;
    static for_(fromInclusive: int, toExclusive: int, body: Action_2<CLROf<int>, ParallelLoopState>): ParallelLoopResult;
    static for_<TLocal>(fromInclusive: int, toExclusive: int, parallelOptions: ParallelOptions, localInit: Func_1<TLocal>, body: Func_4<CLROf<int>, ParallelLoopState, TLocal, TLocal>, localFinally: Action_1<TLocal>): ParallelLoopResult;
    static for_(fromInclusive: int, toExclusive: int, parallelOptions: ParallelOptions, body: Action_1<CLROf<int>>): ParallelLoopResult;
    static for_(fromInclusive: int, toExclusive: int, parallelOptions: ParallelOptions, body: Action_2<CLROf<int>, ParallelLoopState>): ParallelLoopResult;
    static for_<TLocal>(fromInclusive: long, toExclusive: long, localInit: Func_1<TLocal>, body: Func_4<CLROf<long>, ParallelLoopState, TLocal, TLocal>, localFinally: Action_1<TLocal>): ParallelLoopResult;
    static for_(fromInclusive: long, toExclusive: long, body: Action_1<CLROf<long>>): ParallelLoopResult;
    static for_(fromInclusive: long, toExclusive: long, body: Action_2<CLROf<long>, ParallelLoopState>): ParallelLoopResult;
    static for_<TLocal>(fromInclusive: long, toExclusive: long, parallelOptions: ParallelOptions, localInit: Func_1<TLocal>, body: Func_4<CLROf<long>, ParallelLoopState, TLocal, TLocal>, localFinally: Action_1<TLocal>): ParallelLoopResult;
    static for_(fromIn