@tensorlakeai/tensorlake 0.0.0-bootstrap.0 → 0.5.145

package/dist/remote-CNJ9TmcQ.d.cts

@@ -0,0 +1,283 @@
+import { C as CloudClientOptions, A as ApplicationManifest, F as FileSystem, a as ApplicationSummary, R as RequestInput, b as RequestOutput, I as Image } from './sandbox-image-ChzWDeZy.cjs';
+
+declare class APIClient {
+    private readonly cloudClient;
+    private readonly filesystemOptions;
+    constructor(options?: CloudClientOptions);
+    close(): void;
+    upsertApplication(manifest: ApplicationManifest, codeZip: Uint8Array | ArrayBuffer | Blob | string, upgradeRunningRequests?: boolean): Promise<void>;
+    deleteApplication(applicationName: string): Promise<void>;
+    deleteSandboxImage(imageName: string): Promise<void>;
+    createFileSystem(name: string, description?: string, options?: {
+        organizationId?: string;
+        projectId?: string;
+        region?: string;
+    }): Promise<FileSystem>;
+    listFileSystems(_options?: {
+        organizationId?: string;
+        projectId?: string;
+    }): Promise<FileSystem[]>;
+    deleteFileSystem(fileSystemId: string, _options?: {
+        organizationId?: string;
+        projectId?: string;
+    }): Promise<void>;
+    applications(): Promise<ApplicationSummary[]>;
+    application(applicationName: string): Promise<ApplicationManifest>;
+    runRequest(applicationName: string, inputs: RequestInput[]): Promise<string>;
+    waitOnRequestCompletion(applicationName: string, requestId: string): Promise<void>;
+    requestOutput(applicationName: string, requestId: string): Promise<RequestOutput>;
+}
+
+declare const FILE_BRAND: unique symbol;
+declare class File {
+    readonly [FILE_BRAND] = true;
+    readonly content: Uint8Array;
+    readonly contentType: string;
+    static [Symbol.hasInstance](value: unknown): boolean;
+    constructor(content: Uint8Array | ArrayBuffer, contentType: string);
+}
+
+declare const HTTP_BODY_BRAND: unique symbol;
+declare class HttpBody {
+    readonly [HTTP_BODY_BRAND] = true;
+    readonly content: Uint8Array;
+    readonly contentType?: string;
+    static [Symbol.hasInstance](value: unknown): boolean;
+    constructor(content: Uint8Array | ArrayBuffer, contentType?: string);
+    text(encoding?: string): string;
+    json<T = unknown>(): T;
+}
+
+type JSONSchema = Record<string, unknown>;
+declare const TYPE: unique symbol;
+interface Schema<T> {
+    readonly jsonSchema: JSONSchema;
+    readonly [TYPE]?: T;
+    readonly _file?: boolean;
+    readonly _httpBody?: boolean;
+}
+type Infer<S extends Schema<unknown>> = S extends Schema<infer T> ? T : never;
+interface ParameterOptions<T> {
+    description?: string;
+    optional?: boolean;
+    default?: T;
+}
+interface Parameter<T> {
+    readonly name: string;
+    readonly schema: Schema<T>;
+    readonly description?: string;
+    readonly required: boolean;
+    readonly hasDefault: boolean;
+    readonly defaultValue?: T;
+}
+type ParameterValues<P extends readonly Parameter<unknown>[]> = {
+    [K in keyof P]: P[K] extends Parameter<infer T> ? T : never;
+};
+declare function parameter<T>(name: string, valueSchema: Schema<T>, options?: ParameterOptions<T>): Parameter<T>;
+declare const schema: {
+    /** Any JSON-serializable value. Useful when strict runtime validation is not needed. */
+    json: <T = unknown>() => Schema<T>;
+    string: (options?: Omit<JSONSchema, "type">) => Schema<string>;
+    number: (options?: Omit<JSONSchema, "type">) => Schema<number>;
+    integer: (options?: Omit<JSONSchema, "type">) => Schema<number>;
+    boolean: () => Schema<boolean>;
+    null: () => Schema<null>;
+    literal: <T extends string | number | boolean | null>(value: T) => Schema<T>;
+    enum: <const T extends readonly (string | number)[]>(values: T) => Schema<T[number]>;
+    array: <S extends Schema<unknown>>(item: S, options?: Omit<JSONSchema, "type" | "items">) => Schema<Infer<S>[]>;
+    tuple: <const S extends readonly Schema<unknown>[]>(items: S) => Schema<{ [K in keyof S]: S[K] extends Schema<infer T> ? T : never; }>;
+    record: <S extends Schema<unknown>>(value: S) => Schema<Record<string, Infer<S>>>;
+    object: <const P extends Record<string, Schema<unknown>>>(properties: P) => Schema<{ [K in keyof P]: P[K] extends Schema<infer T> ? T : never; }>;
+    union: <const S extends readonly Schema<unknown>[]>(...choices: S) => Schema<Infer<S[number]>>;
+    nullable: <S extends Schema<unknown>>(value: S) => Schema<Infer<S> | null>;
+    file: () => Schema<File>;
+    httpBody: () => Schema<HttpBody>;
+    custom: <T>(jsonSchema: JSONSchema) => Schema<T>;
+    parameter: typeof parameter;
+};
+
+interface Retries {
+    maxRetries: number;
+}
+declare function retries(options: Retries): Retries;
+type Region = "us-east-1" | "eu-west-1";
+type ApplicationCapability = "unauthenticated_requests";
+interface FunctionOptions<P extends readonly Parameter<unknown>[], R> {
+    name?: string;
+    parameters: P;
+    returns: Schema<R>;
+    description?: string;
+    cpu?: number;
+    memory?: number;
+    ephemeralDisk?: number;
+    gpu?: string | string[] | null;
+    timeout?: number;
+    image?: Image;
+    secrets?: string[];
+    retries?: Retries;
+    region?: Region;
+    warmContainers?: number;
+    minContainers?: number;
+    maxContainers?: number;
+}
+interface ApplicationOptions<P extends readonly Parameter<unknown>[], R> extends FunctionOptions<P, R> {
+    tags?: Record<string, string>;
+    applicationRetries?: Retries;
+    allow?: readonly ApplicationCapability[];
+}
+/** Options available when parameter and return schemas use the JSON defaults. */
+type SimpleFunctionOptions = Omit<FunctionOptions<readonly Parameter<unknown>[], unknown>, "name" | "parameters" | "returns">;
+/** Application options available when parameter and return schemas use the JSON defaults. */
+type SimpleApplicationOptions = Omit<ApplicationOptions<readonly Parameter<unknown>[], unknown>, "name" | "parameters" | "returns">;
+interface NormalizedFunctionOptions {
+    description: string;
+    cpu: number;
+    memory: number;
+    ephemeralDisk: number;
+    gpu: string | string[] | null;
+    timeout: number;
+    image?: Image;
+    secrets: string[];
+    retries?: Retries;
+    region?: Region;
+    warmContainers?: number;
+    minContainers?: number;
+    maxContainers?: number;
+}
+interface ApplicationConfiguration {
+    tags: Record<string, string>;
+    retries: Retries;
+    allow: ApplicationCapability[];
+    version: string;
+}
+interface RegisteredDefinition {
+    readonly name: string;
+    readonly handler: (...args: unknown[]) => Promise<unknown>;
+    readonly parameters: readonly Parameter<unknown>[];
+    readonly returns: Schema<unknown>;
+    readonly options: NormalizedFunctionOptions;
+    readonly application?: ApplicationConfiguration;
+}
+declare const TAIL_CALL_BRAND: unique symbol;
+interface TailCall<T> {
+    readonly [TAIL_CALL_BRAND]: true;
+    readonly kind: "tensorlake-tail-call";
+    readonly definition: RegisteredDefinition;
+    readonly args: readonly unknown[];
+    readonly _result?: T;
+}
+interface WaitOptions {
+    timeout?: number;
+    returnWhen?: "all_completed" | "first_completed" | "first_failure";
+}
+interface WaitResult<T> {
+    done: FunctionFuture<T>[];
+    notDone: FunctionFuture<T>[];
+}
+declare class FunctionFuture<T> implements PromiseLike<T> {
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    readonly definition: RegisteredDefinition;
+    readonly args: readonly unknown[];
+    private promise?;
+    private startDelaySeconds;
+    private completionOrder?;
+    private failed;
+    exception?: unknown;
+    done: boolean;
+    constructor(definition: RegisteredDefinition, args: readonly unknown[]);
+    run(): this;
+    runLater(delaySeconds: number): this;
+    get delaySeconds(): number;
+    result(): Promise<T>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    static wait<T>(futures: FunctionFuture<T>[], options?: WaitOptions): Promise<WaitResult<T>>;
+    private static waitForFutures;
+}
+type Awaitable<T> = T | PromiseLike<T>;
+type AwaitableIterable<T> = Iterable<Awaitable<T>> | PromiseLike<Iterable<Awaitable<T>>>;
+interface RegisteredFunction<Args extends readonly unknown[], Result> {
+    (...args: Args): Promise<Result>;
+    readonly definition: RegisteredDefinition;
+    future(...args: Args): FunctionFuture<Result>;
+    map(items: AwaitableIterable<Args[0]>): Promise<Result[]>;
+    reduce(items: AwaitableIterable<Args[1]>, initial?: Args[0]): Promise<Result>;
+    tailCall(...args: Args): TailCall<Result>;
+}
+type SimpleResult<Output> = Output extends TailCall<infer Result> ? Result : Output;
+declare function registerFunction<const P extends readonly Parameter<unknown>[], Result>(handler: (...args: ParameterValues<P>) => Promise<Result | TailCall<Result>>, options: FunctionOptions<P, Result>): RegisteredFunction<ParameterValues<P>, Result>;
+declare function registerFunction<const Args extends readonly unknown[], Output>(name: string, handler: (...args: Args) => Promise<Output>, options?: SimpleFunctionOptions): RegisteredFunction<Args, SimpleResult<Output>>;
+declare function registerApplication<const P extends readonly Parameter<unknown>[], Result>(handler: (...args: ParameterValues<P>) => Promise<Result | TailCall<Result>>, options: ApplicationOptions<P, Result>): RegisteredFunction<ParameterValues<P>, Result>;
+declare function registerApplication<const Args extends readonly unknown[], Output>(name: string, handler: (...args: Args) => Promise<Output>, options?: SimpleApplicationOptions): RegisteredFunction<Args, SimpleResult<Output>>;
+
+type HeadersInit = Headers | Record<string, string> | Iterable<readonly [string, string]>;
+declare const HEADERS_BRAND: unique symbol;
+/** Immutable, case-insensitive application request headers. */
+declare class Headers implements Iterable<readonly [string, string]> {
+    #private;
+    readonly [HEADERS_BRAND] = true;
+    static [Symbol.hasInstance](value: unknown): boolean;
+    constructor(headers?: HeadersInit);
+    get(name: string): string | undefined;
+    getAll(name: string): readonly string[];
+    has(name: string): boolean;
+    entries(): IterableIterator<readonly [string, string]>;
+    [Symbol.iterator](): IterableIterator<readonly [string, string]>;
+}
+
+interface ProgressOptions {
+    message?: string;
+    attributes?: Record<string, string>;
+}
+interface RequestState {
+    set(key: string, value: unknown): Promise<void>;
+    get<T>(key: string, defaultValue?: T): Promise<T | undefined>;
+}
+interface RequestMetrics {
+    timer(name: string, value: number): Promise<void>;
+    counter(name: string, value?: number): Promise<void>;
+}
+interface FunctionProgress {
+    update(current: number, total: number, options?: ProgressOptions): Promise<void>;
+}
+interface RequestContextValue {
+    readonly requestId: string;
+    readonly headers: Headers;
+    readonly signal: AbortSignal;
+    readonly state: RequestState;
+    readonly metrics: RequestMetrics;
+    readonly progress: FunctionProgress;
+}
+declare class RequestContext {
+    static get(): RequestContextValue;
+}
+
+declare class LocalRequest<T> {
+    readonly id: string;
+    private readonly value;
+    private readonly cancelRequest;
+    constructor(id: string, value: Promise<T>, cancelRequest: (reason?: unknown) => void);
+    output(): Promise<T>;
+    cancel(reason?: unknown): void;
+}
+declare function runLocal<Args extends readonly unknown[], Result>(application: RegisteredFunction<Args, Result>, ...args: Args): Promise<LocalRequest<Result>>;
+
+declare const REMOTE_OPTIONS_BRAND: unique symbol;
+/** Explicitly marks client options when one or more application arguments are omitted. */
+interface RemoteOptions {
+    readonly [REMOTE_OPTIONS_BRAND]: true;
+    readonly clientOptions: CloudClientOptions;
+}
+type RemoteInvocation<Args extends readonly unknown[]> = [...Args] | [...Required<Args>, CloudClientOptions] | [...Partial<Args>, RemoteOptions];
+declare function remoteOptions(options?: CloudClientOptions): RemoteOptions;
+declare class RemoteRequest<T> {
+    readonly id: string;
+    private readonly applicationName;
+    private readonly client;
+    private readonly outputIsFile?;
+    constructor(id: string, applicationName: string, client: APIClient, outputIsFile?: boolean | undefined);
+    output(): Promise<T>;
+}
+declare function runRemote<Result = unknown>(application: string, ...args: unknown[]): Promise<RemoteRequest<Result>>;
+declare function runRemote<Args extends readonly unknown[], Result>(application: RegisteredFunction<Args, Result>, ...argsAndOptions: RemoteInvocation<Args>): Promise<RemoteRequest<Result>>;
+
+export { type ApplicationCapability as A, File as F, Headers as H, type Infer as I, type JSONSchema as J, LocalRequest as L, type Parameter as P, type RegisteredDefinition as R, type Schema as S, type TailCall as T, type WaitOptions as W, type ApplicationOptions as a, type FunctionOptions as b, FunctionFuture as c, type HeadersInit as d, HttpBody as e, type ParameterValues as f, type RegisteredFunction as g, type RemoteOptions as h, RemoteRequest as i, RequestContext as j, type RequestContextValue as k, type SimpleApplicationOptions as l, type SimpleFunctionOptions as m, type WaitResult as n, registerFunction as o, remoteOptions as p, retries as q, registerApplication as r, runLocal as s, runRemote as t, schema as u, APIClient as v };

package/dist/remote-dblFxKug.d.ts

@@ -0,0 +1,283 @@
+import { C as CloudClientOptions, A as ApplicationManifest, F as FileSystem, a as ApplicationSummary, R as RequestInput, b as RequestOutput, I as Image } from './sandbox-image-ChzWDeZy.js';
+
+declare class APIClient {
+    private readonly cloudClient;
+    private readonly filesystemOptions;
+    constructor(options?: CloudClientOptions);
+    close(): void;
+    upsertApplication(manifest: ApplicationManifest, codeZip: Uint8Array | ArrayBuffer | Blob | string, upgradeRunningRequests?: boolean): Promise<void>;
+    deleteApplication(applicationName: string): Promise<void>;
+    deleteSandboxImage(imageName: string): Promise<void>;
+    createFileSystem(name: string, description?: string, options?: {
+        organizationId?: string;
+        projectId?: string;
+        region?: string;
+    }): Promise<FileSystem>;
+    listFileSystems(_options?: {
+        organizationId?: string;
+        projectId?: string;
+    }): Promise<FileSystem[]>;
+    deleteFileSystem(fileSystemId: string, _options?: {
+        organizationId?: string;
+        projectId?: string;
+    }): Promise<void>;
+    applications(): Promise<ApplicationSummary[]>;
+    application(applicationName: string): Promise<ApplicationManifest>;
+    runRequest(applicationName: string, inputs: RequestInput[]): Promise<string>;
+    waitOnRequestCompletion(applicationName: string, requestId: string): Promise<void>;
+    requestOutput(applicationName: string, requestId: string): Promise<RequestOutput>;
+}
+
+declare const FILE_BRAND: unique symbol;
+declare class File {
+    readonly [FILE_BRAND] = true;
+    readonly content: Uint8Array;
+    readonly contentType: string;
+    static [Symbol.hasInstance](value: unknown): boolean;
+    constructor(content: Uint8Array | ArrayBuffer, contentType: string);
+}
+
+declare const HTTP_BODY_BRAND: unique symbol;
+declare class HttpBody {
+    readonly [HTTP_BODY_BRAND] = true;
+    readonly content: Uint8Array;
+    readonly contentType?: string;
+    static [Symbol.hasInstance](value: unknown): boolean;
+    constructor(content: Uint8Array | ArrayBuffer, contentType?: string);
+    text(encoding?: string): string;
+    json<T = unknown>(): T;
+}
+
+type JSONSchema = Record<string, unknown>;
+declare const TYPE: unique symbol;
+interface Schema<T> {
+    readonly jsonSchema: JSONSchema;
+    readonly [TYPE]?: T;
+    readonly _file?: boolean;
+    readonly _httpBody?: boolean;
+}
+type Infer<S extends Schema<unknown>> = S extends Schema<infer T> ? T : never;
+interface ParameterOptions<T> {
+    description?: string;
+    optional?: boolean;
+    default?: T;
+}
+interface Parameter<T> {
+    readonly name: string;
+    readonly schema: Schema<T>;
+    readonly description?: string;
+    readonly required: boolean;
+    readonly hasDefault: boolean;
+    readonly defaultValue?: T;
+}
+type ParameterValues<P extends readonly Parameter<unknown>[]> = {
+    [K in keyof P]: P[K] extends Parameter<infer T> ? T : never;
+};
+declare function parameter<T>(name: string, valueSchema: Schema<T>, options?: ParameterOptions<T>): Parameter<T>;
+declare const schema: {
+    /** Any JSON-serializable value. Useful when strict runtime validation is not needed. */
+    json: <T = unknown>() => Schema<T>;
+    string: (options?: Omit<JSONSchema, "type">) => Schema<string>;
+    number: (options?: Omit<JSONSchema, "type">) => Schema<number>;
+    integer: (options?: Omit<JSONSchema, "type">) => Schema<number>;
+    boolean: () => Schema<boolean>;
+    null: () => Schema<null>;
+    literal: <T extends string | number | boolean | null>(value: T) => Schema<T>;
+    enum: <const T extends readonly (string | number)[]>(values: T) => Schema<T[number]>;
+    array: <S extends Schema<unknown>>(item: S, options?: Omit<JSONSchema, "type" | "items">) => Schema<Infer<S>[]>;
+    tuple: <const S extends readonly Schema<unknown>[]>(items: S) => Schema<{ [K in keyof S]: S[K] extends Schema<infer T> ? T : never; }>;
+    record: <S extends Schema<unknown>>(value: S) => Schema<Record<string, Infer<S>>>;
+    object: <const P extends Record<string, Schema<unknown>>>(properties: P) => Schema<{ [K in keyof P]: P[K] extends Schema<infer T> ? T : never; }>;
+    union: <const S extends readonly Schema<unknown>[]>(...choices: S) => Schema<Infer<S[number]>>;
+    nullable: <S extends Schema<unknown>>(value: S) => Schema<Infer<S> | null>;
+    file: () => Schema<File>;
+    httpBody: () => Schema<HttpBody>;
+    custom: <T>(jsonSchema: JSONSchema) => Schema<T>;
+    parameter: typeof parameter;
+};
+
+interface Retries {
+    maxRetries: number;
+}
+declare function retries(options: Retries): Retries;
+type Region = "us-east-1" | "eu-west-1";
+type ApplicationCapability = "unauthenticated_requests";
+interface FunctionOptions<P extends readonly Parameter<unknown>[], R> {
+    name?: string;
+    parameters: P;
+    returns: Schema<R>;
+    description?: string;
+    cpu?: number;
+    memory?: number;
+    ephemeralDisk?: number;
+    gpu?: string | string[] | null;
+    timeout?: number;
+    image?: Image;
+    secrets?: string[];
+    retries?: Retries;
+    region?: Region;
+    warmContainers?: number;
+    minContainers?: number;
+    maxContainers?: number;
+}
+interface ApplicationOptions<P extends readonly Parameter<unknown>[], R> extends FunctionOptions<P, R> {
+    tags?: Record<string, string>;
+    applicationRetries?: Retries;
+    allow?: readonly ApplicationCapability[];
+}
+/** Options available when parameter and return schemas use the JSON defaults. */
+type SimpleFunctionOptions = Omit<FunctionOptions<readonly Parameter<unknown>[], unknown>, "name" | "parameters" | "returns">;
+/** Application options available when parameter and return schemas use the JSON defaults. */
+type SimpleApplicationOptions = Omit<ApplicationOptions<readonly Parameter<unknown>[], unknown>, "name" | "parameters" | "returns">;
+interface NormalizedFunctionOptions {
+    description: string;
+    cpu: number;
+    memory: number;
+    ephemeralDisk: number;
+    gpu: string | string[] | null;
+    timeout: number;
+    image?: Image;
+    secrets: string[];
+    retries?: Retries;
+    region?: Region;
+    warmContainers?: number;
+    minContainers?: number;
+    maxContainers?: number;
+}
+interface ApplicationConfiguration {
+    tags: Record<string, string>;
+    retries: Retries;
+    allow: ApplicationCapability[];
+    version: string;
+}
+interface RegisteredDefinition {
+    readonly name: string;
+    readonly handler: (...args: unknown[]) => Promise<unknown>;
+    readonly parameters: readonly Parameter<unknown>[];
+    readonly returns: Schema<unknown>;
+    readonly options: NormalizedFunctionOptions;
+    readonly application?: ApplicationConfiguration;
+}
+declare const TAIL_CALL_BRAND: unique symbol;
+interface TailCall<T> {
+    readonly [TAIL_CALL_BRAND]: true;
+    readonly kind: "tensorlake-tail-call";
+    readonly definition: RegisteredDefinition;
+    readonly args: readonly unknown[];
+    readonly _result?: T;
+}
+interface WaitOptions {
+    timeout?: number;
+    returnWhen?: "all_completed" | "first_completed" | "first_failure";
+}
+interface WaitResult<T> {
+    done: FunctionFuture<T>[];
+    notDone: FunctionFuture<T>[];
+}
+declare class FunctionFuture<T> implements PromiseLike<T> {
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    readonly definition: RegisteredDefinition;
+    readonly args: readonly unknown[];
+    private promise?;
+    private startDelaySeconds;
+    private completionOrder?;
+    private failed;
+    exception?: unknown;
+    done: boolean;
+    constructor(definition: RegisteredDefinition, args: readonly unknown[]);
+    run(): this;
+    runLater(delaySeconds: number): this;
+    get delaySeconds(): number;
+    result(): Promise<T>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    static wait<T>(futures: FunctionFuture<T>[], options?: WaitOptions): Promise<WaitResult<T>>;
+    private static waitForFutures;
+}
+type Awaitable<T> = T | PromiseLike<T>;
+type AwaitableIterable<T> = Iterable<Awaitable<T>> | PromiseLike<Iterable<Awaitable<T>>>;
+interface RegisteredFunction<Args extends readonly unknown[], Result> {
+    (...args: Args): Promise<Result>;
+    readonly definition: RegisteredDefinition;
+    future(...args: Args): FunctionFuture<Result>;
+    map(items: AwaitableIterable<Args[0]>): Promise<Result[]>;
+    reduce(items: AwaitableIterable<Args[1]>, initial?: Args[0]): Promise<Result>;
+    tailCall(...args: Args): TailCall<Result>;
+}
+type SimpleResult<Output> = Output extends TailCall<infer Result> ? Result : Output;
+declare function registerFunction<const P extends readonly Parameter<unknown>[], Result>(handler: (...args: ParameterValues<P>) => Promise<Result | TailCall<Result>>, options: FunctionOptions<P, Result>): RegisteredFunction<ParameterValues<P>, Result>;
+declare function registerFunction<const Args extends readonly unknown[], Output>(name: string, handler: (...args: Args) => Promise<Output>, options?: SimpleFunctionOptions): RegisteredFunction<Args, SimpleResult<Output>>;
+declare function registerApplication<const P extends readonly Parameter<unknown>[], Result>(handler: (...args: ParameterValues<P>) => Promise<Result | TailCall<Result>>, options: ApplicationOptions<P, Result>): RegisteredFunction<ParameterValues<P>, Result>;
+declare function registerApplication<const Args extends readonly unknown[], Output>(name: string, handler: (...args: Args) => Promise<Output>, options?: SimpleApplicationOptions): RegisteredFunction<Args, SimpleResult<Output>>;
+
+type HeadersInit = Headers | Record<string, string> | Iterable<readonly [string, string]>;
+declare const HEADERS_BRAND: unique symbol;
+/** Immutable, case-insensitive application request headers. */
+declare class Headers implements Iterable<readonly [string, string]> {
+    #private;
+    readonly [HEADERS_BRAND] = true;
+    static [Symbol.hasInstance](value: unknown): boolean;
+    constructor(headers?: HeadersInit);
+    get(name: string): string | undefined;
+    getAll(name: string): readonly string[];
+    has(name: string): boolean;
+    entries(): IterableIterator<readonly [string, string]>;
+    [Symbol.iterator](): IterableIterator<readonly [string, string]>;
+}
+
+interface ProgressOptions {
+    message?: string;
+    attributes?: Record<string, string>;
+}
+interface RequestState {
+    set(key: string, value: unknown): Promise<void>;
+    get<T>(key: string, defaultValue?: T): Promise<T | undefined>;
+}
+interface RequestMetrics {
+    timer(name: string, value: number): Promise<void>;
+    counter(name: string, value?: number): Promise<void>;
+}
+interface FunctionProgress {
+    update(current: number, total: number, options?: ProgressOptions): Promise<void>;
+}
+interface RequestContextValue {
+    readonly requestId: string;
+    readonly headers: Headers;
+    readonly signal: AbortSignal;
+    readonly state: RequestState;
+    readonly metrics: RequestMetrics;
+    readonly progress: FunctionProgress;
+}
+declare class RequestContext {
+    static get(): RequestContextValue;
+}
+
+declare class LocalRequest<T> {
+    readonly id: string;
+    private readonly value;
+    private readonly cancelRequest;
+    constructor(id: string, value: Promise<T>, cancelRequest: (reason?: unknown) => void);
+    output(): Promise<T>;
+    cancel(reason?: unknown): void;
+}
+declare function runLocal<Args extends readonly unknown[], Result>(application: RegisteredFunction<Args, Result>, ...args: Args): Promise<LocalRequest<Result>>;
+
+declare const REMOTE_OPTIONS_BRAND: unique symbol;
+/** Explicitly marks client options when one or more application arguments are omitted. */
+interface RemoteOptions {
+    readonly [REMOTE_OPTIONS_BRAND]: true;
+    readonly clientOptions: CloudClientOptions;
+}
+type RemoteInvocation<Args extends readonly unknown[]> = [...Args] | [...Required<Args>, CloudClientOptions] | [...Partial<Args>, RemoteOptions];
+declare function remoteOptions(options?: CloudClientOptions): RemoteOptions;
+declare class RemoteRequest<T> {
+    readonly id: string;
+    private readonly applicationName;
+    private readonly client;
+    private readonly outputIsFile?;
+    constructor(id: string, applicationName: string, client: APIClient, outputIsFile?: boolean | undefined);
+    output(): Promise<T>;
+}
+declare function runRemote<Result = unknown>(application: string, ...args: unknown[]): Promise<RemoteRequest<Result>>;
+declare function runRemote<Args extends readonly unknown[], Result>(application: RegisteredFunction<Args, Result>, ...argsAndOptions: RemoteInvocation<Args>): Promise<RemoteRequest<Result>>;
+
+export { type ApplicationCapability as A, File as F, Headers as H, type Infer as I, type JSONSchema as J, LocalRequest as L, type Parameter as P, type RegisteredDefinition as R, type Schema as S, type TailCall as T, type WaitOptions as W, type ApplicationOptions as a, type FunctionOptions as b, FunctionFuture as c, type HeadersInit as d, HttpBody as e, type ParameterValues as f, type RegisteredFunction as g, type RemoteOptions as h, RemoteRequest as i, RequestContext as j, type RequestContextValue as k, type SimpleApplicationOptions as l, type SimpleFunctionOptions as m, type WaitResult as n, registerFunction as o, remoteOptions as p, retries as q, registerApplication as r, runLocal as s, runRemote as t, schema as u, APIClient as v };