import { Observable, PathKey, GetAtPath } from '@noya-app/observable';
import { Emitter } from '@noya-app/emitter';
import { EncodedSchema, Asset, Input, OutputTransform, Resource, CreateResourceParametersWithoutAccessibleByFileId, UploadableAsset, DeleteResourceParameters, AssetMode, MediaMap } from '@noya-app/noya-schemas';
import { Cache, hash } from '@noya-app/noya-utils';
import { TaskSnapshot } from '@noya-app/task-runner';
import { TSchema, TObject, Static } from '@sinclair/typebox';
import { Patch, Draft } from 'mutative';
import * as _noya_app_noya_multiplayer_react from '@noya-app/noya-multiplayer-react';
import { ExtendedPatch as ExtendedPatch$1, AssetUploadProgress as AssetUploadProgress$1, ClientToServerMessage as ClientToServerMessage$1, ExtractRequestBody as ExtractRequestBody$1, ExtractResponseBody as ExtractResponseBody$1 } from '@noya-app/noya-multiplayer-react';
import * as _noya_app_noya_pipeline from '@noya-app/noya-pipeline';
import { PipelineState, RemoteEvaluateParameters, ParsedError, PipelineGraphAPI } from '@noya-app/noya-pipeline';
import { Operation } from 'mutative/dist/interface.js';
import { MenuItem } from '@noya-app/noya-designsystem';

type Secret = {
    id: string;
    stableId: string;
    name: string;
};
type SecretManagerOptions = {
    initialSecrets?: Secret[];
};
declare class SecretManager {
    rpcManager: RPCManager;
    constructor(rpcManager: RPCManager, options: SecretManagerOptions);
    secrets$: Observable<Secret[]>;
    isInitialized$: Observable<boolean>;
    fetchSecrets(): Promise<Secret[]>;
    createSecret(id: string | null, name: string, value: string): Promise<Secret>;
    deleteSecret(id: string): Promise<{
        status: 200;
        statusText: "OK";
        headers: {};
        body: _noya_app_noya_multiplayer_react.TypedBody<{
            success: true;
        }>;
    }>;
}

type SerializableRequest = {
    id?: string;
    url: string;
    streaming?: boolean;
    options: {
        method?: string;
        headers?: Record<string, string>;
        body?: string;
    };
};
type SerializableResponse = {
    id?: string;
    status: number;
    statusText: string;
    headers: Record<string, string>;
    body: string;
};
type TypedBody<T> = string & {
    __type?: T;
};
type RPCRequestPayload = {
    type: "fetch" | "streamingFetch";
    request: SerializableRequest;
};
type RPCResponsePayload = {
    type: "fetch";
    response: SerializableResponse;
};
type RPCSuccessResponse = {
    id: string;
    type: "rpcResponse";
    payload: RPCResponsePayload;
};
type RPCStreamChunkResponse = {
    id: string;
    type: "rpcStreamChunk";
    chunk: string;
};
type RPCStreamEndResponse = {
    id: string;
    type: "rpcStreamEnd";
    payload?: RPCResponsePayload;
};
type RPCErrorResponse = {
    id: string;
    type: "rpcResponse";
    error: any;
};
type UploadProgress = {
    loaded: number;
    total?: number;
    percent?: number;
};

type WorkspaceMemberUser = {
    id: string;
    name: string | null;
    email: string | null;
    image: string | null;
};
type BaseTranscriptionRequest = {
    fileName?: string;
    contentType?: string;
    endpoint?: string;
    apiKey?: string;
};
type TranscriptionRequest = BaseTranscriptionRequest & ({
    type: "data";
    data: string;
} | {
    type: "assetId";
    assetId: string;
});
type TranscriptionSegment = {
    id: number;
    seek: number;
    start: number;
    end: number;
    text: string;
    tokens: number[];
    temperature: number;
    avg_logprob: number;
    compression_ratio: number;
    no_speech_prob: number;
};
type TranscriptionMetadata = {
    filename?: string;
    originalSize?: number;
    originalSizeMB?: string;
    duration?: number;
    language?: string;
    processingTimeSeconds?: number;
    segmentCount?: number;
    [key: string]: unknown;
};
type TranscriptionResponse = {
    success: boolean;
    transcription: string;
    segments: TranscriptionSegment[];
    metadata: TranscriptionMetadata;
};
type AIGenerateImage = {
    type: "data";
    data: string;
    mediaType: string;
} | {
    type: "url";
    url: string;
};
type AISamplingOptions = {
    temperature?: number;
    topP?: number;
    topK?: number;
    presencePenalty?: number;
    frequencyPenalty?: number;
    seed?: number;
};
type AIGenerateRequest = AISamplingOptions & {
    prompt: string;
    system?: string;
    model?: string;
    schema: Record<string, unknown>;
    encodedSchema?: EncodedSchema;
    images?: AIGenerateImage[];
    stream?: true;
};
type AIGenerateResponse = {
    object: unknown;
};
type AIGenerateTextRequest = AISamplingOptions & {
    prompt: string;
    system?: string;
    model?: string;
    images?: AIGenerateImage[];
    stream?: true;
};
type AIGenerateTextResponse = {
    text: string;
};
type AIGenerationStreamEvent = {
    type: "text-delta";
    textDelta: string;
} | {
    type: "partial-object";
    object: unknown;
} | {
    type: "object";
    object: unknown;
} | {
    type: "text";
    text: string;
} | {
    type: "error";
    error: string;
};
type AIGenerateImageRequest = {
    prompt: string;
    model?: string;
};
type AIGenerateImageResponse = {
    base64: string;
    mediaType: string;
};
type ScriptEvaluatorFile = string | {
    content: string;
};
type ScriptEvaluatorRequestBase = {
    args?: unknown[];
    env?: Record<string, string>;
    secrets?: Record<string, string>;
    includeFileEnv?: boolean;
};
type ScriptEvaluatorRequest = ScriptEvaluatorRequestBase & ({
    type: "code";
    code: string;
} | {
    type: "url";
    url: string;
    cid?: string;
} | {
    type: "files";
    files: Record<string, ScriptEvaluatorFile>;
    entryPoint?: string;
});
type ScriptEvaluatorResponse = {
    status: "success";
    result: unknown;
    logs: unknown[][];
} | {
    status: "error";
    error: ParsedError;
    logs: unknown[][];
};
type ResourcePatchUpdateParameters = {
    id: string;
    path?: string;
    type?: Resource["type"];
    assetId?: string;
    asset?: UploadableAsset;
    fileId?: string;
    fileVersionId?: string;
    resourceId?: string;
};
type ResourcePatchRequestBody = {
    create?: CreateResourceParametersWithoutAccessibleByFileId[];
    update?: ResourcePatchUpdateParameters[];
    delete?: DeleteResourceParameters[];
};
type GitFileCreateOperation = {
    path: string;
    content: string;
};
type GitFileRenameOperation = {
    oldPath: string;
    newPath: string;
};
type GitFileDeleteOperation = {
    path: string;
};
type GitFilePatchRequestBody = {
    create?: GitFileCreateOperation[];
    rename?: GitFileRenameOperation[];
    delete?: GitFileDeleteOperation[];
};
type GitInitRepoRequestBody = {
    initialFiles?: GitFileCreateOperation[];
};
type GitFilePatchResponseBody = {
    oid: string;
    files: string[];
    ref: string;
    /** Present when includeContent query param is true */
    fileContents?: GitFileInfo[];
};
type GitFileInfo = {
    path: string;
    /** Base64-encoded file content */
    content: string;
};
type GitListFilesResponseBody = {
    files: string[];
    ref: string;
    oid: string;
    /** Present when includeContent query param is true */
    fileContents?: GitFileInfo[];
};
type RouteDefinition<TRequest extends SerializableRequest, TResponse extends SerializableResponse, TSearchParams extends Record<string, string | undefined> = Record<string, never>> = {
    request: TRequest;
    response: TResponse;
    searchParams: TSearchParams;
};
type Routes = {
    "GET /api/assets": RouteDefinition<{
        url: "/api/assets";
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<Asset[]>;
    }>;
    "POST /api/assets": RouteDefinition<{
        url: "/api/assets";
        options: {
            method: "POST";
            headers?: {
                "Content-Type"?: string;
            };
            body: TypedBody<Uint8Array>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<Asset>;
    }, {
        mode?: "immutable" | "mutable";
    }>;
    "PUT /api/assets/:id": RouteDefinition<{
        url: `/api/assets/${string}`;
        options: {
            method: "PUT";
            headers?: {
                "Content-Type"?: string;
            };
            body: TypedBody<Uint8Array>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<Asset>;
    }>;
    "DELETE /api/assets/:id": RouteDefinition<{
        url: `/api/assets/${string}`;
        options: {
            method: "DELETE";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<{
            success: true;
        }>;
    }>;
    "GET /api/secrets": RouteDefinition<{
        url: "/api/secrets";
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<Secret[]>;
    }>;
    "POST /api/secrets": RouteDefinition<{
        url: "/api/secrets";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<{
                name: string;
                value: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<Secret>;
    }>;
    "DELETE /api/secrets": RouteDefinition<{
        url: "/api/secrets";
        options: {
            method: "DELETE";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<{
                name: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<{
            success: true;
        }>;
    }>;
    "PUT /api/file": RouteDefinition<{
        url: "/api/file";
        options: {
            method: "PUT";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<{
                name: string;
                changeId?: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<{
            name: string;
            changeId?: string;
        }>;
    }>;
    "GET /api/file/members": RouteDefinition<{
        url: "/api/file/members";
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<WorkspaceMemberUser[]>;
    }>;
    "POST /api/runWorkflow": RouteDefinition<{
        url: "/api/runWorkflow";
        options: {
            method: "POST";
        };
        body: TypedBody<{
            pipelineState?: PipelineState;
        }>;
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<{
            result: any;
            snapshot: any;
        }>;
    }>;
    "POST /api/transcriptions": RouteDefinition<{
        url: "/api/transcriptions";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<TranscriptionRequest>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<TranscriptionResponse>;
    }>;
    "POST /api/evaluate": RouteDefinition<{
        url: "/api/evaluate";
        options: {
            method: "POST";
            body: TypedBody<RemoteEvaluateParameters>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<{
            result: any;
        }>;
    }>;
    "POST /api/scripts/evaluate": RouteDefinition<{
        url: "/api/scripts/evaluate";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<ScriptEvaluatorRequest>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<ScriptEvaluatorResponse>;
    }>;
    "POST /api/ai": RouteDefinition<{
        url: "/api/ai";
        streaming: true;
        options: {
            method: "POST";
            headers?: Record<string, string>;
            body?: string;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: string;
    }>;
    "POST /api/ai/generate": RouteDefinition<{
        url: "/api/ai/generate";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<AIGenerateRequest>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<AIGenerateResponse>;
    }>;
    "POST /api/ai/generate/text": RouteDefinition<{
        url: "/api/ai/generate/text";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<AIGenerateTextRequest>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<AIGenerateTextResponse>;
    }>;
    "POST /api/ai/generate/image": RouteDefinition<{
        url: "/api/ai/generate/image";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<AIGenerateImageRequest>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<AIGenerateImageResponse>;
    }>;
    "GET /api/inputs": RouteDefinition<{
        url: "/api/inputs";
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<Input[]>;
    }>;
    "GET /api/outputTransforms": RouteDefinition<{
        url: "/api/outputTransforms";
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<OutputTransform[]>;
    }>;
    "POST /api/inputs": RouteDefinition<{
        url: "/api/inputs";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<Partial<Input> & {
                id?: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<Input>;
    }>;
    "PATCH /api/inputs": RouteDefinition<{
        url: "/api/inputs";
        options: {
            method: "PATCH";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<ExtendedPatch$1[]>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<Input[]>;
    }>;
    "POST /api/outputTransforms": RouteDefinition<{
        url: "/api/outputTransforms";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<Partial<OutputTransform> & {
                id?: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<OutputTransform>;
    }>;
    "DELETE /api/inputs": RouteDefinition<{
        url: `/api/inputs`;
        options: {
            method: "DELETE";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<{
                id: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<{
            success: true;
        }>;
    }>;
    "DELETE /api/outputTransforms": RouteDefinition<{
        url: `/api/outputTransforms`;
        options: {
            method: "DELETE";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<{
                id: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<{
            success: true;
        }>;
    }>;
    "PATCH /api/outputTransforms": RouteDefinition<{
        url: "/api/outputTransforms";
        options: {
            method: "PATCH";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<ExtendedPatch$1[]>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<OutputTransform[]>;
    }>;
    "GET /api/resources": RouteDefinition<{
        url: "/api/resources";
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<Resource[]>;
    }>;
    "PATCH /api/resources": RouteDefinition<{
        url: "/api/resources";
        options: {
            method: "PATCH";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<ResourcePatchRequestBody>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<{
            created: Resource[];
            updated: Resource[];
            deleted: Resource[];
        }>;
    }>;
    "POST /api/snapshots/restore": RouteDefinition<{
        url: "/api/snapshots/restore";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<{
                fileId: string;
                fileVersionId: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {};
        body: TypedBody<unknown>;
    }>;
    "POST /api/git/repos": RouteDefinition<{
        url: "/api/git/repos";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body?: TypedBody<GitInitRepoRequestBody>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<{
            id: string;
        }>;
    }>;
    "GET /api/git/repos/:id/files": RouteDefinition<{
        url: `/api/git/repos/${string}/files`;
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<GitListFilesResponseBody>;
    }, {
        ref?: string;
        includeContent?: string;
    }>;
    "GET /api/git/repos/:id/branches": RouteDefinition<{
        url: `/api/git/repos/${string}/branches`;
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<{
            branches: Array<{
                name: string;
                oid: string;
            }>;
        }>;
    }>;
    "PATCH /api/git/repos/:id/files": RouteDefinition<{
        url: `/api/git/repos/${string}/files`;
        options: {
            method: "PATCH";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<GitFilePatchRequestBody>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<GitFilePatchResponseBody>;
    }, {
        ref?: string;
        includeContent?: string;
    }>;
    "GET /api/sandbox/files": RouteDefinition<{
        url: "/api/sandbox/files";
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<{
            files: Array<{
                name: string;
                path: string;
                type: "file" | "directory";
            }>;
            error?: string;
        }>;
    }>;
    "POST /api/sandbox/preview": RouteDefinition<{
        url: "/api/sandbox/preview";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<{
            previewUrl?: string;
            error?: string;
        }>;
    }>;
    "POST /api/sandbox/exec": RouteDefinition<{
        url: "/api/sandbox/exec";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body: TypedBody<{
                command: string;
                cwd?: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<{
            success: boolean;
            stdout: string;
            stderr: string;
            exitCode: number;
        }>;
    }>;
    "GET /api/sandbox/build-files": RouteDefinition<{
        url: "/api/sandbox/build-files";
        options: {
            method: "GET";
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<{
            success: boolean;
            zip?: string;
            error?: string;
        }>;
    }>;
    "POST /api/sandbox/checkpoint": RouteDefinition<{
        url: "/api/sandbox/checkpoint";
        options: {
            method: "POST";
            headers: {
                "Content-Type": "application/json";
            };
            body?: TypedBody<{
                message?: string;
            }>;
        };
    }, {
        status: 200;
        statusText: "OK";
        headers: {
            "Content-Type": "application/json";
        };
        body: TypedBody<{
            success: boolean;
            error?: string;
        }>;
    }>;
};
type RouteKey$1 = keyof Routes;
type ExtractRequestBody<K extends RouteKey$1> = Routes[K]["request"]["options"] extends {
    body: TypedBody<infer T>;
} ? T : Routes[K]["request"]["options"] extends {
    body?: TypedBody<infer T>;
} ? T | undefined : string;
type ExtractResponseBody<K extends RouteKey$1> = Routes[K]["response"]["body"] extends TypedBody<infer T> ? T : never;
type ExtractSearchParams<K extends RouteKey$1> = Routes[K]["searchParams"];

type RPCStatus = "pending" | "resolved" | "rejected" | "streaming";
type RPCResponseMessage = {
    id: string;
} & ({
    type: "end";
    response: SerializableResponse;
} | {
    type: "chunk";
    chunk: string;
} | {
    type: "error";
    error: any;
});
type RequestOptions<TSearchParams extends Record<string, string> = Record<string, never>> = {
    headers?: Record<string, string>;
    body?: string;
    searchParams?: Partial<TSearchParams>;
    onUploadProgress?: (progress: UploadProgress) => void;
};
type StreamingHandlers = {
    onStreamChunk?: (chunk: string) => void;
    onStreamEnd?: () => Promise<void>;
};
type RouteKey = keyof Routes;
declare class RPCManager extends Emitter<[SerializableRequest]> {
    debug: boolean;
    constructor(options?: {
        isConnected?: boolean;
        debug?: boolean;
    });
    isConnected$: Observable<boolean>;
    setIsConnected(connected: boolean): void;
    requests: Record<string, {
        request: SerializableRequest;
        status: RPCStatus;
        resolve: (response: SerializableResponse) => void;
        reject: (reason: any) => void;
        onStreamChunk?: (chunk: string) => void;
        onStreamEnd?: () => Promise<void>;
        onUploadProgress?: (progress: UploadProgress) => void;
    }>;
    request: <K extends keyof Routes>(request: Routes[K]["request"], options?: RequestOptions & StreamingHandlers & {
        streaming?: boolean;
    }) => Promise<Routes[K]["response"]>;
    requestRoute: <K extends RouteKey>(route: K, { body, headers, searchParams, onUploadProgress }?: RequestOptions<ExtractSearchParams<K>>) => Promise<Routes[K]["response"]>;
    requestStreamingRoute: <K extends RouteKey>(route: K, { body, headers, onStreamChunk, onStreamEnd, }: RequestOptions & StreamingHandlers) => Promise<Routes[K]["response"]>;
    handleMessage: (message: RPCResponseMessage) => void;
    getResponseBody: <R extends {
        body: TypedBody<any>;
        headers: Record<string, string>;
    }>(response: R) => NonNullable<R["body"]["__type"]>;
}

/** Helper type that preserves all properties and their requirements except for id */
type CreateParams<T extends {
    id: string;
}> = Omit<T, "id" | "stableId"> | (Partial<T> & {
    id?: string;
    stableId?: string;
});
declare class IOManager {
    rpcManager: RPCManager;
    constructor(rpcManager: RPCManager);
    inputs$: Observable<({
        id: string;
        name: string;
        stableId: string;
        kind: "file";
        required: boolean;
        toolId: string | null;
        description: string | null;
    } | {
        id: string;
        name: string;
        stableId: string;
        schema: {
            default?: string | undefined;
            type: "string";
            _kind: "String";
        } | {
            default?: number | undefined;
            minimum?: number | undefined;
            maximum?: number | undefined;
            type: "number";
            _kind: "Number";
        } | {
            default?: boolean | undefined;
            type: "boolean";
            _kind: "Boolean";
        } | {
            type: "null";
            _kind: "Null";
        } | {
            type: "array";
            _kind: "Array";
            items: {
                default?: string | undefined;
                type: "string";
                _kind: "String";
            } | {
                default?: number | undefined;
                minimum?: number | undefined;
                maximum?: number | undefined;
                type: "number";
                _kind: "Number";
            } | {
                default?: boolean | undefined;
                type: "boolean";
                _kind: "Boolean";
            } | {
                type: "null";
                _kind: "Null";
            } | any | {
                required?: string[] | undefined;
                type: "object";
                properties: {
                    [x: string]: {
                        default?: string | undefined;
                        type: "string";
                        _kind: "String";
                    } | {
                        default?: number | undefined;
                        minimum?: number | undefined;
                        maximum?: number | undefined;
                        type: "number";
                        _kind: "Number";
                    } | {
                        default?: boolean | undefined;
                        type: "boolean";
                        _kind: "Boolean";
                    } | {
                        type: "null";
                        _kind: "Null";
                    } | any | any | {
                        type?: "string" | "number" | "boolean" | "null" | undefined;
                        _kind: "Literal";
                        const: string | number | boolean | null;
                    } | {
                        default?: any;
                        discriminator?: string | undefined;
                        _kind: "Union";
                        anyOf: ({
                            default?: string | undefined;
                            type: "string";
                            _kind: "String";
                        } | {
                            default?: number | undefined;
                            minimum?: number | undefined;
                            maximum?: number | undefined;
                            type: "number";
                            _kind: "Number";
                        } | {
                            default?: boolean | undefined;
                            type: "boolean";
                            _kind: "Boolean";
                        } | {
                            type: "null";
                            _kind: "Null";
                        } | any | any | {
                            type?: "string" | "number" | "boolean" | "null" | undefined;
                            _kind: "Literal";
                            const: string | number | boolean | null;
                        } | any)[];
                    };
                };
                _kind: "Object";
            } | {
                type?: "string" | "number" | "boolean" | "null" | undefined;
                _kind: "Literal";
                const: string | number | boolean | null;
            } | {
                default?: any;
                discriminator?: string | undefined;
                _kind: "Union";
                anyOf: ({
                    default?: string | undefined;
                    type: "string";
                    _kind: "String";
                } | {
                    default?: number | undefined;
                    minimum?: number | undefined;
                    maximum?: number | undefined;
                    type: "number";
                    _kind: "Number";
                } | {
                    default?: boolean | undefined;
                    type: "boolean";
                    _kind: "Boolean";
                } | {
                    type: "null";
                    _kind: "Null";
                } | any | any | {
                    type?: "string" | "number" | "boolean" | "null" | undefined;
                    _kind: "Literal";
                    const: string | number | boolean | null;
                } | any)[];
            };
        } | {
            required?: string[] | undefined;
            type: "object";
            properties: {
                [x: string]: {
                    default?: string | undefined;
                    type: "string";
                    _kind: "String";
                } | {
                    default?: number | undefined;
                    minimum?: number | undefined;
                    maximum?: number | undefined;
                    type: "number";
                    _kind: "Number";
                } | {
                    default?: boolean | undefined;
                    type: "boolean";
                    _kind: "Boolean";
                } | {
                    type: "null";
                    _kind: "Null";
                } | any | any | {
                    type?: "string" | "number" | "boolean" | "null" | undefined;
                    _kind: "Literal";
                    const: string | number | boolean | null;
                } | {
                    default?: any;
                    discriminator?: string | undefined;
                    _kind: "Union";
                    anyOf: ({
                        default?: string | undefined;
                        type: "string";
                        _kind: "String";
                    } | {
                        default?: number | undefined;
                        minimum?: number | undefined;
                        maximum?: number | undefined;
                        type: "number";
                        _kind: "Number";
                    } | {
                        default?: boolean | undefined;
                        type: "boolean";
                        _kind: "Boolean";
                    } | {
                        type: "null";
                        _kind: "Null";
                    } | any | any | {
                        type?: "string" | "number" | "boolean" | "null" | undefined;
                        _kind: "Literal";
                        const: string | number | boolean | null;
                    } | any)[];
                };
            };
            _kind: "Object";
        } | {
            type?: "string" | "number" | "boolean" | "null" | undefined;
            _kind: "Literal";
            const: string | number | boolean | null;
        } | {
            default?: any;
            discriminator?: string | undefined;
            _kind: "Union";
            anyOf: ({
                default?: string | undefined;
                type: "string";
                _kind: "String";
            } | {
                default?: number | undefined;
                minimum?: number | undefined;
                maximum?: number | undefined;
                type: "number";
                _kind: "Number";
            } | {
                default?: boolean | undefined;
                type: "boolean";
                _kind: "Boolean";
            } | {
                type: "null";
                _kind: "Null";
            } | any | any | {
                type?: "string" | "number" | "boolean" | "null" | undefined;
                _kind: "Literal";
                const: string | number | boolean | null;
            } | any)[];
        } | null;
        kind: "data";
        required: boolean;
        description: string | null;
    } | {
        authProvider?: "github" | "figma" | null | undefined;
        authScope?: string | null | undefined;
        id: string;
        name: string;
        stableId: string;
        kind: "secret";
        required: boolean;
        description: string | null;
    })[]>;
    outputTransforms$: Observable<({
        value: string;
        id: string;
        stableId: string;
        kind: "script";
        location: "url" | "state";
        order: number;
    } | {
        value: string;
        id: string;
        stableId: string;
        kind: "jsonPointer";
        order: number;
    })[]>;
    inputsInitialized$: Observable<boolean>;
    outputTransformsInitialized$: Observable<boolean>;
    isInitialized$: Observable<boolean>;
    fetchInputs(): Promise<Input[]>;
    fetchOutputTransforms(): Promise<OutputTransform[]>;
    createInput(input: CreateParams<Input>): Promise<Input>;
    createOutputTransform(outputTransform: CreateParams<OutputTransform>): Promise<OutputTransform>;
    deleteInput(id: string): Promise<{
        success: true;
    }>;
    deleteOutputTransform(id: string): Promise<{
        success: true;
    }>;
    applyInputPatches(patches: ExtendedPatch$1[]): Promise<Input[]>;
    applyOutputTransformPatches(patches: ExtendedPatch$1[]): Promise<OutputTransform[]>;
}

type ServerScriptLogLevel = "log" | "warn" | "error";
type ServerScriptLogEntry = {
    id: string;
    scriptId: string;
    level: ServerScriptLogLevel;
    values: unknown[];
    timestamp: number;
    origin?: string;
    target?: string;
    mode?: string;
};
type LogManagerOptions = {
    maxEntries?: number;
};
/**
 * Stores server script log entries emitted over the multiplayer channel.
 */
declare class LogManager {
    private options;
    logs$: Observable<ServerScriptLogEntry[]>;
    constructor(options?: LogManagerOptions);
    append(entry: ServerScriptLogEntry): void;
    appendMany(entries: ServerScriptLogEntry[]): void;
    clear(): void;
    private truncate;
}

declare function applyPatchToString(str: string, patch: SimplePatch): string;
declare function apply<S>(obj: S, patches: SimplePatch[]): any;
type SimplePatch = Patch<true> & {
    length?: number;
};
type SimplePatchWithStringPath = Patch<{
    pathAsArray: false;
}>;
type ExtendedPatch = {
    op: (typeof Operation)[keyof typeof Operation];
    value?: any;
    path: ExtendedPathKey[];
    from?: ExtendedPathKey[];
    length?: number;
};
type ExtendedPathKey = string | number | {
    id: string | number;
};
declare function extractItemId(item: unknown): string | number | undefined;
declare function toExtendedPathKey(obj: any, path: (string | number)[], type?: "insert"): ExtendedPathKey[];
declare function toSimplePath(obj: any, extendedPath: ExtendedPathKey[]): (string | number)[];
declare function toExtendedPatch(obj: any, patch: SimplePatch): ExtendedPatch;
declare function toSimplePatch(obj: any, patch: ExtendedPatch): SimplePatch;
declare function applyExtendedPatch<S>(obj: S, patches: ExtendedPatch[]): S;
declare function toExtendedPatches<S>(obj: S, patches: SimplePatch[]): ExtendedPatch[];
declare function createExtended<S>(obj: S, mutator: (state: Draft<S>) => void): readonly [S, ExtendedPatch[], ExtendedPatch[]];

type SandboxPhase = "idle" | "preparing" | "uploading" | "installing" | "starting" | "running" | "error";
type SandboxState = {
    status: SandboxPhase;
    sandboxId?: string;
    previewUrl?: string;
    devProcessId?: string;
    port?: number;
    installLogs: string;
    devLogs: string;
    lastUpdated: string;
    message?: string;
    error?: string;
};
declare const createInitialSandboxState: () => SandboxState;
type ExecResult = {
    success: boolean;
    stdout: string;
    stderr: string;
    exitCode: number;
};
declare class SandboxManager {
    private rpcManager;
    state$: Observable<SandboxState>;
    constructor(rpcManager: RPCManager);
    private setState;
    setFromServer: (next: SandboxState) => void;
    exec(command: string, cwd?: string): Promise<ExecResult>;
    listFiles(): Promise<{
        files: Array<{
            name: string;
            path: string;
            type: "file" | "directory";
        }>;
    }>;
    exposePreview(): Promise<{
        previewUrl?: string;
        error?: string;
    }>;
    getBuildFilesZip(): Promise<{
        success: boolean;
        zip?: string;
        error?: string;
    }>;
}

type AssetManagerOptions = {
    assetStore?: IAssetStore;
    initialAssets?: Asset[];
};
type AssetUploadProgress = UploadProgress & {
    id: string;
    name?: string;
    contentType?: string;
};
/**
 * AssetManager is an abstraction for managing assets.
 * It can be backed by IndexedDB, or a remote asset server.
 */
declare class AssetManager {
    isInitialized$: Observable<boolean>;
    assets$: Observable<{
        contentType?: string | undefined;
        mode?: "immutable" | "mutable" | undefined;
        version?: number | undefined;
        id: string;
        createdAt: string;
        stableId: string;
        url: string;
        size: number;
        width: number | null;
        height: number | null;
        userId: string | null;
    }[]>;
    uploads$: Observable<Record<string, AssetUploadProgress | undefined>>;
    _assetStore: IAssetStore;
    get assetStore(): IAssetStore;
    set assetStore(value: IAssetStore);
    constructor(options?: AssetManagerOptions);
    _toNoyaAsset: (asset: Asset) => NoyaAsset;
    /**
     * Handles external updates to the asset list
     *
     * Preserves signed urls for unchanged assets to improve browser caching.
     */
    set: (assets: Asset[]) => void;
    fetch: () => Promise<void>;
    _withUploadProgress: <T>(name: string | undefined, fn: (onUploadProgress: CreateAssetOptions["onUploadProgress"]) => Promise<T>) => Promise<T>;
    create: (options: CreateAssetOptions | Uint8Array | File | Blob) => Promise<NoyaAsset>;
    delete: (id: string) => Promise<NoyaAsset | undefined>;
    update: (id: string, options: UpdateAssetOptions | Uint8Array | File | Blob) => Promise<NoyaAsset>;
    read: (idOrStableId: string) => NoyaAsset | undefined;
    getAsset: (idOrStableId: string) => NoyaAsset | undefined;
    /**
     * Internal: get the server id for an asset when given a stableId or id.
     */
    _getServerAssetId: (idOrStableId: string) => string | undefined;
    getRealAssetId: (idOrStableId: string) => string | undefined;
}
type StoreAsset = {
    id: string;
    stableId: string;
    data: Uint8Array;
    createdAt: string;
    size: number;
    contentType?: string;
    width: number | null;
    height: number | null;
    userId: string | null;
    mode?: AssetMode;
    version?: number;
};
type CreateAssetOptions = {
    data: Uint8Array;
    contentType?: string;
    stableId?: string;
    mode?: AssetMode;
    onUploadProgress?: (progress: {
        loaded: number;
        total?: number;
        percent?: number;
    }) => void;
};
type UpdateAssetOptions = {
    data: Uint8Array;
    contentType?: string;
    onUploadProgress?: (progress: {
        loaded: number;
        total?: number;
        percent?: number;
    }) => void;
};
interface IAssetStore {
    read: (id: string) => Promise<Asset | null>;
    list: () => Promise<Asset[]>;
    create: (options: CreateAssetOptions) => Promise<Asset>;
    update?: (id: string, options: UpdateAssetOptions) => Promise<Asset>;
    delete: (id: string) => Promise<void>;
    _listWithBytes?: () => Promise<StoreAsset[]>;
}
type NoyaAsset = Omit<Asset, "stableId">;
type AssetManagerLocalOptions = {
    randomId?: () => string;
    databaseName?: string;
    indexedDB?: typeof globalThis.indexedDB;
};
/**
 * AssetManagerLocal is a local asset manager that uses IndexedDB to store assets.
 */
declare class AssetStoreIndexedDB implements IAssetStore {
    databaseName: string;
    randomId: () => string;
    db: Promise<IDBDatabase>;
    constructor(options?: AssetManagerLocalOptions);
    _initialize({ indexedDB, }?: {
        indexedDB?: typeof globalThis.indexedDB;
    } & Omit<AssetManagerLocalOptions, "db">): Promise<IDBDatabase>;
    read: (id: string) => Promise<Asset | null>;
    _readWithBytes: (id: string) => Promise<StoreAsset | null>;
    list: () => Promise<Asset[]>;
    _listWithBytes: () => Promise<StoreAsset[]>;
    create: (asset: CreateAssetOptions) => Promise<Asset>;
    update: (id: string, options: UpdateAssetOptions) => Promise<Asset>;
    delete: (id: string) => Promise<void>;
    _list: (db: IDBDatabase) => Promise<StoreAsset[]>;
    _urlCache: Map<string, string>;
    _getUrl: (id: string) => string;
    _createAssetUrl(asset: StoreAsset): void;
    _populateUrlCache(db: IDBDatabase): Promise<void>;
}
type AssetStoreMemoryOptions = {
    randomId?: () => string;
    initialAssets?: StoreAsset[];
};
declare class AssetStoreMemory implements IAssetStore {
    assets: StoreAsset[];
    randomId: () => string;
    constructor(options?: AssetStoreMemoryOptions);
    read: (id: string) => Promise<Asset | null>;
    list: () => Promise<Asset[]>;
    _listWithBytes: () => Promise<StoreAsset[]>;
    create: (asset: CreateAssetOptions) => Promise<Asset>;
    update: (id: string, options: UpdateAssetOptions) => Promise<Asset>;
    delete: (id: string) => Promise<void>;
    _urlCache: Map<string, string>;
    _getUrl: (id: string) => string;
    _createAssetUrl(asset: StoreAsset): void;
}
declare class AssetStoreRemote implements IAssetStore {
    private rpcManager;
    constructor(rpcManager: RPCManager);
    read: (id: string) => Promise<{
        contentType?: string | undefined;
        mode?: "immutable" | "mutable" | undefined;
        version?: number | undefined;
        id: string;
        createdAt: string;
        stableId: string;
        url: string;
        size: number;
        width: number | null;
        height: number | null;
        userId: string | null;
    } | null>;
    list: () => Promise<{
        contentType?: string | undefined;
        mode?: "immutable" | "mutable" | undefined;
        version?: number | undefined;
        id: string;
        createdAt: string;
        stableId: string;
        url: string;
        size: number;
        width: number | null;
        height: number | null;
        userId: string | null;
    }[]>;
    create: (options: CreateAssetOptions) => Promise<{
        contentType?: string | undefined;
        mode?: "immutable" | "mutable" | undefined;
        version?: number | undefined;
        id: string;
        createdAt: string;
        stableId: string;
        url: string;
        size: number;
        width: number | null;
        height: number | null;
        userId: string | null;
    }>;
    update: (id: string, options: UpdateAssetOptions) => Promise<{
        contentType?: string | undefined;
        mode?: "immutable" | "mutable" | undefined;
        version?: number | undefined;
        id: string;
        createdAt: string;
        stableId: string;
        url: string;
        size: number;
        width: number | null;
        height: number | null;
        userId: string | null;
    }>;
    delete: (id: string) => Promise<void>;
}

type AIToolDefinition = {
    functionName: string;
    description: string;
    parameters: Record<string, unknown>;
    onCall: (parameters: Record<string, unknown>) => Promise<string>;
};
type CallableAIToolsMap = Record<string, {
    description: string;
    parameters: Record<string, unknown>;
}>;
type AIToolInvocation = {
    id: string;
    name: string;
    parameters: Record<string, unknown>;
};
type AIImageInput = Blob | {
    data: Uint8Array;
    mediaType: string;
} | {
    url: string | URL;
};
type AIGenerateObjectOptions<Schema extends TObject> = AISamplingOptions & {
    prompt: string;
    schema: Schema;
    system?: string;
    images?: AIImageInput[];
    model?: string;
};
type AIGenerateTextOptions = AISamplingOptions & {
    prompt: string;
    system?: string;
    images?: AIImageInput[];
    model?: string;
};
type AIDeepPartial<T> = T extends readonly (infer Item)[] ? AIDeepPartial<Item>[] : T extends object ? {
    [Key in keyof T]?: AIDeepPartial<T[Key]>;
} : T;
type AIStreamObjectResult<Schema extends TObject> = {
    partialObjectStream: AsyncIterable<AIDeepPartial<Static<Schema>>>;
    object: Promise<Static<Schema>>;
};
type AIStreamTextResult = {
    textStream: AsyncIterable<string>;
    text: Promise<string>;
};
type AIGenerateImageOptions = {
    prompt: string;
    model?: string;
};
type AIGeneratedImage = {
    data: Uint8Array;
    mediaType: string;
};
declare class AIManager {
    rpcManager: RPCManager;
    invocationEmitter: Emitter<[AIToolInvocation]>;
    responseEmitter: Emitter<[AIToolInvocation, string | undefined]>;
    tools$: Observable<AIToolDefinition[]>;
    systemMessage$: Observable<string | undefined>;
    documentState$: Observable<unknown>;
    documentSchema$: Observable<TSchema | undefined>;
    callableTools$: Observable<CallableAIToolsMap>;
    configuration$: Observable<{
        tools: CallableAIToolsMap;
        systemMessage: string | undefined;
    }>;
    get callableTools(): CallableAIToolsMap;
    constructor(rpcManager: RPCManager);
    private createFetch;
    fetch: typeof globalThis.fetch;
    registerTool(tool: AIToolDefinition): () => void;
    unregisterTool(name: string): void;
    callTool(toolInvocation: AIToolInvocation): Promise<string> | undefined;
    private requestGenerationStream;
    generateObject<Schema extends TObject>(options: AIGenerateObjectOptions<Schema>): Promise<Static<Schema>>;
    streamObject<Schema extends TObject>(options: AIGenerateObjectOptions<Schema>): AIStreamObjectResult<Schema>;
    generateText(options: AIGenerateTextOptions): Promise<string>;
    streamText(options: AIGenerateTextOptions): AIStreamTextResult;
    generateImage({ prompt, model, }: AIGenerateImageOptions): Promise<AIGeneratedImage>;
}

declare class UserActivityDetector {
    onActivity?: (() => void) | undefined;
    constructor(onActivity?: (() => void) | undefined);
    private _activityHandler;
    private _visibilityHandler;
    addListeners(): void;
    removeListeners(): void;
    setOnActivity(callback?: () => void): void;
}
type ReconnectingWebSocketState = "CONNECTING" | "OPEN" | "CLOSING" | "CLOSED" | "RECONNECTING" | "MAX_ATTEMPTS_EXCEEDED" | "SHUTDOWN";
type ConnectionOptions = {
    reconnectInterval?: number;
    maxReconnectInterval?: number;
    reconnectDecay?: number;
    timeoutInterval?: number;
    maxReconnectAttempts?: number;
};
type ReconnectingWebSocketOptions = ConnectionOptions & {
    onopen?: (event: Event) => void;
    onmessage?: (event: MessageEvent) => void;
    onclose?: (event: CloseEvent) => void;
    onerror?: (event: Event) => void;
    activityDetector?: UserActivityDetector;
    debug?: boolean;
};
declare class ReconnectingWebSocket extends Emitter<[
    ReconnectingWebSocketState
]> {
    private websocket;
    private timeoutHandle;
    private reconnectTimeoutHandle;
    state: ReconnectingWebSocketState;
    private attempt;
    private options;
    private url;
    private protocols?;
    constructor(options?: ReconnectingWebSocketOptions);
    private transitionTo;
    connect(url?: string, protocols?: string | string[] | undefined): void;
    private onOpen;
    private onClosing;
    private onClosed;
    private onReconnecting;
    private onMaxAttemptsExceeded;
    private onShutdown;
    private reconnect;
    private resetAndReconnect;
    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
    close(): void;
    shutdown(): void;
}

type ConnectionEvent<S> = {
    type: "stateChange";
    state: ReconnectingWebSocketState;
} | {
    type: "send";
    message: ClientToServerMessage<S>;
} | {
    type: "receive";
    message: ServerToClientMessage<S>;
} | {
    type: "error";
    error: MultiplayerStateManagerError;
};
declare class ConnectionEventManager<S> {
    options: {
        maxEvents?: number;
    };
    constructor(options?: {
        maxEvents?: number;
    });
    events$: Observable<ConnectionEvent<S>[]>;
    addEvent(event: ConnectionEvent<S>): void;
    getEvents(): ConnectionEvent<S>[];
}

type EvalRequest = {
    id: string;
    code: string;
};
type EvalResponse = {
    id: string;
    type: "error";
    error: string;
} | {
    id: string;
    type: "result";
    result: string;
};
type SafeEval = (code: string) => unknown;
declare class EvalManager {
    constructor(options: {
        safeEval?: SafeEval;
    });
    safeEval?: SafeEval;
    requestEmitter: Emitter<[EvalRequest]>;
    responseEmitter: Emitter<[EvalResponse]>;
    _evalRequests: Map<string, Promise<unknown>>;
    evaluate(code: string): Promise<unknown>;
}

type FilePropertyManagerOptions = {
    initialName?: string;
};
/**
 * Manages synchronization of the file name between the local client and
 * the multiplayer durable object.
 */
declare class FilePropertyManager {
    private rpcManager;
    name$: Observable<string | undefined>;
    private pendingChanges$;
    optimisticValue$: Observable<string | undefined>;
    isInitialized$: Observable<boolean>;
    isUpdating$: Observable<boolean>;
    constructor(rpcManager: RPCManager, options?: FilePropertyManagerOptions);
    setName(name: string): void;
    applyServerUpdate({ name, changeId }: {
        name: string;
        changeId?: string;
    }): void;
    /**
     * Optimistically update the file name and persist the change through the
     * durable object.
     */
    updateName: (name: string) => Promise<string>;
    acknowledgeNameChange(changeId: string): void;
    private removePendingChange;
}

type HostStorageRequest = {
    id: string;
    operation: "getItem";
    key: string;
} | {
    id: string;
    operation: "setItem";
    key: string;
    value: string;
} | {
    id: string;
    operation: "removeItem";
    key: string;
};
type HostStorageResponse = {
    id: string;
    type: "success";
    value?: string | null;
} | {
    id: string;
    type: "error";
    error: string;
};
declare class HostStorageManager {
    private sendRequest?;
    private pendingRequests;
    connect(sendRequest: (request: HostStorageRequest) => void): () => void;
    getItem(key: string): Promise<string | null>;
    setItem(key: string, value: string): Promise<void>;
    removeItem(key: string): Promise<void>;
    handleResponse(response: HostStorageResponse): void;
    private request;
}

type ImagePickerRequest = {
    id: string;
};
type ImagePickerResponse = {
    id: string;
    resourceStableId?: string;
};
declare class ImagePickerManager {
    requestEmitter: Emitter<[ImagePickerRequest]>;
    responseEmitter: Emitter<[ImagePickerResponse]>;
    isAvailable$: Observable<boolean>;
    setIsAvailable(isAvailable: boolean): void;
    pickImage(): Promise<string | undefined>;
    handleResponse(response: ImagePickerResponse): void;
}

declare class MenuManager<T extends string = string> extends Emitter<[T]> {
    leftMenuItems$: Observable<MenuItem<T>[]>;
    rightMenuItems$: Observable<MenuItem<T>[]>;
    allMenuItems$: Observable<MenuItem<T>[]>;
    getLeftMenuItems(): MenuItem<T>[];
    getRightMenuItems(): MenuItem<T>[];
    getAllMenuItems(): MenuItem<T>[];
    setLeftMenuItems(items: MenuItem<T>[]): void;
    setRightMenuItems(items: MenuItem<T>[]): void;
    showCommandPaletteEmitter: Emitter<[boolean]>;
}

type TaskArtifact = {
    name: string;
    size: number;
    url: string;
};
type TaskMetadata = {
    artifacts: TaskArtifact[];
};
declare class PipelineManager {
    rpcManager: RPCManager;
    constructor(rpcManager: RPCManager);
    status$: Observable<PipelineStatus>;
    tasks$: Observable<TaskSnapshot<TaskMetadata>[]>;
    result$: Observable<any>;
    run(parameters: RemoteEvaluateParameters): Promise<any>;
    runScript(scriptUrl: string, parameters: Pick<RemoteEvaluateParameters, "args" | "env">): Promise<any>;
    runScriptOnFileState(scriptUrl: string, state: unknown): Promise<any>;
    runPipeline(pipelineState?: PipelineState): Promise<{
        result: any;
        snapshot: any;
    }>;
    getPipelineGraphAPI(options: {
        getFileVersionData: PipelineGraphAPI["getFileVersionData"];
        getFileVersionInputs: PipelineGraphAPI["getFileVersionInputs"];
        getFileVersionTransforms: PipelineGraphAPI["getFileVersionTransforms"];
        getFileVersionIds: PipelineGraphAPI["getFileVersionIds"];
        getFileSecret: PipelineGraphAPI["getFileSecret"];
        getFileVersionAssets: PipelineGraphAPI["getFileVersionAssets"];
        getFileAssets: PipelineGraphAPI["getFileAssets"];
        createFileVersion: PipelineGraphAPI["createFileVersion"];
    } & ({
        executionEnvironment: "local";
    } | {
        executionEnvironment: "remote";
        baseUrl: string;
    })): PipelineGraphAPI;
    runPipelineLocally(pipelineState: PipelineState, options: Parameters<typeof this.getPipelineGraphAPI>[0]): Promise<{
        result: _noya_app_noya_pipeline.TaskResult;
        snapshot: TaskSnapshot<_noya_app_noya_pipeline.TaskMetadata>[];
        error?: undefined;
    } | {
        error: unknown;
        snapshot: TaskSnapshot<_noya_app_noya_pipeline.TaskMetadata>[];
        result?: undefined;
    }>;
}

type PublishCallback = () => Promise<MediaMap>;
declare class PublishingManager {
    enablePublishing$: Observable<boolean>;
    setPublishingEnabled(enabled: boolean): void;
    getFilesToPublish?: PublishCallback;
}

type GitFileEditServerMessage = Extract<ServerToClientMessage<any>, {
    type: "gitFileEdit.object";
}> | Extract<ServerToClientMessage<any>, {
    type: "gitFileEdit.acceptPatch";
}> | Extract<ServerToClientMessage<any>, {
    type: "gitFileEdit.rejectPatch";
}>;
type GitFileEditHandle = {
    repoId: string;
    filePath: string;
    ref: string;
    content$: Observable<string>;
    isInitialized$: Observable<boolean>;
    sendPatches: (patches: ExtendedPatch[], metadata?: {
        name?: string;
    }) => void;
    /** Set the content, automatically computing and sending patches from the current state */
    setState: (newContent: string, metadata?: {
        name?: string;
    }) => void;
    close: () => void;
};
declare class GitFileEditSession {
    options: {
        repoId: string;
        filePath: string;
        ref: string;
        sendMessage?: (message: ClientToServerMessage<any>) => void;
        onClose?: () => void;
    };
    private multiplayer;
    private unsubscribeMultiplayerMessages;
    private isOpen;
    constructor(options: {
        repoId: string;
        filePath: string;
        ref: string;
        sendMessage?: (message: ClientToServerMessage<any>) => void;
        onClose?: () => void;
    });
    getHandle(): GitFileEditHandle;
    open(): void;
    close(): void;
    private sendPatches;
    private setState;
    handleServerMessage(message: GitFileEditServerMessage): void;
    private flushOutgoingMessages;
    private translateOutgoingMessage;
    private translateIncomingMessage;
    private ensureMessageSubscription;
}

type GitFileCommittedMessage = Extract<ServerToClientMessage<any>, {
    type: "gitFileEdit.committed";
}>;
type GitRepo = NoyaAsset;
type BranchInfo = {
    name: string;
    oid: string;
};
type RepoFilesFetchState = "idle" | "loading" | "refreshing";
type RepoFilesState = {
    fetchState: RepoFilesFetchState;
    files: string[];
    ref: string;
    oid: string;
    branches: BranchInfo[];
    error?: string;
    /** Present when files were fetched with includeContent=true */
    fileContents?: GitFileInfo[];
    /** Whether content was included in the last fetch (used for background refresh) */
    includeContent?: boolean;
};
type GitManagerOptions = {
    sendMessage?: (message: ClientToServerMessage<any>) => void;
    subscribeConnectionEvents?: (handler: (event: ConnectionEvent<any>) => void) => () => void;
    includeContent?: boolean;
};
declare class GitManager {
    rpcManager: RPCManager;
    assetManager: AssetManager;
    repos$: Observable<GitRepo[]>;
    isInitialized$: Observable<boolean>;
    repoFiles$: Observable<Record<string, RepoFilesState>>;
    includeContent: boolean;
    constructor(rpcManager: RPCManager, assetManager: AssetManager, options?: GitManagerOptions);
    getRepoState$(repoId: string): Observable<RepoFilesState | undefined>;
    /**
     * Fetch files and branches for a specific repo at an optional ref.
     * Uses the instance's includeContent setting to determine whether to fetch file contents.
     */
    fetchRepoFiles(repoId: string, ref?: string): Promise<void>;
    /**
     * Refresh files for a repo in the background.
     * Sets fetchState to "refreshing" so the UI can show a subtle indicator
     * without replacing the file list with a loading spinner.
     */
    refreshRepoFiles(repoId: string, ref?: string): Promise<void>;
    /**
     * Initialize a new git repo by creating a mutable asset with git bundle content type.
     * Optionally accepts initial files to populate the repo.
     */
    initRepo(options?: GitInitRepoRequestBody): Promise<GitRepo>;
    /**
     * List all files in a git repo at an optional ref.
     * The repoId can be either the asset id or stableId.
     * Uses the instance's includeContent setting to determine whether to fetch file contents.
     */
    listFiles(repoId: string, ref?: string): Promise<GitListFilesResponseBody>;
    /**
     * List all branches in a git repo.
     * The repoId can be either the asset id or stableId.
     */
    listBranches(repoId: string): Promise<BranchInfo[]>;
    /**
     * Patch files in a git repo (create, rename, delete).
     * Creates a single commit with all the requested operations.
     * Uses the instance's includeContent setting to determine whether to include file contents in response.
     */
    patchFiles(repoId: string, patch: GitFilePatchRequestBody, ref?: string): Promise<GitFilePatchResponseBody>;
    _sendMessage?: (message: ClientToServerMessage<any>) => void;
    _unsubscribeConnectionEvents?: () => void;
    _editSessions: Map<string, GitFileEditSession>;
    _sessionSubscriptions: Map<string, () => void>;
    _autoFetchedRepos: Set<string>;
    _repoStateCache: Map<string, Observable<RepoFilesState | undefined>>;
    private _makeSessionKey;
    _handleConnectionEvent: (event: ConnectionEvent<any>) => void;
    openEditingHandle(repoId: string, filePath: string, ref: string): GitFileEditHandle;
    /**
     * Optimistically update a file's content in the repoFiles state.
     * This is called when a file edit session receives content updates.
     */
    private _updateFileContent;
}

type ResourceEditServerMessage = Extract<ServerToClientMessage<any>, {
    type: "resourceEdit.object";
}> | Extract<ServerToClientMessage<any>, {
    type: "resourceEdit.acceptPatch";
}> | Extract<ServerToClientMessage<any>, {
    type: "resourceEdit.rejectPatch";
}>;
type ResourceEditHandle = {
    resourceId: string;
    content$: Observable<string>;
    isInitialized$: Observable<boolean>;
    sendPatches: (patches: ExtendedPatch[], metadata?: {
        name?: string;
    }) => void;
    close: () => void;
};
declare class ResourceEditSession {
    options: {
        resourceId: string;
        sendMessage?: (message: ClientToServerMessage<any>) => void;
        onClose?: () => void;
    };
    private multiplayer;
    private unsubscribeMultiplayerMessages;
    private isOpen;
    constructor(options: {
        resourceId: string;
        sendMessage?: (message: ClientToServerMessage<any>) => void;
        onClose?: () => void;
    });
    getHandle(): ResourceEditHandle;
    open(): void;
    close(): void;
    private sendPatches;
    handleServerMessage(message: ResourceEditServerMessage): void;
    private flushOutgoingMessages;
    private translateOutgoingMessage;
    private translateIncomingMessage;
    private ensureMessageSubscription;
}

type ResourceManagerOptions = {
    initialResources?: Resource[];
    resourceUrlBase?: string;
    sendMessage?: (message: ClientToServerMessage$1<any>) => void;
    subscribeConnectionEvents?: (handler: (event: ConnectionEvent<any>) => void) => () => void;
    resolveAssetId?: (idOrStableId: string) => string;
};
declare class ResourceManager {
    rpcManager: RPCManager;
    isInitialized$: Observable<boolean>;
    resources$: Observable<({
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "asset";
        createdAt: string;
        stableId: string;
        assetId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "file";
        createdAt: string;
        fileId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "directory";
        createdAt: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "resource";
        createdAt: string;
        fileId: string;
        resourceId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    })[]>;
    patches$: Observable<{
        id: string;
        patches: ExtendedPatch$1[];
    }[]>;
    optimisticResources$: Observable<({
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "asset";
        createdAt: string;
        stableId: string;
        assetId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "file";
        createdAt: string;
        fileId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "directory";
        createdAt: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "resource";
        createdAt: string;
        fileId: string;
        resourceId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    })[]>;
    uploads$: Observable<Record<string, AssetUploadProgress$1 | undefined>>;
    constructor(rpcManager: RPCManager, options?: ResourceManagerOptions);
    setResources(resources: Resource[]): void;
    createResource<Result extends CreateResourceParametersWithoutAccessibleByFileId | CreateResourceParametersWithoutAccessibleByFileId[]>(parameters: Result): Promise<Result extends unknown[] ? Resource[] : Resource>;
    _withPatch<T>(patches: ExtendedPatch$1[], callback: () => Promise<T>): Promise<T>;
    deleteResource<Result extends DeleteResourceParameters | DeleteResourceParameters[]>(parameters: Result): Promise<Result extends unknown[] ? Resource[] : Resource>;
    patchResources({ create, update, delete: deleteParameters, }: ExtractRequestBody$1<"PATCH /api/resources">): Promise<ExtractResponseBody$1<"PATCH /api/resources">>;
    updateResource({ id, path, assetId, asset, type, fileId, fileVersionId, resourceId, }: {
        id: string;
        path?: string;
        assetId?: string;
        asset?: UploadableAsset;
        type?: Resource["type"];
        fileId?: string;
        fileVersionId?: string;
        resourceId?: string;
    }): Promise<{
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "asset";
        createdAt: string;
        stableId: string;
        assetId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "file";
        createdAt: string;
        fileId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "directory";
        createdAt: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "resource";
        createdAt: string;
        fileId: string;
        resourceId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    }>;
    listResources(): Promise<({
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "asset";
        createdAt: string;
        stableId: string;
        assetId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "file";
        createdAt: string;
        fileId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "directory";
        createdAt: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        file?: {
            id: string;
            toolId: string;
            tool: {
                theme?: any;
            };
        } | null | undefined;
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        transformUrl?: string | undefined;
        path: string;
        id: string;
        type: "resource";
        createdAt: string;
        fileId: string;
        resourceId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    })[]>;
    _sendMessage?: (message: ClientToServerMessage$1<any>) => void;
    _unsubscribeConnectionEvents?: () => void;
    _resolveAssetId?: (idOrStableId: string) => string;
    _resourceUrlBase?: string;
    _editSessions: Map<string, ResourceEditSession>;
    _handleConnectionEvent: (event: ConnectionEvent<any>) => void;
    openEditingHandle(resourceId: string): _noya_app_noya_multiplayer_react.ResourceEditHandle;
}
declare function getResourceTransformUrl(resource: Pick<Resource, "id" | "transformUrl">, { format, inputs, resourceUrlBase, }: {
    format: string;
    inputs?: Record<string, unknown>;
    resourceUrlBase?: string;
}): string;

type RequestOfType<Type extends ScriptEvaluatorRequest["type"]> = Omit<Extract<ScriptEvaluatorRequest, {
    type: Type;
}>, "type">;
type EvaluateScriptOptions = RequestOfType<"code">;
type EvaluateScriptUrlOptions = RequestOfType<"url">;
type EvaluateScriptFilesOptions = RequestOfType<"files">;
type ScriptEvaluationResult<Result> = {
    result: Result;
    logs: unknown[][];
};
declare class ScriptEvaluationError extends Error {
    evaluationError: ParsedError;
    logs: unknown[][];
    constructor(evaluationError: ParsedError, logs: unknown[][]);
}
declare class ScriptEvaluatorManager {
    private rpcManager;
    constructor(rpcManager: RPCManager);
    evaluateScript<Result = unknown>(options: EvaluateScriptOptions): Promise<ScriptEvaluationResult<Result>>;
    evaluateUrl<Result = unknown>(options: EvaluateScriptUrlOptions): Promise<ScriptEvaluationResult<Result>>;
    evaluateFiles<Result = unknown>(options: EvaluateScriptFilesOptions): Promise<ScriptEvaluationResult<Result>>;
    private evaluate;
}

type HistoryEntry<S, M> = {
    undo: (state: S) => S;
    redo: (state: S) => S;
    undoPatches?: ExtendedPatch[];
    redoPatches?: ExtendedPatch[];
    metadata: M;
};
type ActionHandler<S> = {
    run: (state: S) => S;
    undo: (state: S) => S;
};
type HistorySnapshot<S, M> = {
    version: number;
    history: HistoryEntry<S, M>[];
    historyIndex: number;
    canUndo: boolean;
    canRedo: boolean;
};
type StateManagerOptions<S, M = void> = {
    /**
     * By default, the state manager will ignore edits that don't change the state.
     * Set this to true to allow empty edits.
     */
    allowEmptyEdits?: boolean;
    /**
     * Merge two history entries into a single history entry.
     * Usually this means providing a name, timestamp, or other metadata, and
     * combining the undo/redo operations based on this metadata.
     */
    mergeHistoryEntries?: (parameters: {
        previous: HistoryEntry<S, M>;
        next: HistoryEntry<S, M>;
    }, stateManager: StateManager<S, M>) => HistoryEntry<S, M> | void;
    /**
     * Maximum number of history entries to retain.
     * When the limit is reached, older entries are discarded.
     */
    maxHistoryEntries?: number;
    /**
     * Schema to validate the state against.
     */
    schema?: TSchema;
};
declare function createEditHistoryEntry<S, M>(state: S, options: StateManagerOptions<S, M>, metadata: M, mutator: (draft: Draft<S>) => void): {
    state: S;
    historyEntry: Required<HistoryEntry<S, M>>;
} | undefined;
declare function createPatchHistoryEntry<S, M>(state: S, options: StateManagerOptions<S, M>, metadata: M, patches: ExtendedPatch[], inversePatches: ExtendedPatch[]): {
    state: S;
    historyEntry: Required<HistoryEntry<S, M>>;
} | undefined;
/**
 * A wrapper class that allows easily creating JSON patches.
 *
 * Supports methods for the following operations:
 * - 'add'
 * - 'remove'
 * - 'replace'
 * - 'move'
 */
declare class OperationManager<S> {
    state: S;
    constructor(state: S);
    patches: ExtendedPatch[];
    inversePatches: ExtendedPatch[];
    getState: () => S;
    get: <P extends string | PathKey[]>(path: P) => GetAtPath<S, P>;
    _replaceLastDashWithIndex: (exInv: ExtendedPatch, state: S, value: unknown) => void;
    set: <P extends string>(path: P | PathKey[], value: GetAtPath<S, P>) => void;
    /**
     * Alias for `set`
     */
    replace: <P extends string>(path: P | PathKey[], value: GetAtPath<S, P>) => void;
    /**
     * For objects, behaves like `set`.
     * For arrays, inserts the value instead of replacing an existing value.
     */
    add: <P extends string | PathKey[]>(path: P, value: GetAtPath<S, P>) => void;
    remove: <P extends string | PathKey[]>(path: P) => void;
    /**
     * Alias for `remove`
     */
    delete: <P extends string | PathKey[]>(path: P) => void;
    static getInverseMoveIndexes({ state, opFrom, opTo, }: {
        state?: any;
        opFrom: PathKey[];
        opTo: PathKey[];
    }): {
        invFrom: PathKey[];
        invTo: PathKey[];
    };
    move: <P extends string | PathKey[], F extends string | PathKey[]>(from: F, to: P) => void;
    editDraft: (mutator: (draft: Draft<S>) => void) => void;
}
declare class StateManager<S, M = void> extends Emitter {
    options: StateManagerOptions<S, M>;
    state: S;
    schema?: TSchema;
    version: number;
    history: HistoryEntry<S, M>[];
    historyIndex$: Observable<number>;
    get historyIndex(): number;
    set historyIndex(value: number);
    historyEmittor: Emitter<[]>;
    constructor(initialState: S, options?: StateManagerOptions<S, M>);
    _setState(newState: S): void;
    _setStateWithHistoryEntry(newState: S, historyEntry: HistoryEntry<S, M>, { shouldTypeCheck, }?: {
        shouldTypeCheck?: boolean;
    }): void;
    edit: (...args: M extends {} ? [metadata: M, mutator: (draft: Draft<S>) => void] : [mutator: (draft: Draft<S>) => void]) => void;
    operate: (...args: M extends {} ? [metadata: M, operator: (operationManager: OperationManager<S>) => void] : [operator: (operationManager: OperationManager<S>) => void]) => ExtendedPatch[] | undefined;
    performAction: (...args: M extends {} ? [metadata: M, handler: ActionHandler<S>] : [handler: ActionHandler<S>]) => void;
    canUndo: () => boolean;
    canUndo$: Observable<boolean>;
    canRedo: () => boolean;
    canRedo$: Observable<boolean>;
    undo: () => void;
    redo: () => void;
    getState(): S;
    getState<P extends string | PathKey[]>(path: P): GetAtPath<S, P>;
    clearHistory: () => void;
    replaceState: (newState: S) => void;
    /**
     * Replace the initial state of the state manager, effectively rebasing the history.
     *
     * Replaces the initial state with the new state then applies each redo up to the
     * current history index.
     */
    rebase: (newInitialState: S) => void;
    getStateAtHistoryIndex: (index: number) => S;
    _rewindToIndex: (index: number, f: (state: S) => S) => void;
    /**
     * Accept a patch to the base state, effectively rebasing the history.
     */
    acceptPatchesAtIndex: (index: number, patches: ExtendedPatch[], filterHistoryEntry?: (entry: HistoryEntry<S, M>, index: number) => boolean) => void;
    goToHistoryIndex: (index: number) => void;
    getHistorySnapshot: () => HistorySnapshot<S, M>;
    _createVersionMemoizer<F extends (...args: any[]) => any>(f: F): (...args: Parameters<F>) => ReturnType<F>;
}

type AvoidRect = {
    id: string;
    rect: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
};
/**
 * Messages sent from the embedded editor to the parent frame
 */
type EmbeddedToParentMessage<S> = {
    type: "multiplayer.ready";
} | {
    type: "multiplayer.message";
    payload: ClientToServerMessage<S>;
} | {
    type: "application.setMenuItems";
    payload: {
        menuItems: MenuItem<string>[];
        position: "left" | "right";
    };
} | {
    type: "application.showCommandPalette";
    payload: boolean;
} | {
    type: "application.pickImage";
    payload: ImagePickerRequest;
} | {
    type: "application.evaluate";
    payload: EvalRequest;
} | {
    type: "application.localStorage.request";
    payload: HostStorageRequest;
} | {
    type: "application.enablePublishing";
    payload: boolean;
} | {
    type: "application.publish";
    payload: {
        id: string;
        files: MediaMap;
    };
} | {
    type: "ai.setConfig";
    payload: {
        tools: CallableAIToolsMap;
        systemMessage?: string;
    };
} | {
    type: "ai.tool.response";
    payload: {
        invocation: AIToolInvocation;
        response?: string;
    };
} | {
    type: "ai.setContext";
    payload: {
        state: S;
        schema?: TSchema;
    };
} | {
    type: "rpc.request";
    payload: SerializableRequest;
};
/**
 * Messages sent from the parent frame to the embedded editor
 */
type ParentToEmbeddedMessage<S> = ConnectionMessage | RPCResponseMessage | ServerToClientMessage<S> | {
    type: "application.selectMenuItem";
    payload: {
        value: string;
    };
} | {
    type: "application.evaluate.result";
    payload: EvalResponse;
} | {
    type: "application.pickImage.result";
    payload: ImagePickerResponse;
} | {
    type: "application.localStorage.result";
    payload: HostStorageResponse;
} | {
    type: "application.requestPublish";
    payload: {
        id: string;
    };
} | {
    type: "ai.tool.call";
    payload: AIToolInvocation;
} | {
    type: "application.setAvoidRects";
    payload: {
        rects: AvoidRect[];
    };
};
/**
 * Interface for handling communication between parent frame and embedded editor
 */
interface ParentFrameMessageHandler<S> {
    /**
     * Send a message to the parent frame
     * @param message The message to send
     * @param origin The target origin
     */
    postMessage: (message: EmbeddedToParentMessage<S> | ParentToEmbeddedMessage<S>, origin: string) => void;
    /**
     * Add a listener for messages from the parent frame
     * @param handler The message handler function
     * @returns A cleanup function to remove the listener
     */
    addMessageListener: (handler: (event: MessageEvent<ParentToEmbeddedMessage<S>>) => void) => () => void;
}
/**
 * Default implementation of ParentFrameMessageHandler using window.parent
 */
declare function createDefaultMessageHandler<S>(): ParentFrameMessageHandler<S>;
/**
 * Type guard to check if a message is a valid ParentToEmbeddedMessage
 */
declare function isParentToEmbeddedMessage<S>(message: any): message is ParentToEmbeddedMessage<S>;
/**
 * Type guard to check if a message is a valid EmbeddedToParentMessage
 */
declare function isEmbeddedToParentMessage<S>(message: any): message is EmbeddedToParentMessage<S>;

type Task = {
    id: string;
    name: string;
    payload: any;
    status: "pending" | "done" | "error";
};

declare class TaskManager {
    options: {
        maxTasks?: number;
    };
    constructor(options?: {
        maxTasks?: number;
    });
    tasks$: Observable<Task[]>;
    setTasks(tasks: Task[]): void;
    getTasks(): Task[];
}

type BaseTranscribeOptions = {
    fileName?: string;
    contentType?: string;
    endpoint?: string;
    apiKey?: string;
};
type TranscribeOptions = BaseTranscribeOptions & ({
    data: Uint8Array;
} | {
    assetId: string;
});
type TranscriptionResult = ExtractResponseBody$1<"POST /api/transcriptions">;
type AssetTranscriptionResult = ({
    type: "success";
} & Omit<TranscriptionResult, "success">) | {
    type: "error";
    error: Error;
} | {
    type: "processing";
};
declare class TranscriptionManager {
    private rpcManager;
    private assetManager;
    constructor(rpcManager: RPCManager, assetManager: AssetManager);
    assetTranscriptions$: Observable<Record<string, AssetTranscriptionResult>>;
    getAssetTranscription$(assetId: string, options: BaseTranscribeOptions): Observable<AssetTranscriptionResult>;
    transcribe(options: TranscribeOptions): Promise<TranscriptionResult>;
}
type AssetResolverResult = {
    data: ArrayBufferLike;
    contentType?: string;
};
declare function requestTranscription(options: TranscriptionRequest & {
    endpoint: string;
}, { resolveAsset, }: {
    resolveAsset: (assetId: string) => Promise<AssetResolverResult | undefined>;
}): Promise<TranscriptionResult>;

declare function findNoyaUser(users: MultiplayerUser[], id: string): MultiplayerUser;
declare function findNoyaUser(users: MultiplayerUser[], id?: string): MultiplayerUser | undefined;
declare class UserManager {
    #private;
    private rpcManager?;
    constructor(rpcManager?: RPCManager | undefined);
    currentUserId$: Observable<string | undefined>;
    currentClientId$: Observable<string | undefined>;
    currentConnectionId$: Observable<string | undefined>;
    /**
     * Get the best id we have for the current user.
     * The user id (signed in) > client id (browser storage) > connection id (websocket connection)
     */
    currentId$: Observable<string | undefined>;
    allUsers$: Observable<MultiplayerUser[]>;
    connectedUsers$: Observable<MultiplayerUser[]>;
    connectedUsersCount$: Observable<number>;
    currentUser$: Observable<MultiplayerUser | undefined>;
    workspaceUsers$: Observable<WorkspaceMemberUser[]>;
    initializeWorkspaceUsers(): void;
    setCurrentUserId(userId: string | undefined): void;
    setCurrentConnectionId(connectionId: string | undefined): void;
    setAllUsers(users: MultiplayerUser[]): void;
    private fetchWorkspaceMembers;
}

type NoyaManagerOptions<S, M> = MultiplayerStateManagerOptions<S, M> & {
    initialAssets?: Asset[];
    initialSecrets?: Secret[];
    initialResources?: Resource[];
    resourceUrlBase?: string;
    initialFileName?: string;
    registerDefaultAITools?: boolean;
    safeEval?: SafeEval;
    /** Whether git operations should include base64-encoded file contents in responses */
    gitIncludeContent?: boolean;
};
declare function defaultMergeHistoryEntries<S, M extends MultiplayerPatchMetadata>({ previous, next, }: {
    previous: HistoryEntry<S, M>;
    next: HistoryEntry<S, M>;
}): HistoryEntry<S, M> | undefined;
declare class NoyaManager<S, M extends object = object, E extends object = object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>> {
    id: string;
    multiplayerStateManager: MultiplayerStateManager<S, M>;
    rpcManager: RPCManager;
    pipelineManager: PipelineManager;
    scriptEvaluatorManager: ScriptEvaluatorManager;
    secretManager: SecretManager;
    aiManager: AIManager;
    ioManager: IOManager;
    imagePickerManager: ImagePickerManager;
    hostStorageManager: HostStorageManager;
    sharedConnectionDataManager: SharedConnectionDataManager<E>;
    assetManager: AssetManager;
    userManager: UserManager;
    taskManager: TaskManager;
    connectionEventManager: ConnectionEventManager<S>;
    menuManager: MenuManager<MenuT>;
    evalManager: EvalManager;
    publishingManager: PublishingManager;
    resourceManager: ResourceManager;
    activityEventsManager: ActivityEventsManager;
    filePropertyManager: FilePropertyManager;
    logManager: LogManager;
    transcriptionManager: TranscriptionManager;
    sandboxManager: SandboxManager;
    gitManager: GitManager;
    isProcessing$: Observable<boolean>;
    avoidRects$: Observable<AvoidRect[]>;
    initialState: S | (() => S);
    options: NoyaManagerOptions<S, M>;
    unrecoverableError: Observable<MultiplayerStateManagerError | undefined>;
    constructor(initialState: S | (() => S), options?: NoyaManagerOptions<S, M>);
    enqueueInput: <K extends Extract<keyof I, string>>(queue: K, payload: I[K]) => void;
    forceInit: () => void;
    undo: () => HistoryEntry<S, Partial<M> & MultiplayerPatchMetadata> | undefined;
    redo: () => HistoryEntry<S, Partial<M> & MultiplayerPatchMetadata> | undefined;
    canUndo: () => boolean;
    canRedo: () => boolean;
    restoreSnapshot: (options: {
        fileId: string;
        fileVersionId: string;
    }) => Promise<unknown>;
}

type MultiplayerUser = {
    id: string;
    connectionId: string;
    clientId: string;
    authId?: string;
    name?: string;
    image?: string;
    inactive?: boolean;
    access?: AccessType;
    roles?: MultiplayerAuthorityRole[];
};
type AccessType = "read" | "write" | "none";
type MultiplayerAuthorityRole = "file-owner";
/**
 * Trusted connection identity supplied by the multiplayer host. Unlike a
 * command payload, these fields are not controlled by the sending client.
 */
type MultiplayerActor = {
    actorId: string;
    connectionId: string;
    clientId: string;
    authId?: string;
    name?: string;
    image?: string;
    access: AccessType;
    roles: MultiplayerAuthorityRole[];
};
type TokenPayload = Omit<MultiplayerUser, "clientId"> & {
    fileId: string;
    access: AccessType;
    roles?: MultiplayerAuthorityRole[];
    writeTo?: string;
    baseUrl: string;
};
type Destructor = () => void;
type SyncAdapterOptions<S, M extends object, E extends object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>> = {
    noyaManager: NoyaManager<S, M, E, MenuT, I>;
};
type SyncAdapter<S, M extends object, E extends object, MenuT extends string = string, I extends Record<string, any> = Record<string, unknown>> = (options: SyncAdapterOptions<S, M, E, MenuT, I>) => Destructor;
type SyncURLOption = string | URL | (() => Promise<string | URL>);
type SyncOptionsBase = {
    url: SyncURLOption;
    debug?: boolean;
};
type WebSocketSyncOptions = SyncURLOption | SyncOptionsBase;
type ParentFrameSyncOptions = {
    origin?: string;
    messageHandler?: ParentFrameMessageHandler<any>;
    debug?: boolean;
    policyAuthContext?: PolicyAuthContext;
    enableDocumentAI?: boolean;
};
type SyncConfig = {
    url: URL;
    tokenString: string;
    tokenPayload: TokenPayload;
};
type AdapterHandlers<E extends object> = {
    assetManager?: AssetManager;
    sharedConnectionDataManager?: SharedConnectionDataManager<E>;
    pipelineManager?: PipelineManager;
    secretManager?: SecretManager;
    userManager?: UserManager;
    onChangeTasks?: (tasks: Task[]) => void;
};
type ConnectionMessage = {
    type: "connection";
    state: "connected" | "disconnected";
};

declare const MULTIPLAYER_POLICY_METADATA_KEY = "noyaPolicy";
declare const SERVER_COMPUTED_METADATA_KEY = "noyaServerComputed";
declare const SERVER_SCRIPTS_METADATA_KEY = "noyaServerScripts";
type MultiplayerPolicyAction = "read" | "create" | "update" | "delete";
type MultiplayerPolicyLet = [string, string];
type MultiplayerPolicyDefinition = {
    allow?: Partial<Record<MultiplayerPolicyAction, string>>;
    let?: MultiplayerPolicyLet[] | Record<string, string>;
};
type PolicyAuthContext = {
    id?: string | null;
    access?: AccessType;
    [key: string]: unknown;
};
type ServerComputedEvent = "create" | "update";
type ServerComputedTarget = "value" | "object";
type ServerComputedValueFactory = {
    kind: "timestamp";
    format?: "iso" | "number";
} | {
    kind: "authId";
} | {
    kind: "uuid";
} | {
    kind: "literal";
    value: unknown;
} | {
    kind: "expression";
    expression: string;
};
type ServerComputedDefinition = {
    events?: ServerComputedEvent[];
    targets?: ServerComputedTarget[];
    compute: ServerComputedValueFactory;
};
type ServerScriptDefinition = {
    id: string;
    code: string;
    label?: string;
    on?: {
        interval?: string;
        stateChange?: true | {
            paths: string[];
        };
        inputQueue?: true | {
            queues: string[];
        };
        user?: true | {
            events: ("join" | "leave")[];
        };
        schemaMigration?: true | {
            fromVersions?: number[];
        };
    };
};
type ServerComputedDefinitionInput = Omit<ServerComputedDefinition, "compute"> & {
    compute: ServerComputedValueFactory | string;
};
declare function ServerComputed<T extends TSchema>(schema: T, definition: ServerComputedDefinitionInput): T;
declare function AccessPolicy<T extends TSchema>(schema: T, definition: MultiplayerPolicyDefinition): T;
declare function ServerScripts<T extends TSchema>(schema: T, scripts: ServerScriptDefinition[]): T;
declare function getServerScriptDefinitions(schema?: TSchema | null): ServerScriptDefinition[];
type PolicyViolation = {
    action: MultiplayerPolicyAction;
    patch: ExtendedPatch;
    expression?: string;
    message?: string;
};
declare function enforceMultiplayerPolicies<S>(options: {
    schema?: TSchema;
    patches: ExtendedPatch[];
    previousState: S;
    nextState: S;
    auth?: PolicyAuthContext;
    now: number;
}): PolicyViolation | undefined;
declare function applyServerComputedMetadata(options: {
    schema?: TSchema;
    patches: ExtendedPatch[];
    auth?: PolicyAuthContext;
    now: number;
}): ExtendedPatch[];
declare function filterStateForReadAccess<S>(options: {
    schema?: TSchema;
    state: S;
    auth?: PolicyAuthContext;
    now: number;
}): S;

type InputQueueItem = {
    id: string;
    connectionId: string;
    queue: string;
    enqueuedAt: number;
    payload: unknown;
    actor?: MultiplayerActor;
};
type DrainInputQueueOptions = {
    connectionId?: string;
    queue?: string;
    maxEntries?: number;
};
type QuickJSHandleLike = {
    consume<T>(fn: (handle: QuickJSHandleLike) => T): T;
    dispose(): void;
};
type QuickJSContextLike = {
    global: QuickJSHandleLike;
    undefined: QuickJSHandleLike;
    evalCode(code: string, filename?: string, options?: {
        type?: "global" | "module";
    }): QuickJSHandleLike;
    unwrapResult(handle: QuickJSHandleLike): QuickJSHandleLike;
    newFunction(name: string, fn: (...args: QuickJSHandleLike[]) => QuickJSHandleLike): QuickJSHandleLike;
    newObject(): QuickJSHandleLike;
    newString(value: string): QuickJSHandleLike;
    setProp(object: QuickJSHandleLike, prop: string, value: QuickJSHandleLike): void;
    dump<T>(handle: QuickJSHandleLike): T;
    dispose(): void;
};
type QuickJSRuntimeLike = {
    newContext(): QuickJSContextLike;
    setModuleLoader(loader: (moduleName: string) => string | {
        error: Error;
    } | Promise<string | {
        error: Error;
    }>): void;
    dispose(): void;
};
type QuickJSModuleLike = {
    newRuntime(): QuickJSRuntimeLike;
};
type QuickJSModuleFactory<TModule extends QuickJSModuleLike = QuickJSModuleLike> = () => Promise<TModule> | TModule;
type ServerScriptTarget = "durable-object" | "local-storage" | "client-simulator" | "test";
type ServerScriptUserTriggerEvent = "join" | "leave";
type ServerScriptMode = "live" | "simulation";
type ServerScriptEnvironment = {
    target: ServerScriptTarget;
    mode?: ServerScriptMode;
    label?: string;
    clock?: () => number;
};
type ServerScriptLogEvent = {
    level: "log" | "error" | "warn";
    scriptId: string;
    target: ServerScriptTarget;
    mode: ServerScriptMode;
    origin: string;
    values: unknown[];
};
type ServerScriptRuntimeBindings = {
    getState: () => any;
    getSharedConnectionData: () => Record<string, unknown>;
    setSharedConnectionData: (data: Record<string, unknown>) => void;
    drainInputQueue: (options?: DrainInputQueueOptions) => InputQueueItem[];
    getConnectedActors?: () => MultiplayerActor[];
    applyState: (options: {
        scriptId: string;
        nextState: any;
        invocation?: number;
        timestamp?: number;
    }) => Promise<void> | void;
    getInitialInvocation?: (scriptId: string) => number | undefined;
};
type ServerScriptManagerOptions<TModule extends QuickJSModuleLike = QuickJSModuleLike> = ServerScriptRuntimeBindings & {
    getQuickJSModule: QuickJSModuleFactory<TModule>;
    randomUUID?: () => string;
    environment: ServerScriptEnvironment;
    log: (entry: ServerScriptLogEvent) => void;
};
declare function serializeServerScriptLogValue(value: unknown, seen?: WeakSet<object>): unknown;
declare class ServerScriptManager<TModule extends QuickJSModuleLike = QuickJSModuleLike> {
    private options;
    private isHot;
    private runners;
    private quickJSPromise;
    private randomUUID;
    private environment;
    private log;
    constructor(options: ServerScriptManagerOptions<TModule>);
    private getQuickJSPromise;
    setIsHot(isHot: boolean): void;
    syncInvocation(scriptId: string | undefined, invocation: number, timestamp?: number): void;
    updateSchema(schema?: any | null): Promise<void>;
    handleStateChange(patches: ExtendedPatch[]): void;
    handleInputQueueActivity(queueName?: string): void;
    handleUserEvent(event: ServerScriptUserTriggerEvent, user: MultiplayerUser): void;
    /**
     * Runs migration scripts in definition order.
     * If multiple scripts match, they chain: each receives the output of the previous.
     * Returns the final migrated state, or undefined if no scripts ran/returned state.
     *
     * Note: Unlike other handlers, this does NOT require isHot to be true since
     * migrations run during schema initialization before normal script execution.
     */
    handleSchemaMigration(fromVersion: number, toVersion: number, state: any): Promise<any | undefined>;
    dispose(): void;
}

declare const createHash: typeof hash;
type SetStateAction<S> = S | ((prevState: S) => S);
/**
 * TODO:
 *
 * Pending commits may need to be updated when a patch is accepted or rejected?
 * Since right now we're using optimisticState based on pending commits - but
 * instead we could use a memoization approach
 *
 * Server may want to say whether a commit is from self or not, so that we can
 * more easily ignore patches that we sent (e.g. in case we change a pending patch
 * after sending? but it already has an id so maybe not needed)
 *
 * Prune old patches from the server
 *
 * MSM can just have a sm StateManager, mostly separate from any multiplayer logic,
 * that does its usual patch merging etc, but can be used to send undo/redo patches
 */
type ServerInvocation = {
    scriptId?: string;
    invocation: number;
    timestamp: number;
};
type MultiplayerPatchMetadata = {
    id: string;
    name?: string;
    timestamp: number;
    serverInvocation?: ServerInvocation & {
        source: "server" | "client-sim";
    };
};
type ClientCommit<S, M> = {
    state: S;
    baseHash: string;
    historyEntry: Required<HistoryEntry<S, M & MultiplayerPatchMetadata>>;
};
type ClientConnectionStatus = "connected" | "disconnected";
type ClientToServerMessage<S> = {
    type: "init";
    object: S;
    force?: boolean;
    schema?: EncodedSchema;
    inputs?: CreateParams<Input>[];
    outputTransforms?: CreateParams<OutputTransform>[];
} | {
    type: "patch";
    id: string;
    name?: string;
    patches: ExtendedPatch[];
    baseHash: string;
    serverInvocation?: ServerInvocation;
} | {
    type: "resourceEdit.open";
    resourceId: string;
} | {
    type: "resourceEdit.patch";
    resourceId: string;
    id: string;
    patches: ExtendedPatch[];
    baseHash: string;
} | {
    type: "resourceEdit.close";
    resourceId: string;
} | {
    type: "gitFileEdit.open";
    repoId: string;
    filePath: string;
    ref: string;
} | {
    type: "gitFileEdit.patch";
    repoId: string;
    filePath: string;
    ref: string;
    id: string;
    patches: ExtendedPatch[];
    baseHash: string;
} | {
    type: "gitFileEdit.close";
    repoId: string;
    filePath: string;
    ref: string;
} | {
    type: "setSharedConnectionData";
    connectionId: string;
    data?: unknown;
} | {
    type: "enqueueInput";
    connectionId?: string;
    queue: string;
    payload: unknown;
} | {
    type: "ping";
    id: string;
} | {
    type: "activityEvents.subscribe";
    streamId: string;
    cursor?: string;
} | {
    type: "activityEvents.unsubscribe";
    streamId: string;
};
type RejectInitReason = "invalidDataType" | "schemaMismatch" | "outdatedSchema" | "dataMigrationFailure";
type RejectPatchReason = "serverStateNotInitialized" | "errorApplyingPatch" | "clientOutOfSync" | "invalidDataType" | "outdatedSchema" | "policyViolation";
type PipelineStatus = "idle" | "running" | "success" | "error";
type ServerToClientMessage<S> = {
    type: "object";
    object: S;
    schema?: EncodedSchema;
} | {
    type: "rejectInit";
    reason: RejectInitReason;
    error?: string;
} | {
    type: "acceptPatch";
    id: string;
    patches: ExtendedPatch[];
    hash?: string;
    serverInvocation?: ServerInvocation;
} | {
    type: "rejectPatch";
    id: string;
    reason: RejectPatchReason;
    error?: string;
} | {
    type: "resourceEdit.object";
    resourceId: string;
    content: string;
    hash?: string;
} | {
    type: "resourceEdit.acceptPatch";
    resourceId: string;
    id: string;
    patches: ExtendedPatch[];
    hash?: string;
} | {
    type: "resourceEdit.rejectPatch";
    resourceId: string;
    id: string;
    reason: RejectPatchReason;
    error?: string;
} | {
    type: "gitFileEdit.object";
    repoId: string;
    filePath: string;
    ref: string;
    content: string;
    hash?: string;
} | {
    type: "gitFileEdit.acceptPatch";
    repoId: string;
    filePath: string;
    ref: string;
    id: string;
    patches: ExtendedPatch[];
    hash?: string;
} | {
    type: "gitFileEdit.rejectPatch";
    repoId: string;
    filePath: string;
    ref: string;
    id: string;
    reason: RejectPatchReason;
    error?: string;
} | {
    type: "gitFileEdit.committed";
    repoId: string;
    ref: string;
    oid: string;
} | {
    type: "connectedUsers";
    users: MultiplayerUser[];
} | {
    type: "schemaMigration";
    schema: EncodedSchema;
} | {
    type: "sharedConnectionData";
    data: Record<string, unknown>;
} | {
    type: "workflow";
    workflow: {
        status: PipelineStatus;
        tasks: TaskSnapshot<any>[];
        result: any;
    };
} | {
    type: "tasks";
    tasks: Task[];
} | {
    type: "assets";
    assets: Asset[];
} | {
    type: "resources";
    resources: Resource[];
} | {
    type: "inputs";
    inputs: Input[];
} | {
    type: "outputTransforms";
    outputTransforms: OutputTransform[];
} | {
    type: "pong";
    id: string;
} | {
    type: "secrets";
    secrets: Secret[];
} | {
    type: "fileName";
    name: string;
    changeId?: string;
} | {
    type: "activityEvents";
    activityEvents: unknown[];
} | {
    type: "activityEvents.update";
    streamId: string;
    activityEvents: unknown[];
} | {
    type: "serverScript.log";
    log: ServerScriptLogEntry;
} | {
    type: "sandbox";
    state: SandboxState;
};
type MultiplayerStateManagerErrorType = RejectInitReason | "schemaMigration" | RejectPatchReason;
declare class MultiplayerStateManagerError extends Error {
    readonly reason: MultiplayerStateManagerErrorType;
    constructor(reason: MultiplayerStateManagerErrorType, message?: string);
}
type MultiplayerStateManagerMode = "standalone" | "synchronized";
type MultiplayerStateManagerOptions<S, M> = StateManagerOptions<S, Partial<M> & MultiplayerPatchMetadata> & {
    randomId?: () => string;
    getNow?: () => number;
    serverScripts?: {
        simulateLocally?: boolean;
        getQuickJSModule: ServerScriptManagerOptions["getQuickJSModule"];
        randomUUID?: ServerScriptManagerOptions["randomUUID"];
        getNow?: () => number;
    };
    getSharedConnectionData?: () => Record<string, unknown>;
    drainInputQueue?: (options?: DrainInputQueueOptions) => InputQueueItem[];
    overrideExistingState?: boolean;
    outputTransforms?: CreateParams<OutputTransform>[];
    inputs?: CreateParams<Input>[];
    debug?: boolean;
    mode?: MultiplayerStateManagerMode;
};
declare class MultiplayerStateManager<TState, TMetadata extends object = object> extends Emitter {
    options: MultiplayerStateManagerOptions<TState, TMetadata>;
    get _metadataType(): Partial<TMetadata> & MultiplayerPatchMetadata;
    state: TState;
    schema?: TSchema;
    errorEmitter: Emitter<[MultiplayerStateManagerError]>;
    sm: StateManager<TState, typeof this._metadataType>;
    pendingCommits: ClientCommit<TState, typeof this._metadataType>[];
    connectionStatus$: Observable<ClientConnectionStatus>;
    isInitialized$: Observable<boolean>;
    outgoingMessages: ClientToServerMessage<TState>[];
    incomingMessages: ServerToClientMessage<TState>[];
    optimisticState$: Observable<TState>;
    partialHashCache: Cache<unknown, string>;
    createHashCached: (input: unknown) => string;
    applyCommitCache: Cache<string, {
        input: TState;
        output: TState;
    }>;
    private policyAuthContext;
    private enforcePoliciesLocally;
    enhanceMetadata(metadata: Partial<TMetadata> & Partial<MultiplayerPatchMetadata>): typeof this._metadataType;
    getRandomId(): string;
    private initializeServerSimulator;
    setPolicyAuthContext(context: PolicyAuthContext | undefined): void;
    setLocalPolicyEnforcement(enabled: boolean): void;
    constructor(state: TState | (() => TState), options?: MultiplayerStateManagerOptions<TState, TMetadata>);
    autoConnect: () => void;
    getHash(): string;
    _setState(state: TState, schema: TSchema | undefined): void;
    _lastEmittedHash: string | undefined;
    emitIfChanged: () => void;
    get isConnected(): boolean;
    _pushCommit(state: TState, historyEntry: Required<HistoryEntry<TState, typeof this._metadataType>>, { addToHistory, shouldTypeCheck, sendMessage, }: {
        addToHistory: boolean;
        shouldTypeCheck?: boolean;
        sendMessage?: boolean;
    }): void;
    private getLocalPolicyViolation;
    canUndo: () => boolean;
    canRedo: () => boolean;
    undo: () => HistoryEntry<TState, Partial<TMetadata> & MultiplayerPatchMetadata> | undefined;
    redo: () => HistoryEntry<TState, Partial<TMetadata> & MultiplayerPatchMetadata> | undefined;
    /**
     * Mutate the state in-place.
     *
     * This will create a patch based on the changes made to the state and create
     * a history entry with the patch.
     */
    editDraft: (...args: [metadata: Partial<TMetadata>, callback: (draft: Draft<TState>) => void] | [callback: (draft: Draft<TState>) => void]) => void;
    /**
     * Apply a patch optimistically.
     *
     * Creates a history entry with the patch. If inversePatches are not provided,
     * this will perform a diff between the current state and the new state.
     */
    applyPatch: (...args: [metadata: Partial<TMetadata>, {
        patches: ExtendedPatch[];
        inversePatches?: ExtendedPatch[];
    }] | [{
        patches: ExtendedPatch[];
        inversePatches?: ExtendedPatch[];
    }]) => void;
    /**
     * Set the current state optimistically.
     *
     * This will perform a diff between the current state and the new state, and
     * create a history entry with the patch.
     */
    setState: (...args: [metadata: Partial<TMetadata>, action: SetStateAction<TState>] | [action: SetStateAction<TState>]) => void;
    setStateAtPath: <P extends PathKey[] | string>(...args: [metadata: Partial<TMetadata>, path: P, value: SetStateAction<GetAtPath<TState, P>>] | [path: P, value: SetStateAction<GetAtPath<TState, P>>]) => void;
    operate: (...args: [metadata: Partial<TMetadata>, operator: (operationManager: OperationManager<TState>) => void] | [operator: (operationManager: OperationManager<TState>) => void]) => void;
    getConfirmedState: () => TState;
    getOptimisticState: () => TState;
    getOptimisticHash(): string;
    reinitialize(state: TState): void;
    _handledMessages: Record<string, boolean>;
    processIncomingMessages(): void;
    connect(): void;
    sendInit({ force, state, schema, outputTransforms, inputs, }?: {
        force?: boolean;
        state?: TState;
        schema?: TSchema;
        outputTransforms?: CreateParams<OutputTransform>[];
        inputs?: CreateParams<Input>[];
    }): void;
    sendMessage(message: ClientToServerMessage<TState>): void;
    disconnect(): void;
    hasPendingMessages(): boolean;
    messageEmitter: Emitter<[ClientToServerMessage<TState>]>;
    /** SERVER PREDICTIONS */
    serverSimulationLogManager: LogManager;
    serverSimulationLogs$: Observable<ServerScriptLogEntry[]>;
    private serverPredictionCommits;
    private serverInvocationTracker;
    private serverClockSkewMs;
    private serverScriptSimulator?;
    private getNow;
    private getServerNowEstimate;
    getServerSimulationDiagnostics(): {
        simulateLocally: boolean;
        simulatorActive: boolean;
        clockSkewMs: number;
        invocations: {
            scriptId: string | undefined;
            invocation: number;
            timestamp: number;
        }[];
        pendingPredictions: {
            scriptId: string | undefined;
            invocation: number | undefined;
            commitId: string;
        }[];
    };
    getLatestServerInvocation(scriptId?: string): {
        invocation: number;
        timestamp: number;
    } | undefined;
    getLatestPrediction(): {
        state: TState;
        serverInvocation: (ServerInvocation & {
            source: "server" | "client-sim";
        }) | undefined;
    } | undefined;
    private clearServerPredictions;
    applyServerPrediction(options: {
        scriptId?: string;
        nextState: TState;
        invocation?: number;
        timestamp?: number;
    }): void;
    private handleServerInvocation;
}
type SharedConnectionMetadata = {
    updatedAt: number;
};
type SelectionRange = {
    anchor: PathKey[];
    head?: PathKey[];
};
type Point = {
    x: number;
    y: number;
};
type DefaultSharedConnectionData = {
    pointer?: Point;
    selection?: SelectionRange[];
};
declare class SharedConnectionDataManager<E extends object> extends Emitter<[
    Record<string, (E & DefaultSharedConnectionData) | undefined>,
    Record<string, {
        updatedAt: number;
    } | undefined>
]> {
    data$: Observable<Record<string, (E & DefaultSharedConnectionData) | undefined>>;
    metadata$: Observable<Record<string, SharedConnectionMetadata | undefined>>;
    currentConnectionId$: Observable<string | undefined>;
    currentConnectionDataEmitter: Emitter<[(E & DefaultSharedConnectionData) | undefined]>;
    setCurrentConnectionId: (currentConnectionId: string | undefined) => void;
    setForCurrentConnection: (value: E & DefaultSharedConnectionData) => void;
    set: (connectionId: string, value: E & DefaultSharedConnectionData) => void;
    merge: (partial: Record<string, E & DefaultSharedConnectionData>) => void;
    delete: (connectionId: string) => void;
    _snapshot: {
        data: Record<string, E | undefined>;
        metadata: Record<string, SharedConnectionMetadata | undefined>;
        currentConnectionId: string | undefined;
    } | undefined;
    getSnapshot: () => {
        data: Record<string, E | undefined>;
        metadata: Record<string, SharedConnectionMetadata | undefined>;
        currentConnectionId: string | undefined;
    };
}

type ActivityEventStream = {
    activityEvents: Observable<unknown[]>;
    isInitialized: Observable<boolean>;
};
type StreamFilter = "all" | {
    resourceId: string;
};
declare class ActivityEventsManager {
    private sendMessage?;
    activityEventStreams: Record<string, ActivityEventStream>;
    constructor(sendMessage?: ((message: ClientToServerMessage<any>) => void) | undefined);
    subscribe(filter: StreamFilter): string;
    getStream(streamId: string): Observable<unknown[]>;
    unsubscribe(streamId: string): void;
    setStreamEvents(streamId: string, activityEvents: unknown[]): void;
}

export { type ReconnectingWebSocketState as $, AssetStoreIndexedDB as A, type GitFilePatchRequestBody as B, type ClientToServerMessage as C, type DrainInputQueueOptions as D, type ExtractRequestBody as E, type GitFilePatchResponseBody as F, type GitFileCreateOperation as G, type HistoryEntry as H, type InputQueueItem as I, type GitFileRenameOperation as J, type RouteDefinition as K, type RouteKey$1 as L, type MultiplayerAuthorityRole as M, NoyaManager as N, type ScriptEvaluatorFile as O, type ParentToEmbeddedMessage as P, type ScriptEvaluatorRequest as Q, type Routes as R, type SerializableRequest as S, type ScriptEvaluatorResponse as T, type UploadProgress as U, type WorkspaceMemberUser as V, type WebSocketSyncOptions as W, type AdapterHandlers as X, type ConnectionMessage as Y, ReconnectingWebSocket as Z, UserActivityDetector as _, type SerializableResponse as a, IOManager as a$, createDefaultMessageHandler as a0, isEmbeddedToParentMessage as a1, isParentToEmbeddedMessage as a2, type AvoidRect as a3, type EmbeddedToParentMessage as a4, type ParentFrameMessageHandler as a5, type StreamFilter as a6, ActivityEventsManager as a7, type AIToolDefinition as a8, type CallableAIToolsMap as a9, extractItemId as aA, toExtendedPathKey as aB, toSimplePath as aC, toExtendedPatch as aD, toSimplePatch as aE, applyExtendedPatch as aF, toExtendedPatches as aG, createExtended as aH, type FilePropertyManagerOptions as aI, FilePropertyManager as aJ, type GitFileEditServerMessage as aK, type GitFileEditHandle as aL, GitFileEditSession as aM, type GitFileCommittedMessage as aN, type GitRepo as aO, type BranchInfo as aP, type RepoFilesFetchState as aQ, type RepoFilesState as aR, type GitManagerOptions as aS, GitManager as aT, type HostStorageRequest as aU, type HostStorageResponse as aV, HostStorageManager as aW, type ImagePickerRequest as aX, type ImagePickerResponse as aY, ImagePickerManager as aZ, type CreateParams as a_, type AIToolInvocation as aa, type AIImageInput as ab, type AIGenerateObjectOptions as ac, type AIGenerateTextOptions as ad, type AIDeepPartial as ae, type AIStreamObjectResult as af, type AIStreamTextResult as ag, type AIGenerateImageOptions as ah, type AIGeneratedImage as ai, AIManager as aj, type AssetUploadProgress as ak, type CreateAssetOptions as al, type UpdateAssetOptions as am, type IAssetStore as an, type NoyaAsset as ao, AssetStoreMemory as ap, AssetStoreRemote as aq, type ConnectionEvent as ar, ConnectionEventManager as as, type EvalRequest as at, type EvalResponse as au, type SafeEval as av, EvalManager as aw, applyPatchToString as ax, apply as ay, type SimplePatchWithStringPath as az, type ExtractResponseBody as b, RPCManager as b$, type ServerScriptLogLevel as b0, type ServerScriptLogEntry as b1, type LogManagerOptions as b2, LogManager as b3, MenuManager as b4, createHash as b5, type MultiplayerPatchMetadata as b6, type ClientCommit as b7, type ClientConnectionStatus as b8, type RejectInitReason as b9, getServerScriptDefinitions as bA, type PolicyViolation as bB, enforceMultiplayerPolicies as bC, applyServerComputedMetadata as bD, filterStateForReadAccess as bE, type NoyaManagerOptions as bF, defaultMergeHistoryEntries as bG, type TaskArtifact as bH, type TaskMetadata as bI, PipelineManager as bJ, type PublishCallback as bK, PublishingManager as bL, type ResourceEditServerMessage as bM, type ResourceEditHandle as bN, ResourceEditSession as bO, type ResourceManagerOptions as bP, ResourceManager as bQ, getResourceTransformUrl as bR, type TypedBody as bS, type RPCRequestPayload as bT, type RPCResponsePayload as bU, type RPCSuccessResponse as bV, type RPCStreamChunkResponse as bW, type RPCStreamEndResponse as bX, type RPCErrorResponse as bY, type RPCStatus as bZ, type RPCResponseMessage as b_, type RejectPatchReason as ba, type PipelineStatus as bb, type MultiplayerStateManagerErrorType as bc, MultiplayerStateManagerError as bd, type MultiplayerStateManagerMode as be, type MultiplayerStateManagerOptions as bf, MultiplayerStateManager as bg, type SharedConnectionMetadata as bh, type SelectionRange as bi, type DefaultSharedConnectionData as bj, SharedConnectionDataManager as bk, MULTIPLAYER_POLICY_METADATA_KEY as bl, SERVER_COMPUTED_METADATA_KEY as bm, SERVER_SCRIPTS_METADATA_KEY as bn, type MultiplayerPolicyAction as bo, type MultiplayerPolicyLet as bp, type MultiplayerPolicyDefinition as bq, type PolicyAuthContext as br, type ServerComputedEvent as bs, type ServerComputedTarget as bt, type ServerComputedValueFactory as bu, type ServerComputedDefinition as bv, type ServerScriptDefinition as bw, ServerComputed as bx, AccessPolicy as by, ServerScripts as bz, type ServerToClientMessage as c, type SandboxPhase as c0, type SandboxState as c1, createInitialSandboxState as c2, type ExecResult as c3, SandboxManager as c4, type EvaluateScriptOptions as c5, type EvaluateScriptUrlOptions as c6, type EvaluateScriptFilesOptions as c7, type ScriptEvaluationResult as c8, ScriptEvaluationError as c9, type Destructor as cA, type SyncAdapterOptions as cB, TaskManager as cC, type Task as cD, type TranscribeOptions as cE, type TranscriptionResult as cF, type AssetTranscriptionResult as cG, TranscriptionManager as cH, requestTranscription as cI, findNoyaUser as cJ, UserManager as cK, ScriptEvaluatorManager as ca, type Secret as cb, type SecretManagerOptions as cc, SecretManager as cd, type QuickJSHandleLike as ce, type QuickJSContextLike as cf, type QuickJSRuntimeLike as cg, type QuickJSModuleLike as ch, type QuickJSModuleFactory as ci, type ServerScriptTarget as cj, type ServerScriptMode as ck, type ServerScriptEnvironment as cl, type ServerScriptLogEvent as cm, type ServerScriptRuntimeBindings as cn, serializeServerScriptLogValue as co, ServerScriptManager as cp, type ActionHandler as cq, type HistorySnapshot as cr, type StateManagerOptions as cs, createEditHistoryEntry as ct, createPatchHistoryEntry as cu, OperationManager as cv, StateManager as cw, type MultiplayerUser as cx, type AccessType as cy, type TokenPayload as cz, type SyncOptionsBase as d, type SyncURLOption as e, type SyncConfig as f, type ServerScriptManagerOptions as g, type SyncAdapter as h, type ParentFrameSyncOptions as i, type StoreAsset as j, type ExtendedPatch as k, type SimplePatch as l, type ExtendedPathKey as m, type MultiplayerActor as n, AssetManager as o, type AIGenerateImage as p, type AIGenerateImageRequest as q, type AIGenerateImageResponse as r, type AIGenerateRequest as s, type AIGenerateResponse as t, type AIGenerateTextRequest as u, type AIGenerateTextResponse as v, type AIGenerationStreamEvent as w, type AISamplingOptions as x, type GitFileDeleteOperation as y, type GitFileInfo as z };