export declare const ReqEnsureAppSlug: import("arktype/internal/variants/object.ts").ObjectType<{
    appSlug: string;
    ownerHandle: string;
    type: "vibes.diy.req-ensure-app-slug";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    mode: "dev" | "production";
    env?: Record<string, string> | undefined;
    runId?: string | undefined;
    message?: string | undefined;
    fileSystem: ({
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "code-block";
        lang: string;
        content: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "code-ref";
        refId: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "str-asset-block";
        content: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "str-asset-ref";
        refId: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "uint8-asset-block";
        content: Uint8Array<ArrayBuffer>;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "uint8-asset-ref";
        refId: string;
    })[];
} | {
    appSlug?: string | undefined;
    ownerHandle: string;
    type: "vibes.diy.req-ensure-app-slug";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    mode: "dev" | "production";
    env?: Record<string, string> | undefined;
    runId?: string | undefined;
    message?: string | undefined;
    fileSystem: ({
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "code-block";
        lang: string;
        content: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "code-ref";
        refId: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "str-asset-block";
        content: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "str-asset-ref";
        refId: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "uint8-asset-block";
        content: Uint8Array<ArrayBuffer>;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "uint8-asset-ref";
        refId: string;
    })[];
} | {
    appSlug: string;
    ownerHandle?: string | undefined;
    type: "vibes.diy.req-ensure-app-slug";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    mode: "dev" | "production";
    env?: Record<string, string> | undefined;
    runId?: string | undefined;
    message?: string | undefined;
    fileSystem: ({
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "code-block";
        lang: string;
        content: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "code-ref";
        refId: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "str-asset-block";
        content: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "str-asset-ref";
        refId: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "uint8-asset-block";
        content: Uint8Array<ArrayBuffer>;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "uint8-asset-ref";
        refId: string;
    })[];
} | {
    appSlug?: string | undefined;
    ownerHandle?: string | undefined;
    type: "vibes.diy.req-ensure-app-slug";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    mode: "dev" | "production";
    env?: Record<string, string> | undefined;
    runId?: string | undefined;
    message?: string | undefined;
    fileSystem: ({
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "code-block";
        lang: string;
        content: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "code-ref";
        refId: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "str-asset-block";
        content: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "str-asset-ref";
        refId: string;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "uint8-asset-block";
        content: Uint8Array<ArrayBuffer>;
    } | {
        filename: string;
        entryPoint?: boolean | undefined;
        mimetype?: string | undefined;
        type: "uint8-asset-ref";
        refId: string;
    })[];
}, {}>;
export type ReqEnsureAppSlug = typeof ReqEnsureAppSlug.infer;
export declare const resEnsureAppSlugOk: import("arktype/internal/variants/object.ts").ObjectType<{
    appSlug: string;
    ownerHandle: string;
    mode: "dev" | "production";
    fsId: string;
    type: "vibes.diy.res-ensure-app-slug";
    env: Record<string, string>;
    fileSystem: {
        fileName: string;
        mimeType: string;
        assetId: string;
        assetURI: string;
        transform?: {
            type: "jsx-to-js";
            transformedAssetId: string;
        } | {
            type: "imports";
            importMapAssetId: string;
        } | {
            type: "import-map";
            fromAssetIds: string[];
        } | {
            type: "transformed";
            action: "jsx-to-js";
            transformedAssetId: string;
        } | {
            type: "tailwind-css";
        } | undefined;
        entryPoint?: boolean | undefined;
        size: number;
    }[];
}, {}>;
export type ResEnsureAppSlugOk = typeof resEnsureAppSlugOk.infer;
export declare const resEnsureAppSlugRequireLogin: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "require-login";
    };
}, {}>;
export type ResEnsureAppSlugRequireLogin = typeof resEnsureAppSlugRequireLogin.infer;
export declare function isResEnsureAppSlugOk(obj: unknown): obj is ResEnsureAppSlugOk;
export declare const resEnsureAppSlugUserSlugInvalid: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "user-slug-invalid";
    };
}, {}>;
export type ResEnsureAppSlugUserSlugInvalid = typeof resEnsureAppSlugUserSlugInvalid.infer;
export declare function isResEnsureAppSlugUserSlugInvalid(obj: unknown): obj is ResEnsureAppSlugUserSlugInvalid;
export declare const resEnsureAppSlugInvalid: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "app-slug-invalid";
    };
}, {}>;
export type ResEnsureAppSlugInvalid = typeof resEnsureAppSlugInvalid.infer;
declare const resEnsureAppSlugMaxAppsError: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "max-app-slugs-reached";
    };
}, {}>;
export type ResEnsureAppSlugMaxAppsError = typeof resEnsureAppSlugMaxAppsError.infer;
export declare function isResEnsureAppSlugMaxAppsError(obj: unknown): obj is ResEnsureAppSlugMaxAppsError;
export declare function isResEnsureAppSlugInvalid(obj: unknown): obj is ResEnsureAppSlugInvalid;
export declare const resEnsureAppSlugError: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "require-login";
    };
} | {
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "user-slug-invalid";
    };
} | {
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "app-slug-invalid";
    };
} | {
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "max-app-slugs-reached";
    };
}, {}>;
export declare const resEnsureAppSlug: import("arktype/internal/variants/object.ts").ObjectType<{
    appSlug: string;
    ownerHandle: string;
    mode: "dev" | "production";
    fsId: string;
    type: "vibes.diy.res-ensure-app-slug";
    env: Record<string, string>;
    fileSystem: {
        fileName: string;
        mimeType: string;
        assetId: string;
        assetURI: string;
        transform?: {
            type: "jsx-to-js";
            transformedAssetId: string;
        } | {
            type: "imports";
            importMapAssetId: string;
        } | {
            type: "import-map";
            fromAssetIds: string[];
        } | {
            type: "transformed";
            action: "jsx-to-js";
            transformedAssetId: string;
        } | {
            type: "tailwind-css";
        } | undefined;
        entryPoint?: boolean | undefined;
        size: number;
    }[];
} | {
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "require-login";
    };
} | {
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "user-slug-invalid";
    };
} | {
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "app-slug-invalid";
    };
} | {
    type: "vibes.diy.res-error";
    error: {
        message: string;
        code: "max-app-slugs-reached";
    };
}, {}>;
export type ResEnsureAppSlugError = typeof resEnsureAppSlugError.infer;
export declare function isResEnsureAppSlugError(obj: unknown): obj is ResEnsureAppSlugError;
export type ResEnsureAppSlug = typeof resEnsureAppSlug.infer;
export declare function isResEnsureAppSlug(obj: unknown): obj is ResEnsureAppSlug;
export declare const reqGetChatDetails: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-get-chat-details";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    ownerHandle: string;
    appSlug: string;
    chatId?: string | undefined;
}, {}>;
export type ReqGetChatDetails = typeof reqGetChatDetails.infer;
export declare const resChatDetailsPrompt: import("arktype/internal/variants/object.ts").ObjectType<{
    prompt: string;
    fsId: string;
    created: string;
}, {}>;
export type ResChatDetailsPrompt = typeof resChatDetailsPrompt.infer;
export declare const resGetChatDetails: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-get-chat-details";
    chatId?: string | undefined;
    ownerHandle: string;
    appSlug: string;
    prompts: {
        prompt: string;
        fsId: string;
        created: string;
    }[];
}, {}>;
export type ResGetChatDetails = typeof resGetChatDetails.infer;
export declare function isResGetChatDetails(obj: unknown): obj is ResGetChatDetails;
export declare const reqGetApplicationChat: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-get-application-chat";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    chatId: string;
    appSlug?: string | undefined;
    ownerHandle?: string | undefined;
}, {}>;
export type ReqGetApplicationChat = typeof reqGetApplicationChat.infer;
export declare const resGetApplicationChat: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-get-application-chat";
    chatId?: string | undefined;
    appSlug?: string | undefined;
    ownerHandle?: string | undefined;
    blocks: ({
        type: "prompt.research";
        version: 1;
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        researchId: string;
        status: "complete" | "failed" | "partial";
        brief: string;
        sources: {
            url: string;
            finalUrl: string | null;
            contentType: string | null;
            httpStatus: number | null;
            backendFetchable: boolean;
            fetched: boolean;
            errorCode?: string | undefined;
        }[];
        api: {
            method: string;
            path: string;
            description: string;
            fields: string[];
        }[];
        excerpts: {
            sourceUrl: string;
            text: string;
            locator?: string | undefined;
        }[];
        seedRows: {
            sourceUrl: string;
            dbName: string;
            key: string;
            item: unknown;
        }[];
        completedAt: string;
        errorCode?: string | undefined;
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.block-begin";
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.block-end";
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.req";
        request: {
            model?: string | undefined;
            messages: ({
                role: "assistant" | "system" | "user";
                content: ({
                    type: "text";
                    text: string;
                } | {
                    type: "image_url";
                    image_url: {
                        url: string;
                    };
                } | {
                    type: "vibes_file";
                    uploadId: string;
                    name: string;
                    mimeType: string;
                    kind: "image" | "text";
                    originalUploadId?: string | undefined;
                    size?: number | undefined;
                })[];
            } | {
                role: "assistant";
                content: string | null;
                tool_calls: {
                    id: string;
                    type: "function";
                    function: {
                        name: string;
                        arguments: string;
                    };
                }[];
            } | {
                role: "tool";
                content: string;
                tool_call_id: string;
            })[];
            stream?: boolean | undefined;
            temperature?: number | undefined;
            max_tokens?: number | undefined;
            top_p?: number | undefined;
            logprobs?: boolean | undefined;
            top_logsprobs?: number | undefined;
            frequency_penalty?: number | undefined;
            presence_penalty?: number | undefined;
            stop?: string | string[] | undefined;
            verbosity?: "high" | "low" | "max" | "medium" | undefined;
            modalities?: string[] | undefined;
            tools?: {
                type: "function";
                function: {
                    name: string;
                    description?: string | undefined;
                    parameters: unknown;
                };
            }[] | undefined;
            tool_choice?: "auto" | "none" | "required" | {
                type: "function";
                function: {
                    name: string;
                };
            } | undefined;
        };
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.error";
        error: string;
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.fs";
        fileSystem: ({
            filename: string;
            entryPoint?: boolean | undefined;
            mimetype?: string | undefined;
            type: "code-block";
            lang: string;
            content: string;
        } | {
            filename: string;
            entryPoint?: boolean | undefined;
            mimetype?: string | undefined;
            type: "code-ref";
            refId: string;
        } | {
            filename: string;
            entryPoint?: boolean | undefined;
            mimetype?: string | undefined;
            type: "str-asset-block";
            content: string;
        } | {
            filename: string;
            entryPoint?: boolean | undefined;
            mimetype?: string | undefined;
            type: "str-asset-ref";
            refId: string;
        } | {
            filename: string;
            entryPoint?: boolean | undefined;
            mimetype?: string | undefined;
            type: "uint8-asset-block";
            content: Uint8Array<ArrayBuffer>;
        } | {
            filename: string;
            entryPoint?: boolean | undefined;
            mimetype?: string | undefined;
            type: "uint8-asset-ref";
            refId: string;
        })[];
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.dry-run-payload";
        request: {
            model?: string | undefined;
            messages: ({
                role: "assistant" | "system" | "user";
                content: ({
                    type: "text";
                    text: string;
                } | {
                    type: "image_url";
                    image_url: {
                        url: string;
                    };
                } | {
                    type: "vibes_file";
                    uploadId: string;
                    name: string;
                    mimeType: string;
                    kind: "image" | "text";
                    originalUploadId?: string | undefined;
                    size?: number | undefined;
                })[];
            } | {
                role: "assistant";
                content: string | null;
                tool_calls: {
                    id: string;
                    type: "function";
                    function: {
                        name: string;
                        arguments: string;
                    };
                }[];
            } | {
                role: "tool";
                content: string;
                tool_call_id: string;
            })[];
            stream?: boolean | undefined;
            temperature?: number | undefined;
            max_tokens?: number | undefined;
            top_p?: number | undefined;
            logprobs?: boolean | undefined;
            top_logsprobs?: number | undefined;
            frequency_penalty?: number | undefined;
            presence_penalty?: number | undefined;
            stop?: string | string[] | undefined;
            verbosity?: "high" | "low" | "max" | "medium" | undefined;
            modalities?: string[] | undefined;
            tools?: {
                type: "function";
                function: {
                    name: string;
                    description?: string | undefined;
                    parameters: unknown;
                };
            }[] | undefined;
            tool_choice?: "auto" | "none" | "required" | {
                type: "function";
                function: {
                    name: string;
                };
            } | undefined;
        };
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.model-resolved";
        model: string;
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.raw";
        text: string;
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.fs-persisted";
        fsRef: (In: {
            appSlug: string;
            ownerHandle?: string | undefined;
            userSlug?: string | undefined;
            mode: "dev" | "production";
            fsId: string;
        }) => import("arktype").Out<{
            appSlug: string;
            mode: "dev" | "production";
            fsId: string;
            ownerHandle: string;
        }>;
    } | {
        streamId: string;
        chatId: string;
        seq: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "prompt.system-prompt";
        text: string;
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "block.begin";
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "block.end";
        stats: {
            toplevel: {
                lines: number;
                bytes: number;
                cnt?: number | undefined;
            };
            code: {
                lines: number;
                bytes: number;
                cnt?: number | undefined;
            };
            image: {
                lines: number;
                bytes: number;
                cnt?: number | undefined;
            };
            total: {
                lines: number;
                bytes: number;
                cnt?: number | undefined;
            };
        };
        usage: {
            given: {
                prompt_tokens: number;
                completion_tokens: number;
                total_tokens: number;
            }[];
            calculated: {
                prompt_tokens: number;
                completion_tokens: number;
                total_tokens: number;
            };
        };
        fsRef?: ((In: {
            appSlug: string;
            ownerHandle?: string | undefined;
            userSlug?: string | undefined;
            mode: "dev" | "production";
            fsId: string;
        }) => import("arktype").Out<{
            appSlug: string;
            mode: "dev" | "production";
            fsId: string;
            ownerHandle: string;
        }>) | undefined;
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "block.stats";
        stats: {
            toplevel: {
                lines: number;
                bytes: number;
                cnt?: number | undefined;
            };
            code: {
                lines: number;
                bytes: number;
                cnt?: number | undefined;
            };
            image: {
                lines: number;
                bytes: number;
                cnt?: number | undefined;
            };
            total: {
                lines: number;
                bytes: number;
                cnt?: number | undefined;
            };
        };
        usage: {
            prompt_tokens: number;
            completion_tokens: number;
            total_tokens: number;
        };
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        stats: {
            lines: number;
            bytes: number;
            cnt?: number | undefined;
        };
        type: "block.image";
        sectionId: string;
        url?: string | undefined;
        uploadId?: string | undefined;
        cid?: string | undefined;
        mimeType?: string | undefined;
        size?: number | undefined;
        docWritten?: boolean | undefined;
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "block.code.begin";
        sectionId: string;
        lang: string;
        path?: string | undefined;
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        lineNr: number;
        line: string;
        type: "block.code.line";
        sectionId: string;
        lang: string;
        path?: string | undefined;
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        stats: {
            lines: number;
            bytes: number;
            cnt?: number | undefined;
        };
        type: "block.code.end";
        sectionId: string;
        lang: string;
        path?: string | undefined;
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "block.code.truncated";
        sectionId: string;
        lang: string;
        path?: string | undefined;
        reason: string;
        kind: string;
        truncatedAtLine: number;
        errorCount: number;
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        type: "block.toplevel.begin";
        sectionId: string;
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        lineNr: number;
        line: string;
        type: "block.toplevel.line";
        sectionId: string;
    } | {
        blockId: string;
        streamId: string;
        seq: number;
        blockNr: number;
        timestamp: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
        stats: {
            lines: number;
            bytes: number;
            cnt?: number | undefined;
        };
        type: "block.toplevel.end";
        sectionId: string;
    })[];
}, {}>;
export type ResGetApplicationChat = typeof resGetApplicationChat.infer;
export declare function isResGetApplicationChat(obj: unknown): obj is ResGetApplicationChat;
export declare const reqGetAppByFsId: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-get-app-by-fsid";
    auth?: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    } | undefined;
    fsId?: string | undefined;
    appSlug: string;
    ownerHandle: string;
    token?: string | undefined;
    selectMode?: "ownerLatest" | "published" | undefined;
}, {}>;
export type ReqGetAppByFsId = typeof reqGetAppByFsId.infer;
export declare function isReqGetAppByFsId(obj: unknown): obj is ReqGetAppByFsId;
export declare const resGetAppByFsId: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-get-app-by-fsid";
    error?: string | undefined;
    appSlug: string;
    ownerHandle: string;
    ownerDisplayName?: string | undefined;
    fsId?: string | undefined;
    mode: "dev" | "production";
    grant: "accepted-email-invite" | "first-build-pending" | "granted-access.editor" | "granted-access.submitter" | "granted-access.viewer" | "not-found" | "not-grant" | "owner" | "pending-request" | "public-access" | "req-login.invite" | "req-login.request" | "revoked-access" | "unpublished";
    firstBuildStatus?: "failed" | "parked" | "pending" | "retrying" | undefined;
    firstBuildChatId?: string | undefined;
    firstBuildUpdated?: string | undefined;
    firstBuildIsOwner?: boolean | undefined;
    releaseSeq: number;
    lockedFsId?: string | undefined;
    hasOutboundLinks?: boolean | undefined;
    env: Record<string, string>;
    fileSystem: {
        fileName: string;
        mimeType: string;
        assetId: string;
        assetURI: string;
        transform?: {
            type: "jsx-to-js";
            transformedAssetId: string;
        } | {
            type: "imports";
            importMapAssetId: string;
        } | {
            type: "import-map";
            fromAssetIds: string[];
        } | {
            type: "transformed";
            action: "jsx-to-js";
            transformedAssetId: string;
        } | {
            type: "tailwind-css";
        } | undefined;
        entryPoint?: boolean | undefined;
        size: number;
    }[];
    meta: ({
        type: "screen-shot-ref";
        assetUrl: string;
        mime: string;
    } | {
        type: "title";
        title: string;
    } | {
        type: "remix-of";
        srcFsId: string;
        srcUserId?: string | undefined;
        srcOwnerHandle?: string | undefined;
        srcAppSlug?: string | undefined;
    })[];
    created: string;
}, {}>;
export type ResGetAppByFsId = typeof resGetAppByFsId.infer;
export declare function isResGetAppByFsId(obj: unknown): obj is ResGetAppByFsId;
export declare const reqListVersions: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-list-versions";
    auth?: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    } | undefined;
    appSlug: string;
    ownerHandle: string;
}, {}>;
export type ReqListVersions = typeof reqListVersions.infer;
export declare function isReqListVersions(obj: unknown): obj is ReqListVersions;
export declare const resListVersionsItem: import("arktype/internal/variants/object.ts").ObjectType<{
    fsId: string;
    mode: "dev" | "production";
    releaseSeq: number;
    created: string;
    published: boolean;
}, {}>;
export type ResListVersionsItem = typeof resListVersionsItem.infer;
export declare const resListVersions: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-list-versions";
    appSlug: string;
    ownerHandle: string;
    items: {
        fsId: string;
        mode: "dev" | "production";
        releaseSeq: number;
        created: string;
        published: boolean;
    }[];
    lockedFsId?: string | undefined;
}, {}>;
export type ResListVersions = typeof resListVersions.infer;
export declare function isResListVersions(obj: unknown): obj is ResListVersions;
export declare const reqGetByUserSlugAppSlug: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-get-by-user-slug-app-slug";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    ownerHandle: string;
    appSlug: string;
}, {}>;
export declare const reqListUserSlugAppSlug: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-list-user-slug-app-slug";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    ownerHandle?: string | undefined;
    appSlug?: string | undefined;
}, {}>;
export type ReqListUserSlugAppSlug = typeof reqListUserSlugAppSlug.infer;
export declare function isReqListUserSlugAppSlug(obj: unknown): obj is ReqListUserSlugAppSlug;
export declare const resListUserSlugAppSlugItem: import("arktype/internal/variants/object.ts").ObjectType<{
    userId: string;
    ownerHandle: string;
    appSlugs: string[];
}, {}>;
export type ResListUserSlugAppSlugItem = typeof resListUserSlugAppSlugItem.infer;
export declare const resListUserSlugAppSlug: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-list-user-slug-app-slug";
    items: {
        userId: string;
        ownerHandle: string;
        appSlugs: string[];
    }[];
}, {}>;
export type ResListUserSlugAppSlug = typeof resListUserSlugAppSlug.infer;
export declare function isResListUserSlugAppSlug(obj: unknown): obj is ResListUserSlugAppSlug;
export declare const reqListRecentVibes: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-list-recent-vibes";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    limit?: number | undefined;
    cursor?: string | undefined;
    includeUnpublished?: boolean | undefined;
}, {}>;
export type ReqListRecentVibes = typeof reqListRecentVibes.infer;
export declare function isReqListRecentVibes(obj: unknown): obj is ReqListRecentVibes;
export declare const resRecentVibesItem: import("arktype/internal/variants/object.ts").ObjectType<{
    ownerHandle: string;
    appSlug: string;
    updated: string;
    title?: string | undefined;
    icon?: {
        cid: string;
        mime: string;
    } | undefined;
    pinnedAt?: string | undefined;
    unpublishedAt?: string | undefined;
}, {}>;
export type ResRecentVibesItem = typeof resRecentVibesItem.infer;
export declare const resListRecentVibes: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-list-recent-vibes";
    items: {
        ownerHandle: string;
        appSlug: string;
        updated: string;
        title?: string | undefined;
        icon?: {
            cid: string;
            mime: string;
        } | undefined;
        pinnedAt?: string | undefined;
        unpublishedAt?: string | undefined;
    }[];
    nextCursor?: string | undefined;
}, {}>;
export type ResListRecentVibes = typeof resListRecentVibes.infer;
export declare function isResListRecentVibes(obj: unknown): obj is ResListRecentVibes;
export declare const reqPinRecentVibe: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-pin-recent-vibe";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    ownerHandle: string;
    appSlug: string;
    pin: boolean;
}, {}>;
export type ReqPinRecentVibe = typeof reqPinRecentVibe.infer;
export declare function isReqPinRecentVibe(obj: unknown): obj is ReqPinRecentVibe;
export declare const resPinRecentVibe: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-pin-recent-vibe";
    ownerHandle: string;
    appSlug: string;
    pinnedAt: string;
}, {}>;
export type ResPinRecentVibe = typeof resPinRecentVibe.infer;
export declare function isResPinRecentVibe(obj: unknown): obj is ResPinRecentVibe;
export declare const reqSetUnpublish: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-set-unpublish";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    ownerHandle: string;
    appSlug: string;
    unpublish: boolean;
}, {}>;
export type ReqSetUnpublish = typeof reqSetUnpublish.infer;
export declare function isReqSetUnpublish(obj: unknown): obj is ReqSetUnpublish;
export declare const resSetUnpublish: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-set-unpublish";
    ownerHandle: string;
    appSlug: string;
    unpublishedAt: string;
    previousUnpublishedAt: string;
}, {}>;
export type ResSetUnpublish = typeof resSetUnpublish.infer;
export declare function isResSetUnpublish(obj: unknown): obj is ResSetUnpublish;
export declare const reqSetVersionLock: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-set-version-lock";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    appSlug: string;
    ownerHandle: string;
    fsId?: string | undefined;
}, {}>;
export type ReqSetVersionLock = typeof reqSetVersionLock.infer;
export declare function isReqSetVersionLock(obj: unknown): obj is ReqSetVersionLock;
export declare const resSetVersionLock: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-set-version-lock";
    appSlug: string;
    ownerHandle: string;
    lockedFsId: string;
    previousLockedFsId: string;
}, {}>;
export type ResSetVersionLock = typeof resSetVersionLock.infer;
export declare function isResSetVersionLock(obj: unknown): obj is ResSetVersionLock;
export type ReqGetByUserSlugAppSlug = typeof reqGetByUserSlugAppSlug.infer;
export declare function isReqGetByUserSlugAppSlug(obj: unknown): obj is ReqGetByUserSlugAppSlug;
export declare const resGetByUserSlugAppSlug: import("arktype/internal/variants/object.ts").ObjectType<{
    appSlug: string;
    ownerHandle: string;
    mode: "dev" | "production";
    fsId: string;
    type: "vibes.diy.res-get-by-user-slug-app-slug";
}, {}>;
export type ResGetByUserSlugAppSlug = typeof resGetByUserSlugAppSlug.infer;
export declare function isResGetByUserSlugAppSlug(obj: unknown): obj is ResGetByUserSlugAppSlug;
export declare const reqForkApp: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-fork-app";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    srcUserSlug: string;
    srcAppSlug: string;
    srcFsId?: string | undefined;
    skipChat?: boolean | undefined;
    cacheKey?: string | undefined;
}, {}>;
export type ReqForkApp = typeof reqForkApp.infer;
export declare function isReqForkApp(obj: unknown): obj is ReqForkApp;
export declare const resForkApp: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-fork-app";
    ownerHandle: string;
    appSlug: string;
    chatId: string;
    srcFsId: string;
    srcUserSlug: string;
    srcAppSlug: string;
    seededFromCache?: boolean | undefined;
}, {}>;
export type ResForkApp = typeof resForkApp.infer;
export declare function isResForkApp(obj: unknown): obj is ResForkApp;
export declare const ResSetModeFs: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-set-mode-fs";
    fsId: string;
    appSlug: string;
    ownerHandle: string;
    mode: "dev" | "production";
}, {}>;
export type ResSetModeFs = typeof ResSetModeFs.infer;
export declare function isResSetModeFs(obj: unknown): obj is ResSetModeFs;
export declare const ReqSetModeFs: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-set-mode-fs";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    fsId: string;
    appSlug: string;
    ownerHandle: string;
    mode: "dev" | "production";
}, {}>;
export type ReqSetModeFs = typeof ReqSetModeFs.infer;
export declare const reqSetModeFs: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-set-mode-fs";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    fsId: string;
    appSlug: string;
    ownerHandle: string;
    mode: "dev" | "production";
}, {}>;
export declare function isReqSetModeFs(obj: unknown): obj is ReqSetModeFs;
export declare const reqPublishApp: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-publish-app";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    appSlug: string;
    ownerHandle: string;
    fsId?: string | undefined;
    auto?: boolean | undefined;
}, {}>;
export type ReqPublishApp = typeof reqPublishApp.infer;
export declare function isReqPublishApp(obj: unknown): obj is ReqPublishApp;
export declare const resPublishApp: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-publish-app";
    appSlug: string;
    ownerHandle: string;
    fsId: string;
    releaseSeq: number;
    mode: "production";
    published: boolean;
    suppressed?: boolean | undefined;
}, {}>;
export type ResPublishApp = typeof resPublishApp.infer;
export declare function isResPublishApp(obj: unknown): obj is ResPublishApp;
export declare const reqSeedRemove: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-seed-remove";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    appSlug: string;
    ownerHandle: string;
}, {}>;
export type ReqSeedRemove = typeof reqSeedRemove.infer;
export declare function isReqSeedRemove(obj: unknown): obj is ReqSeedRemove;
export declare const resSeedRemove: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-seed-remove";
    appSlug: string;
    ownerHandle: string;
    removed: number;
    failed: number;
}, {}>;
export type ResSeedRemove = typeof resSeedRemove.infer;
export declare function isResSeedRemove(obj: unknown): obj is ResSeedRemove;
export declare const reqSeedRerun: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-seed-rerun";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    appSlug: string;
    ownerHandle: string;
}, {}>;
export type ReqSeedRerun = typeof reqSeedRerun.infer;
export declare function isReqSeedRerun(obj: unknown): obj is ReqSeedRerun;
export declare const resSeedRerun: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-seed-rerun";
    appSlug: string;
    ownerHandle: string;
    applied: number;
    failed: number;
}, {}>;
export type ResSeedRerun = typeof resSeedRerun.infer;
export declare function isResSeedRerun(obj: unknown): obj is ResSeedRerun;
export declare const ReqListHandleBindings: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-list-user-slug-bindings";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
}, {}>;
export type ReqListHandleBindings = typeof ReqListHandleBindings.infer;
export declare function isReqListHandleBindings(obj: unknown): obj is ReqListHandleBindings;
export declare const HandleBindingItem: import("arktype/internal/variants/object.ts").ObjectType<{
    ownerHandle: string;
    tenant: string;
    created: string;
    appSlugCount: number;
}, {}>;
export type HandleBindingItem = typeof HandleBindingItem.infer;
export declare const ResListHandleBindings: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-list-user-slug-bindings";
    items: {
        ownerHandle: string;
        tenant: string;
        created: string;
        appSlugCount: number;
    }[];
}, {}>;
export type ResListHandleBindings = typeof ResListHandleBindings.infer;
export declare function isResListHandleBindings(obj: unknown): obj is ResListHandleBindings;
export declare const ReqCreateHandleBinding: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-create-user-slug-binding";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    ownerHandle?: string | undefined;
}, {}>;
export type ReqCreateHandleBinding = typeof ReqCreateHandleBinding.infer;
export declare function isReqCreateHandleBinding(obj: unknown): obj is ReqCreateHandleBinding;
export declare const ResCreateHandleBinding: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-create-user-slug-binding";
    ownerHandle: string;
    tenant: string;
    created: string;
}, {}>;
export type ResCreateHandleBinding = typeof ResCreateHandleBinding.infer;
export declare function isResCreateHandleBinding(obj: unknown): obj is ResCreateHandleBinding;
export declare const ReqDeleteHandleBinding: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-delete-user-slug-binding";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    ownerHandle: string;
}, {}>;
export type ReqDeleteHandleBinding = typeof ReqDeleteHandleBinding.infer;
export declare function isReqDeleteHandleBinding(obj: unknown): obj is ReqDeleteHandleBinding;
export declare const ResDeleteHandleBinding: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-delete-user-slug-binding";
    ownerHandle: string;
    deleted: boolean;
}, {}>;
export type ResDeleteHandleBinding = typeof ResDeleteHandleBinding.infer;
export declare function isResDeleteHandleBinding(obj: unknown): obj is ResDeleteHandleBinding;
export declare const ReqSuggestHandleCandidates: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-suggest-handle-candidates";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    count?: number | undefined;
}, {}>;
export type ReqSuggestHandleCandidates = typeof ReqSuggestHandleCandidates.infer;
export declare function isReqSuggestHandleCandidates(obj: unknown): obj is ReqSuggestHandleCandidates;
export declare const ResSuggestHandleCandidates: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-suggest-handle-candidates";
    wordSlugs: string[];
    clerkSuggestions: string[];
}, {}>;
export type ResSuggestHandleCandidates = typeof ResSuggestHandleCandidates.infer;
export declare function isResSuggestHandleCandidates(obj: unknown): obj is ResSuggestHandleCandidates;
export declare const ReqConfirmPlaceholderHandle: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-confirm-placeholder-handle";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    appSlug: string;
    ownerHandle: string;
    routeHandle: string;
}, {}>;
export type ReqConfirmPlaceholderHandle = typeof ReqConfirmPlaceholderHandle.infer;
export declare function isReqConfirmPlaceholderHandle(obj: unknown): obj is ReqConfirmPlaceholderHandle;
export declare const ResConfirmPlaceholderHandle: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-confirm-placeholder-handle";
    ownerHandle: string;
    appSlug: string;
    chosenHandle: string;
    defaultHandle: string;
    moved: boolean;
}, {}>;
export type ResConfirmPlaceholderHandle = typeof ResConfirmPlaceholderHandle.infer;
export declare function isResConfirmPlaceholderHandle(obj: unknown): obj is ResConfirmPlaceholderHandle;
export declare const reqListNotifications: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-list-notifications";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    appSlug?: string | undefined;
    ownerHandle?: string | undefined;
    notificationType?: "access-requested" | "app-message" | "build-complete" | "build-failed" | "comment-posted" | "dm-received" | "follow-approved" | "follow-request" | "follower-added" | "member-joined" | "request-approved" | "request-revoked" | "vibe-published" | "vibe-remixed" | undefined;
    cursor?: string | undefined;
    limit?: number | undefined;
}, {}>;
export type ReqListNotifications = typeof reqListNotifications.infer;
export declare function isReqListNotifications(obj: unknown): obj is ReqListNotifications;
export declare const resListNotifications: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-list-notifications";
    items: {
        id: string;
        userId: string;
        notificationType: "access-requested" | "app-message" | "build-complete" | "build-failed" | "comment-posted" | "dm-received" | "follow-approved" | "follow-request" | "follower-added" | "member-joined" | "request-approved" | "request-revoked" | "vibe-published" | "vibe-remixed";
        ownerHandle: string;
        appSlug: string | null;
        body: string;
        actorHandle?: string | null | undefined;
        actorUserId?: string | null | undefined;
        targetRef?: unknown;
        dedupeKey: string;
        created: string;
        readAt?: string | null | undefined;
    }[];
    nextCursor?: string | undefined;
    unreadCount: number;
}, {}>;
export type ResListNotifications = typeof resListNotifications.infer;
export declare function isResListNotifications(obj: unknown): obj is ResListNotifications;
export declare const reqMarkNotificationsRead: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.req-mark-notifications-read";
    auth: {
        type: "clerk" | "device-id" | "ucan";
        token: string;
    };
    ids?: string[] | undefined;
}, {}>;
export type ReqMarkNotificationsRead = typeof reqMarkNotificationsRead.infer;
export declare function isReqMarkNotificationsRead(obj: unknown): obj is ReqMarkNotificationsRead;
export declare const resMarkNotificationsRead: import("arktype/internal/variants/object.ts").ObjectType<{
    type: "vibes.diy.res-mark-notifications-read";
    ok: number;
}, {}>;
export type ResMarkNotificationsRead = typeof resMarkNotificationsRead.infer;
export declare function isResMarkNotificationsRead(obj: unknown): obj is ResMarkNotificationsRead;
export {};