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 * as _sinclair_typebox from '@sinclair/typebox';
import { TObject, Static, TSchema } 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 AIGenerateRequest = {
    prompt: string;
    system?: string;
    model?: string;
    schema: Record<string, unknown>;
    encodedSchema?: EncodedSchema;
    images?: AIGenerateImage[];
};
type AIGenerateResponse = {
    object: unknown;
};
type AIGenerateTextRequest = {
    prompt: string;
    system?: string;
    model?: string;
    images?: AIGenerateImage[];
};
type AIGenerateTextResponse = {
    text: 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;
                };
                _kind: "Object";
            };
        } | {
            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;
            };
            _kind: "Object";
        } | 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;
    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> = {
    prompt: string;
    schema: Schema;
    system?: string;
    images?: AIImageInput[];
    model?: string;
};
type AIGenerateTextOptions = {
    prompt: string;
    system?: string;
    images?: AIImageInput[];
    model?: 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>;
    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;
    generateObject<Schema extends TObject>({ prompt, schema, system, images, model, }: AIGenerateObjectOptions<Schema>): Promise<Static<Schema>>;
    generateText({ prompt, system, images, model, }: AIGenerateTextOptions): Promise<string>;
    generateImage({ prompt, model, }: AIGenerateImageOptions): Promise<AIGeneratedImage>;
}

declare class UserActivityDetector {
    onActivity?: (() => void) | undefined;
    constructor(onActivity?: (() => void) | undefined);
    private _activityHandler;
    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;
}

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[];
    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<({
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "asset";
        createdAt: string;
        stableId: string;
        assetId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "file";
        createdAt: string;
        fileId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "directory";
        createdAt: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: 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<({
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "asset";
        createdAt: string;
        stableId: string;
        assetId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "file";
        createdAt: string;
        fileId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "directory";
        createdAt: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: 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<{
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "asset";
        createdAt: string;
        stableId: string;
        assetId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "file";
        createdAt: string;
        fileId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "directory";
        createdAt: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: 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<({
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "asset";
        createdAt: string;
        stableId: string;
        assetId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "file";
        createdAt: string;
        fileId: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: string;
        } | undefined;
        path: string;
        id: string;
        type: "directory";
        createdAt: string;
        stableId: string;
        updatedAt: string;
        accessibleByFileId: string | null;
        accessibleByFileVersionId: string | null;
    } | {
        url?: string | undefined;
        accessibleByFile?: {
            id: string;
            name: string;
            toolId: 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;
    _editSessions: Map<string, ResourceEditSession>;
    _handleConnectionEvent: (event: ConnectionEvent<any>) => void;
    openEditingHandle(resourceId: string): _noya_app_noya_multiplayer_react.ResourceEditHandle;
}

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.evaluate";
    payload: EvalRequest;
} | {
    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: "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.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[];
    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;
    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>;
}
declare const createMutatorParametersSchema: _sinclair_typebox.TObject<{
    sourceCode: _sinclair_typebox.TString;
    message: _sinclair_typebox.TString;
}>;
type CreateMutatorParameters = Static<typeof createMutatorParametersSchema>;

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