export declare const LIVE_PLUGIN_BUNDLE_V1_JSON_SCHEMA: Readonly<{
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://thortiq.local/schemas/live-plugin-bundle-v1.json";
    readonly title: "Thortiq Live Plugin Bundle v1";
    readonly type: "object";
    readonly required: readonly ["formatVersion", "pluginId", "apiVersion", "revision", "parentRevision", "manifest", "javascript", "css", "provenance"];
    readonly properties: {
        readonly provenance: Readonly<{
            type: "object";
            required: string[];
            properties: {
                schemaVersion: {
                    const: number;
                };
                authorKind: {
                    enum: readonly ["user", "assistant", "system"];
                };
                actorId: {
                    type: string;
                    minLength: number;
                    maxLength: 128;
                };
                authoredAt: {
                    type: string;
                    format: string;
                };
                operation: {
                    enum: readonly ["create", "update", "restore", "reconcile"];
                };
                toolId: {
                    type: string;
                    minLength: number;
                    maxLength: 128;
                };
            };
            additionalProperties: false;
        }>;
        readonly manifest: {
            $schema: undefined;
            $id: undefined;
            title: undefined;
            properties: {
                runtime: {
                    const: string;
                };
                manifestVersion: {
                    readonly const: 2;
                };
                id: {
                    readonly type: "string";
                    readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                    readonly maxLength: 64;
                };
                name: Readonly<{
                    type: "string";
                    minLength: 1;
                    maxLength: 256;
                }>;
                description: {
                    readonly type: "string";
                    readonly maxLength: 2048;
                };
                author: Readonly<{
                    type: "string";
                    minLength: 1;
                    maxLength: 256;
                }>;
                version: {
                    readonly type: "string";
                    readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$";
                };
                apiVersion: {
                    readonly type: "string";
                    readonly maxLength: 64;
                };
                platforms: {
                    readonly type: "array";
                    readonly minItems: 1;
                    readonly maxItems: 3;
                    readonly uniqueItems: true;
                    readonly items: {
                        readonly enum: readonly ["web", "capacitor", "desktop"];
                    };
                };
                permissions: {
                    readonly type: "array";
                    readonly maxItems: 17;
                    readonly uniqueItems: true;
                    readonly items: {
                        readonly enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                    };
                };
                entry: {
                    readonly type: "string";
                    readonly maxLength: 4096;
                };
                styles: {
                    readonly type: "array";
                    readonly minItems: 1;
                    readonly maxItems: number;
                    readonly uniqueItems: true;
                    readonly items: {
                        readonly type: "string";
                        readonly maxLength: 4096;
                    };
                };
                assets: {
                    readonly type: "array";
                    readonly minItems: 1;
                    readonly maxItems: number;
                    readonly uniqueItems: true;
                    readonly items: {
                        readonly type: "string";
                        readonly maxLength: 4096;
                    };
                };
                integrity: {
                    readonly type: "object";
                    readonly maxProperties: number;
                    readonly patternProperties: {
                        readonly "^.+$": {
                            readonly type: "string";
                            readonly pattern: "^sha256:[0-9a-f]{64}$";
                        };
                    };
                    readonly additionalProperties: false;
                };
                editorExtensionBuild: {
                    readonly type: "object";
                    readonly required: readonly ["proofVersion", "path"];
                    readonly properties: {
                        readonly proofVersion: {
                            readonly const: 1;
                        };
                        readonly path: {
                            readonly type: "string";
                            readonly maxLength: 4096;
                        };
                    };
                    readonly additionalProperties: false;
                };
                network: Readonly<{
                    type: "array";
                    maxItems: 32;
                    items: {
                        oneOf: ({
                            type: string;
                            required: string[];
                            properties: {
                                id: Readonly<{
                                    type: "string";
                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                    maxLength: 64;
                                }>;
                                origin: {
                                    type: string;
                                    format: string;
                                    pattern: string;
                                };
                                originSetting?: undefined;
                                requireHttps?: undefined;
                            };
                            additionalProperties: boolean;
                        } | {
                            type: string;
                            required: string[];
                            properties: {
                                id: Readonly<{
                                    type: "string";
                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                    maxLength: 64;
                                }>;
                                originSetting: {
                                    type: string;
                                    maxLength: 128;
                                };
                                requireHttps: {
                                    const: boolean;
                                };
                                origin?: undefined;
                            };
                            additionalProperties: boolean;
                        })[];
                    };
                }>;
                contributes: Readonly<{
                    type: "object";
                    minProperties: 1;
                    maxProperties: 10;
                    properties: {
                        views: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                };
                                additionalProperties: false;
                            }>;
                        };
                        commands: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                };
                                additionalProperties: false;
                            }>;
                        };
                        navigationItems: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: {
                                required: string[];
                                properties: {
                                    view: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                };
                                type: "object";
                                additionalProperties: false;
                            };
                        };
                        searchPresentations: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                };
                                additionalProperties: false;
                            }>;
                        };
                        markdownBlocks: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    runtime: {
                                        enum: readonly ["native", "sandboxed-page", "live-sandboxed"];
                                    };
                                    rendererMode: {
                                        enum: readonly ["native-imperative", "live-declarative"];
                                    };
                                    configSchema: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            version: {
                                                const: number;
                                            };
                                            type: {
                                                const: string;
                                            };
                                            properties: {
                                                type: string;
                                                maxProperties: 64;
                                                patternProperties: {
                                                    [x: string]: Readonly<{
                                                        oneOf: ({
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                    enum?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                minimum?: undefined;
                                                                maximum?: undefined;
                                                                enum?: undefined;
                                                                minLength?: undefined;
                                                                maxLength?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    enum: string[];
                                                                    const?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                minimum: {
                                                                    type: string;
                                                                };
                                                                maximum: {
                                                                    type: string;
                                                                };
                                                                enum?: undefined;
                                                                minLength?: undefined;
                                                                maxLength?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                    enum?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                enum: {
                                                                    type: string;
                                                                    minItems: number;
                                                                    maxItems: 64;
                                                                    uniqueItems: boolean;
                                                                    items: {
                                                                        type: string;
                                                                        maxLength: 2048;
                                                                    };
                                                                };
                                                                minLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                    maximum: number;
                                                                };
                                                                maxLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                    maximum: number;
                                                                };
                                                                minimum?: undefined;
                                                                maximum?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        })[];
                                                    }>;
                                                };
                                                additionalProperties: boolean;
                                            };
                                            required: {
                                                type: string;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: {
                                                    type: string;
                                                    pattern: string;
                                                    maxLength: 128;
                                                };
                                            };
                                            additionalProperties: {
                                                const: boolean;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                    permissions: {
                                        type: string;
                                        maxItems: 17;
                                        uniqueItems: boolean;
                                        items: {
                                            enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                        };
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                        editorExtensions: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    hostApiVersion: {
                                        const: "1.0.0";
                                    };
                                    appliesTo: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            noteTypes: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                            };
                                            modes: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 2;
                                                uniqueItems: boolean;
                                                items: {
                                                    enum: readonly ["edit", "read"];
                                                };
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                    priority: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            tier: {
                                                enum: readonly ["low", "normal", "high"];
                                            };
                                            order: {
                                                type: string;
                                                minimum: -1000;
                                                maximum: 1000;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                    configSchema: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            version: {
                                                const: number;
                                            };
                                            type: {
                                                const: string;
                                            };
                                            properties: {
                                                type: string;
                                                maxProperties: 64;
                                                patternProperties: {
                                                    [x: string]: Readonly<{
                                                        oneOf: ({
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                    enum?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                minimum?: undefined;
                                                                maximum?: undefined;
                                                                enum?: undefined;
                                                                minLength?: undefined;
                                                                maxLength?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    enum: string[];
                                                                    const?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                minimum: {
                                                                    type: string;
                                                                };
                                                                maximum: {
                                                                    type: string;
                                                                };
                                                                enum?: undefined;
                                                                minLength?: undefined;
                                                                maxLength?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                    enum?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                enum: {
                                                                    type: string;
                                                                    minItems: number;
                                                                    maxItems: 64;
                                                                    uniqueItems: boolean;
                                                                    items: {
                                                                        type: string;
                                                                        maxLength: 2048;
                                                                    };
                                                                };
                                                                minLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                    maximum: number;
                                                                };
                                                                maxLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                    maximum: number;
                                                                };
                                                                minimum?: undefined;
                                                                maximum?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        })[];
                                                    }>;
                                                };
                                                additionalProperties: boolean;
                                            };
                                            required: {
                                                type: string;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: {
                                                    type: string;
                                                    pattern: string;
                                                    maxLength: 128;
                                                };
                                            };
                                            additionalProperties: {
                                                const: boolean;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                        noteActions: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    runtime: {
                                        const: string;
                                    };
                                    permissions: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 17;
                                        uniqueItems: boolean;
                                        items: {
                                            enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                        };
                                        contains: {
                                            const: string;
                                        };
                                    };
                                    surfaces: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 2;
                                        uniqueItems: boolean;
                                        items: {
                                            enum: readonly ["editor", "search"];
                                        };
                                    };
                                    appliesTo: {
                                        type: string;
                                        properties: {
                                            noteTypes: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                            };
                                            allTags: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 128;
                                                }>;
                                            };
                                            anyTags: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 128;
                                                }>;
                                            };
                                            requiredProperties: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 128;
                                                }>;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                        fileViewers: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    runtime: {
                                        enum: readonly ["native", "sandboxed-page", "live-sandboxed"];
                                    };
                                    rendererMode: {
                                        enum: readonly ["native-imperative", "sandboxed-page", "live-declarative"];
                                    };
                                    permissions: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 17;
                                        uniqueItems: boolean;
                                        items: {
                                            enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                        };
                                        allOf: {
                                            contains: {
                                                const: string;
                                            };
                                        }[];
                                    };
                                    extensions: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 32;
                                        uniqueItems: boolean;
                                        items: {
                                            type: string;
                                            pattern: string;
                                        };
                                    };
                                    mediaTypes: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 32;
                                        uniqueItems: boolean;
                                        items: {
                                            type: string;
                                            pattern: string;
                                        };
                                    };
                                    maxBytes: {
                                        type: string;
                                        minimum: number;
                                        maximum: number;
                                    };
                                    content: {
                                        enum: string[];
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                        settings: Readonly<{
                            type: "object";
                            required: string[];
                            properties: {
                                sections: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 32;
                                    items: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            fields: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 256;
                                                items: Readonly<{
                                                    type: "object";
                                                    required: string[];
                                                    properties: {
                                                        key: {
                                                            type: string;
                                                            pattern: string;
                                                            maxLength: 128;
                                                        };
                                                        type: {
                                                            enum: readonly ["text", "textarea", "number", "checkbox", "select", "url", "note", "folder", "asset", "secret"];
                                                        };
                                                        title: Readonly<{
                                                            type: "string";
                                                            minLength: 1;
                                                            maxLength: 256;
                                                        }>;
                                                        description: {
                                                            type: string;
                                                            maxLength: 2048;
                                                        };
                                                        required: {
                                                            type: string;
                                                        };
                                                        storage: {
                                                            enum: readonly ["synced", "local", "encrypted-secret"];
                                                        };
                                                        placeholder: {
                                                            type: string;
                                                            maxLength: 2048;
                                                        };
                                                        default: {
                                                            type: string[];
                                                        };
                                                        minLength: {
                                                            type: string;
                                                            minimum: number;
                                                        };
                                                        maxLength: {
                                                            type: string;
                                                            minimum: number;
                                                        };
                                                        min: {
                                                            type: string;
                                                        };
                                                        max: {
                                                            type: string;
                                                        };
                                                        step: {
                                                            type: string;
                                                            exclusiveMinimum: number;
                                                        };
                                                        sensitiveName: {
                                                            type: string;
                                                        };
                                                        options: {
                                                            type: string;
                                                            minItems: number;
                                                            maxItems: 256;
                                                            items: {
                                                                type: string;
                                                                required: string[];
                                                                properties: {
                                                                    value: {
                                                                        type: string;
                                                                        maxLength: 128;
                                                                    };
                                                                    title: Readonly<{
                                                                        type: "string";
                                                                        minLength: 1;
                                                                        maxLength: 256;
                                                                    }>;
                                                                };
                                                                additionalProperties: boolean;
                                                            };
                                                        };
                                                    };
                                                    additionalProperties: false;
                                                    allOf: {
                                                        if: {
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                };
                                                            };
                                                            required: string[];
                                                        };
                                                        then: {
                                                            properties: {
                                                                storage: {
                                                                    const: string;
                                                                };
                                                            };
                                                        };
                                                        else: {
                                                            properties: {
                                                                storage: {
                                                                    enum: string[];
                                                                };
                                                                sensitiveName: boolean;
                                                            };
                                                        };
                                                    }[];
                                                }>;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                };
                            };
                            additionalProperties: false;
                        }>;
                        jobs: {
                            type: string;
                            minItems: number;
                            maxItems: 32;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    triggers: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 8;
                                        items: Readonly<{
                                            oneOf: ({
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    noteSetting?: undefined;
                                                    minutes?: undefined;
                                                    minutesSetting?: undefined;
                                                    command?: undefined;
                                                    pathSetting?: undefined;
                                                };
                                                additionalProperties: boolean;
                                                oneOf?: undefined;
                                            } | {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    noteSetting: {
                                                        type: string;
                                                        maxLength: 128;
                                                    };
                                                    minutes?: undefined;
                                                    minutesSetting?: undefined;
                                                    command?: undefined;
                                                    pathSetting?: undefined;
                                                };
                                                additionalProperties: boolean;
                                                oneOf?: undefined;
                                            } | {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    minutes: {
                                                        type: string;
                                                        minimum: 5;
                                                        maximum: 1440;
                                                    };
                                                    minutesSetting: {
                                                        type: string;
                                                        maxLength: 128;
                                                    };
                                                    noteSetting?: undefined;
                                                    command?: undefined;
                                                    pathSetting?: undefined;
                                                };
                                                oneOf: {
                                                    required: string[];
                                                }[];
                                                additionalProperties: boolean;
                                            } | {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    command: Readonly<{
                                                        type: "string";
                                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                        maxLength: 64;
                                                    }>;
                                                    noteSetting?: undefined;
                                                    minutes?: undefined;
                                                    minutesSetting?: undefined;
                                                    pathSetting?: undefined;
                                                };
                                                additionalProperties: boolean;
                                                oneOf?: undefined;
                                            } | {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    pathSetting: {
                                                        type: string;
                                                        maxLength: 128;
                                                    };
                                                    noteSetting?: undefined;
                                                    minutes?: undefined;
                                                    minutesSetting?: undefined;
                                                    command?: undefined;
                                                };
                                                additionalProperties: boolean;
                                                oneOf?: undefined;
                                            })[];
                                        }>;
                                    };
                                    concurrency: {
                                        const: string;
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                    };
                    additionalProperties: false;
                }>;
            };
            type: "object";
            required: readonly ["manifestVersion", "id", "name", "version", "apiVersion", "runtime", "platforms", "permissions", "contributes"];
            additionalProperties: false;
            oneOf: readonly [{
                readonly properties: {
                    readonly runtime: {
                        readonly enum: readonly ["native", "sandboxed-page"];
                    };
                };
                readonly required: readonly ["entry", "integrity"];
            }, {
                readonly properties: {
                    readonly runtime: {
                        readonly const: "live-sandboxed";
                    };
                    readonly entry: false;
                    readonly styles: false;
                    readonly assets: false;
                    readonly integrity: false;
                    readonly editorExtensionBuild: false;
                };
            }];
            allOf: readonly [{
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly contributes: {
                            readonly not: {
                                readonly required: readonly ["searchPresentations"];
                            };
                        };
                    };
                };
            }, {
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly editorExtensionBuild: false;
                        readonly contributes: {
                            readonly not: {
                                readonly required: readonly ["editorExtensions"];
                            };
                        };
                    };
                };
            }, {
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly const: "sandboxed-page";
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly contributes: {
                            readonly not: {
                                readonly required: readonly ["markdownBlocks"];
                            };
                        };
                    };
                };
            }, {
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly contributes: {
                            readonly not: {
                                readonly required: readonly ["noteActions"];
                            };
                        };
                    };
                };
            }, {
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly const: "live-sandboxed";
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly contributes: {
                            readonly properties: {
                                readonly fileViewers: {
                                    readonly items: {
                                        readonly properties: {
                                            readonly content: {
                                                readonly const: "text";
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }];
            "x-thortiq-runtime-validation": readonly ["canonical NFC identities and paths", "exact integrity key equality", "cross-contribution references", "permission/runtime coherence", "setting-derived connection references"];
        };
        readonly javascript: {
            type: string;
            "x-thortiq-maxUtf8Bytes": number;
        };
        readonly css: {
            type: string;
            "x-thortiq-maxUtf8Bytes": number;
        };
        readonly settingsSchema: Readonly<{
            type: "object";
            required: string[];
            properties: {
                sections: {
                    type: string;
                    minItems: number;
                    maxItems: 32;
                    items: {
                        type: string;
                        required: string[];
                        properties: {
                            id: Readonly<{
                                type: "string";
                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                maxLength: 64;
                            }>;
                            title: Readonly<{
                                type: "string";
                                minLength: 1;
                                maxLength: 256;
                            }>;
                            fields: {
                                type: string;
                                minItems: number;
                                maxItems: 256;
                                items: Readonly<{
                                    type: "object";
                                    required: string[];
                                    properties: {
                                        key: {
                                            type: string;
                                            pattern: string;
                                            maxLength: 128;
                                        };
                                        type: {
                                            enum: readonly ["text", "textarea", "number", "checkbox", "select", "url", "note", "folder", "asset", "secret"];
                                        };
                                        title: Readonly<{
                                            type: "string";
                                            minLength: 1;
                                            maxLength: 256;
                                        }>;
                                        description: {
                                            type: string;
                                            maxLength: 2048;
                                        };
                                        required: {
                                            type: string;
                                        };
                                        storage: {
                                            enum: readonly ["synced", "local", "encrypted-secret"];
                                        };
                                        placeholder: {
                                            type: string;
                                            maxLength: 2048;
                                        };
                                        default: {
                                            type: string[];
                                        };
                                        minLength: {
                                            type: string;
                                            minimum: number;
                                        };
                                        maxLength: {
                                            type: string;
                                            minimum: number;
                                        };
                                        min: {
                                            type: string;
                                        };
                                        max: {
                                            type: string;
                                        };
                                        step: {
                                            type: string;
                                            exclusiveMinimum: number;
                                        };
                                        sensitiveName: {
                                            type: string;
                                        };
                                        options: {
                                            type: string;
                                            minItems: number;
                                            maxItems: 256;
                                            items: {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    value: {
                                                        type: string;
                                                        maxLength: 128;
                                                    };
                                                    title: Readonly<{
                                                        type: "string";
                                                        minLength: 1;
                                                        maxLength: 256;
                                                    }>;
                                                };
                                                additionalProperties: boolean;
                                            };
                                        };
                                    };
                                    additionalProperties: false;
                                    allOf: {
                                        if: {
                                            properties: {
                                                type: {
                                                    const: string;
                                                };
                                            };
                                            required: string[];
                                        };
                                        then: {
                                            properties: {
                                                storage: {
                                                    const: string;
                                                };
                                            };
                                        };
                                        else: {
                                            properties: {
                                                storage: {
                                                    enum: string[];
                                                };
                                                sensitiveName: boolean;
                                            };
                                        };
                                    }[];
                                }>;
                            };
                        };
                        additionalProperties: boolean;
                    };
                };
            };
            additionalProperties: false;
        }>;
        readonly formatVersion: {
            readonly const: 1;
        };
        readonly pluginId: {
            readonly type: "string";
            readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
            readonly maxLength: 64;
        };
        readonly apiVersion: {
            readonly type: "string";
            readonly maxLength: 64;
        };
        readonly revision: Readonly<{
            type: "string";
            pattern: "^sha256:[0-9a-f]{64}$";
        }>;
        readonly parentRevision: {
            readonly oneOf: readonly [Readonly<{
                type: "string";
                pattern: "^sha256:[0-9a-f]{64}$";
            }>, {
                readonly type: "null";
            }];
        };
    };
    readonly additionalProperties: false;
    readonly "x-thortiq-maxUtf8Bytes": number;
    readonly "x-thortiq-runtime-validation": readonly ["canonical LF line endings", "NFC normalization only for schema-defined identifiers and keys", "bundle and manifest identity equality", "duplicate settings schema equality", "SHA-256 over every authoritative field except revision", "manifest/settings/provenance aggregate UTF-8 limit"];
}>;
export declare const LIVE_PLUGIN_PATCH_V1_JSON_SCHEMA: Readonly<{
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://thortiq.local/schemas/live-plugin-patch-v1.json";
    readonly title: "Thortiq Live Plugin Patch v1";
    readonly type: "object";
    readonly minProperties: 1;
    readonly properties: {
        readonly settingsSchema: {
            readonly oneOf: readonly [Readonly<{
                type: "object";
                required: string[];
                properties: {
                    sections: {
                        type: string;
                        minItems: number;
                        maxItems: 32;
                        items: {
                            type: string;
                            required: string[];
                            properties: {
                                id: Readonly<{
                                    type: "string";
                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                    maxLength: 64;
                                }>;
                                title: Readonly<{
                                    type: "string";
                                    minLength: 1;
                                    maxLength: 256;
                                }>;
                                fields: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 256;
                                    items: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            key: {
                                                type: string;
                                                pattern: string;
                                                maxLength: 128;
                                            };
                                            type: {
                                                enum: readonly ["text", "textarea", "number", "checkbox", "select", "url", "note", "folder", "asset", "secret"];
                                            };
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            description: {
                                                type: string;
                                                maxLength: 2048;
                                            };
                                            required: {
                                                type: string;
                                            };
                                            storage: {
                                                enum: readonly ["synced", "local", "encrypted-secret"];
                                            };
                                            placeholder: {
                                                type: string;
                                                maxLength: 2048;
                                            };
                                            default: {
                                                type: string[];
                                            };
                                            minLength: {
                                                type: string;
                                                minimum: number;
                                            };
                                            maxLength: {
                                                type: string;
                                                minimum: number;
                                            };
                                            min: {
                                                type: string;
                                            };
                                            max: {
                                                type: string;
                                            };
                                            step: {
                                                type: string;
                                                exclusiveMinimum: number;
                                            };
                                            sensitiveName: {
                                                type: string;
                                            };
                                            options: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 256;
                                                items: {
                                                    type: string;
                                                    required: string[];
                                                    properties: {
                                                        value: {
                                                            type: string;
                                                            maxLength: 128;
                                                        };
                                                        title: Readonly<{
                                                            type: "string";
                                                            minLength: 1;
                                                            maxLength: 256;
                                                        }>;
                                                    };
                                                    additionalProperties: boolean;
                                                };
                                            };
                                        };
                                        additionalProperties: false;
                                        allOf: {
                                            if: {
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                };
                                                required: string[];
                                            };
                                            then: {
                                                properties: {
                                                    storage: {
                                                        const: string;
                                                    };
                                                };
                                            };
                                            else: {
                                                properties: {
                                                    storage: {
                                                        enum: string[];
                                                    };
                                                    sensitiveName: boolean;
                                                };
                                            };
                                        }[];
                                    }>;
                                };
                            };
                            additionalProperties: boolean;
                        };
                    };
                };
                additionalProperties: false;
            }>, {
                readonly type: "null";
            }];
        };
        readonly manifest: {
            $schema: undefined;
            $id: undefined;
            title: undefined;
            properties: {
                runtime: {
                    const: string;
                };
                manifestVersion: {
                    readonly const: 2;
                };
                id: {
                    readonly type: "string";
                    readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                    readonly maxLength: 64;
                };
                name: Readonly<{
                    type: "string";
                    minLength: 1;
                    maxLength: 256;
                }>;
                description: {
                    readonly type: "string";
                    readonly maxLength: 2048;
                };
                author: Readonly<{
                    type: "string";
                    minLength: 1;
                    maxLength: 256;
                }>;
                version: {
                    readonly type: "string";
                    readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$";
                };
                apiVersion: {
                    readonly type: "string";
                    readonly maxLength: 64;
                };
                platforms: {
                    readonly type: "array";
                    readonly minItems: 1;
                    readonly maxItems: 3;
                    readonly uniqueItems: true;
                    readonly items: {
                        readonly enum: readonly ["web", "capacitor", "desktop"];
                    };
                };
                permissions: {
                    readonly type: "array";
                    readonly maxItems: 17;
                    readonly uniqueItems: true;
                    readonly items: {
                        readonly enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                    };
                };
                entry: {
                    readonly type: "string";
                    readonly maxLength: 4096;
                };
                styles: {
                    readonly type: "array";
                    readonly minItems: 1;
                    readonly maxItems: number;
                    readonly uniqueItems: true;
                    readonly items: {
                        readonly type: "string";
                        readonly maxLength: 4096;
                    };
                };
                assets: {
                    readonly type: "array";
                    readonly minItems: 1;
                    readonly maxItems: number;
                    readonly uniqueItems: true;
                    readonly items: {
                        readonly type: "string";
                        readonly maxLength: 4096;
                    };
                };
                integrity: {
                    readonly type: "object";
                    readonly maxProperties: number;
                    readonly patternProperties: {
                        readonly "^.+$": {
                            readonly type: "string";
                            readonly pattern: "^sha256:[0-9a-f]{64}$";
                        };
                    };
                    readonly additionalProperties: false;
                };
                editorExtensionBuild: {
                    readonly type: "object";
                    readonly required: readonly ["proofVersion", "path"];
                    readonly properties: {
                        readonly proofVersion: {
                            readonly const: 1;
                        };
                        readonly path: {
                            readonly type: "string";
                            readonly maxLength: 4096;
                        };
                    };
                    readonly additionalProperties: false;
                };
                network: Readonly<{
                    type: "array";
                    maxItems: 32;
                    items: {
                        oneOf: ({
                            type: string;
                            required: string[];
                            properties: {
                                id: Readonly<{
                                    type: "string";
                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                    maxLength: 64;
                                }>;
                                origin: {
                                    type: string;
                                    format: string;
                                    pattern: string;
                                };
                                originSetting?: undefined;
                                requireHttps?: undefined;
                            };
                            additionalProperties: boolean;
                        } | {
                            type: string;
                            required: string[];
                            properties: {
                                id: Readonly<{
                                    type: "string";
                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                    maxLength: 64;
                                }>;
                                originSetting: {
                                    type: string;
                                    maxLength: 128;
                                };
                                requireHttps: {
                                    const: boolean;
                                };
                                origin?: undefined;
                            };
                            additionalProperties: boolean;
                        })[];
                    };
                }>;
                contributes: Readonly<{
                    type: "object";
                    minProperties: 1;
                    maxProperties: 10;
                    properties: {
                        views: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                };
                                additionalProperties: false;
                            }>;
                        };
                        commands: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                };
                                additionalProperties: false;
                            }>;
                        };
                        navigationItems: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: {
                                required: string[];
                                properties: {
                                    view: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                };
                                type: "object";
                                additionalProperties: false;
                            };
                        };
                        searchPresentations: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                };
                                additionalProperties: false;
                            }>;
                        };
                        markdownBlocks: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    runtime: {
                                        enum: readonly ["native", "sandboxed-page", "live-sandboxed"];
                                    };
                                    rendererMode: {
                                        enum: readonly ["native-imperative", "live-declarative"];
                                    };
                                    configSchema: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            version: {
                                                const: number;
                                            };
                                            type: {
                                                const: string;
                                            };
                                            properties: {
                                                type: string;
                                                maxProperties: 64;
                                                patternProperties: {
                                                    [x: string]: Readonly<{
                                                        oneOf: ({
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                    enum?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                minimum?: undefined;
                                                                maximum?: undefined;
                                                                enum?: undefined;
                                                                minLength?: undefined;
                                                                maxLength?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    enum: string[];
                                                                    const?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                minimum: {
                                                                    type: string;
                                                                };
                                                                maximum: {
                                                                    type: string;
                                                                };
                                                                enum?: undefined;
                                                                minLength?: undefined;
                                                                maxLength?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                    enum?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                enum: {
                                                                    type: string;
                                                                    minItems: number;
                                                                    maxItems: 64;
                                                                    uniqueItems: boolean;
                                                                    items: {
                                                                        type: string;
                                                                        maxLength: 2048;
                                                                    };
                                                                };
                                                                minLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                    maximum: number;
                                                                };
                                                                maxLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                    maximum: number;
                                                                };
                                                                minimum?: undefined;
                                                                maximum?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        })[];
                                                    }>;
                                                };
                                                additionalProperties: boolean;
                                            };
                                            required: {
                                                type: string;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: {
                                                    type: string;
                                                    pattern: string;
                                                    maxLength: 128;
                                                };
                                            };
                                            additionalProperties: {
                                                const: boolean;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                    permissions: {
                                        type: string;
                                        maxItems: 17;
                                        uniqueItems: boolean;
                                        items: {
                                            enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                        };
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                        editorExtensions: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    hostApiVersion: {
                                        const: "1.0.0";
                                    };
                                    appliesTo: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            noteTypes: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                            };
                                            modes: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 2;
                                                uniqueItems: boolean;
                                                items: {
                                                    enum: readonly ["edit", "read"];
                                                };
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                    priority: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            tier: {
                                                enum: readonly ["low", "normal", "high"];
                                            };
                                            order: {
                                                type: string;
                                                minimum: -1000;
                                                maximum: 1000;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                    configSchema: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            version: {
                                                const: number;
                                            };
                                            type: {
                                                const: string;
                                            };
                                            properties: {
                                                type: string;
                                                maxProperties: 64;
                                                patternProperties: {
                                                    [x: string]: Readonly<{
                                                        oneOf: ({
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                    enum?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                minimum?: undefined;
                                                                maximum?: undefined;
                                                                enum?: undefined;
                                                                minLength?: undefined;
                                                                maxLength?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    enum: string[];
                                                                    const?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                minimum: {
                                                                    type: string;
                                                                };
                                                                maximum: {
                                                                    type: string;
                                                                };
                                                                enum?: undefined;
                                                                minLength?: undefined;
                                                                maxLength?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                    enum?: undefined;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string;
                                                                };
                                                                enum: {
                                                                    type: string;
                                                                    minItems: number;
                                                                    maxItems: 64;
                                                                    uniqueItems: boolean;
                                                                    items: {
                                                                        type: string;
                                                                        maxLength: 2048;
                                                                    };
                                                                };
                                                                minLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                    maximum: number;
                                                                };
                                                                maxLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                    maximum: number;
                                                                };
                                                                minimum?: undefined;
                                                                maximum?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                        })[];
                                                    }>;
                                                };
                                                additionalProperties: boolean;
                                            };
                                            required: {
                                                type: string;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: {
                                                    type: string;
                                                    pattern: string;
                                                    maxLength: 128;
                                                };
                                            };
                                            additionalProperties: {
                                                const: boolean;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                        noteActions: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    runtime: {
                                        const: string;
                                    };
                                    permissions: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 17;
                                        uniqueItems: boolean;
                                        items: {
                                            enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                        };
                                        contains: {
                                            const: string;
                                        };
                                    };
                                    surfaces: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 2;
                                        uniqueItems: boolean;
                                        items: {
                                            enum: readonly ["editor", "search"];
                                        };
                                    };
                                    appliesTo: {
                                        type: string;
                                        properties: {
                                            noteTypes: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                            };
                                            allTags: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 128;
                                                }>;
                                            };
                                            anyTags: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 128;
                                                }>;
                                            };
                                            requiredProperties: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 64;
                                                uniqueItems: boolean;
                                                items: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 128;
                                                }>;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                        fileViewers: {
                            type: string;
                            minItems: number;
                            maxItems: 256;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    icon: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    runtime: {
                                        enum: readonly ["native", "sandboxed-page", "live-sandboxed"];
                                    };
                                    rendererMode: {
                                        enum: readonly ["native-imperative", "sandboxed-page", "live-declarative"];
                                    };
                                    permissions: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 17;
                                        uniqueItems: boolean;
                                        items: {
                                            enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                        };
                                        allOf: {
                                            contains: {
                                                const: string;
                                            };
                                        }[];
                                    };
                                    extensions: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 32;
                                        uniqueItems: boolean;
                                        items: {
                                            type: string;
                                            pattern: string;
                                        };
                                    };
                                    mediaTypes: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 32;
                                        uniqueItems: boolean;
                                        items: {
                                            type: string;
                                            pattern: string;
                                        };
                                    };
                                    maxBytes: {
                                        type: string;
                                        minimum: number;
                                        maximum: number;
                                    };
                                    content: {
                                        enum: string[];
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                        settings: Readonly<{
                            type: "object";
                            required: string[];
                            properties: {
                                sections: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 32;
                                    items: {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            fields: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 256;
                                                items: Readonly<{
                                                    type: "object";
                                                    required: string[];
                                                    properties: {
                                                        key: {
                                                            type: string;
                                                            pattern: string;
                                                            maxLength: 128;
                                                        };
                                                        type: {
                                                            enum: readonly ["text", "textarea", "number", "checkbox", "select", "url", "note", "folder", "asset", "secret"];
                                                        };
                                                        title: Readonly<{
                                                            type: "string";
                                                            minLength: 1;
                                                            maxLength: 256;
                                                        }>;
                                                        description: {
                                                            type: string;
                                                            maxLength: 2048;
                                                        };
                                                        required: {
                                                            type: string;
                                                        };
                                                        storage: {
                                                            enum: readonly ["synced", "local", "encrypted-secret"];
                                                        };
                                                        placeholder: {
                                                            type: string;
                                                            maxLength: 2048;
                                                        };
                                                        default: {
                                                            type: string[];
                                                        };
                                                        minLength: {
                                                            type: string;
                                                            minimum: number;
                                                        };
                                                        maxLength: {
                                                            type: string;
                                                            minimum: number;
                                                        };
                                                        min: {
                                                            type: string;
                                                        };
                                                        max: {
                                                            type: string;
                                                        };
                                                        step: {
                                                            type: string;
                                                            exclusiveMinimum: number;
                                                        };
                                                        sensitiveName: {
                                                            type: string;
                                                        };
                                                        options: {
                                                            type: string;
                                                            minItems: number;
                                                            maxItems: 256;
                                                            items: {
                                                                type: string;
                                                                required: string[];
                                                                properties: {
                                                                    value: {
                                                                        type: string;
                                                                        maxLength: 128;
                                                                    };
                                                                    title: Readonly<{
                                                                        type: "string";
                                                                        minLength: 1;
                                                                        maxLength: 256;
                                                                    }>;
                                                                };
                                                                additionalProperties: boolean;
                                                            };
                                                        };
                                                    };
                                                    additionalProperties: false;
                                                    allOf: {
                                                        if: {
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                };
                                                            };
                                                            required: string[];
                                                        };
                                                        then: {
                                                            properties: {
                                                                storage: {
                                                                    const: string;
                                                                };
                                                            };
                                                        };
                                                        else: {
                                                            properties: {
                                                                storage: {
                                                                    enum: string[];
                                                                };
                                                                sensitiveName: boolean;
                                                            };
                                                        };
                                                    }[];
                                                }>;
                                            };
                                        };
                                        additionalProperties: boolean;
                                    };
                                };
                            };
                            additionalProperties: false;
                        }>;
                        jobs: {
                            type: string;
                            minItems: number;
                            maxItems: 32;
                            items: Readonly<{
                                type: "object";
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    triggers: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 8;
                                        items: Readonly<{
                                            oneOf: ({
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    noteSetting?: undefined;
                                                    minutes?: undefined;
                                                    minutesSetting?: undefined;
                                                    command?: undefined;
                                                    pathSetting?: undefined;
                                                };
                                                additionalProperties: boolean;
                                                oneOf?: undefined;
                                            } | {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    noteSetting: {
                                                        type: string;
                                                        maxLength: 128;
                                                    };
                                                    minutes?: undefined;
                                                    minutesSetting?: undefined;
                                                    command?: undefined;
                                                    pathSetting?: undefined;
                                                };
                                                additionalProperties: boolean;
                                                oneOf?: undefined;
                                            } | {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    minutes: {
                                                        type: string;
                                                        minimum: 5;
                                                        maximum: 1440;
                                                    };
                                                    minutesSetting: {
                                                        type: string;
                                                        maxLength: 128;
                                                    };
                                                    noteSetting?: undefined;
                                                    command?: undefined;
                                                    pathSetting?: undefined;
                                                };
                                                oneOf: {
                                                    required: string[];
                                                }[];
                                                additionalProperties: boolean;
                                            } | {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    command: Readonly<{
                                                        type: "string";
                                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                        maxLength: 64;
                                                    }>;
                                                    noteSetting?: undefined;
                                                    minutes?: undefined;
                                                    minutesSetting?: undefined;
                                                    pathSetting?: undefined;
                                                };
                                                additionalProperties: boolean;
                                                oneOf?: undefined;
                                            } | {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    type: {
                                                        const: string;
                                                    };
                                                    pathSetting: {
                                                        type: string;
                                                        maxLength: 128;
                                                    };
                                                    noteSetting?: undefined;
                                                    minutes?: undefined;
                                                    minutesSetting?: undefined;
                                                    command?: undefined;
                                                };
                                                additionalProperties: boolean;
                                                oneOf?: undefined;
                                            })[];
                                        }>;
                                    };
                                    concurrency: {
                                        const: string;
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                    };
                    additionalProperties: false;
                }>;
            };
            type: "object";
            required: readonly ["manifestVersion", "id", "name", "version", "apiVersion", "runtime", "platforms", "permissions", "contributes"];
            additionalProperties: false;
            oneOf: readonly [{
                readonly properties: {
                    readonly runtime: {
                        readonly enum: readonly ["native", "sandboxed-page"];
                    };
                };
                readonly required: readonly ["entry", "integrity"];
            }, {
                readonly properties: {
                    readonly runtime: {
                        readonly const: "live-sandboxed";
                    };
                    readonly entry: false;
                    readonly styles: false;
                    readonly assets: false;
                    readonly integrity: false;
                    readonly editorExtensionBuild: false;
                };
            }];
            allOf: readonly [{
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly contributes: {
                            readonly not: {
                                readonly required: readonly ["searchPresentations"];
                            };
                        };
                    };
                };
            }, {
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly editorExtensionBuild: false;
                        readonly contributes: {
                            readonly not: {
                                readonly required: readonly ["editorExtensions"];
                            };
                        };
                    };
                };
            }, {
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly const: "sandboxed-page";
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly contributes: {
                            readonly not: {
                                readonly required: readonly ["markdownBlocks"];
                            };
                        };
                    };
                };
            }, {
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly contributes: {
                            readonly not: {
                                readonly required: readonly ["noteActions"];
                            };
                        };
                    };
                };
            }, {
                readonly if: {
                    readonly properties: {
                        readonly runtime: {
                            readonly const: "live-sandboxed";
                        };
                    };
                    readonly required: readonly ["runtime"];
                };
                readonly then: {
                    readonly properties: {
                        readonly contributes: {
                            readonly properties: {
                                readonly fileViewers: {
                                    readonly items: {
                                        readonly properties: {
                                            readonly content: {
                                                readonly const: "text";
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    };
                };
            }];
            "x-thortiq-runtime-validation": readonly ["canonical NFC identities and paths", "exact integrity key equality", "cross-contribution references", "permission/runtime coherence", "setting-derived connection references"];
        };
        readonly javascript: {
            type: string;
            "x-thortiq-maxUtf8Bytes": number;
        };
        readonly css: {
            type: string;
            "x-thortiq-maxUtf8Bytes": number;
        };
    };
    readonly additionalProperties: false;
}>;
export declare const LIVE_PLUGIN_PREVIEW_CANDIDATE_V1_JSON_SCHEMA: Readonly<{
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://thortiq.local/schemas/live-plugin-preview-candidate-v1.json";
    readonly title: "Thortiq Live Plugin Preview Candidate v1";
    readonly type: "object";
    readonly required: readonly ["formatVersion", "pluginId", "baseRevision", "content"];
    readonly properties: {
        readonly formatVersion: {
            readonly const: 1;
        };
        readonly pluginId: {
            readonly type: "string";
            readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
            readonly maxLength: 64;
        };
        readonly baseRevision: {
            readonly oneOf: readonly [Readonly<{
                type: "string";
                pattern: "^sha256:[0-9a-f]{64}$";
            }>, {
                readonly type: "null";
            }];
        };
        readonly content: Readonly<{
            type: "object";
            required: string[];
            properties: {
                manifest: {
                    $schema: undefined;
                    $id: undefined;
                    title: undefined;
                    properties: {
                        runtime: {
                            const: string;
                        };
                        manifestVersion: {
                            readonly const: 2;
                        };
                        id: {
                            readonly type: "string";
                            readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                            readonly maxLength: 64;
                        };
                        name: Readonly<{
                            type: "string";
                            minLength: 1;
                            maxLength: 256;
                        }>;
                        description: {
                            readonly type: "string";
                            readonly maxLength: 2048;
                        };
                        author: Readonly<{
                            type: "string";
                            minLength: 1;
                            maxLength: 256;
                        }>;
                        version: {
                            readonly type: "string";
                            readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$";
                        };
                        apiVersion: {
                            readonly type: "string";
                            readonly maxLength: 64;
                        };
                        platforms: {
                            readonly type: "array";
                            readonly minItems: 1;
                            readonly maxItems: 3;
                            readonly uniqueItems: true;
                            readonly items: {
                                readonly enum: readonly ["web", "capacitor", "desktop"];
                            };
                        };
                        permissions: {
                            readonly type: "array";
                            readonly maxItems: 17;
                            readonly uniqueItems: true;
                            readonly items: {
                                readonly enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                            };
                        };
                        entry: {
                            readonly type: "string";
                            readonly maxLength: 4096;
                        };
                        styles: {
                            readonly type: "array";
                            readonly minItems: 1;
                            readonly maxItems: number;
                            readonly uniqueItems: true;
                            readonly items: {
                                readonly type: "string";
                                readonly maxLength: 4096;
                            };
                        };
                        assets: {
                            readonly type: "array";
                            readonly minItems: 1;
                            readonly maxItems: number;
                            readonly uniqueItems: true;
                            readonly items: {
                                readonly type: "string";
                                readonly maxLength: 4096;
                            };
                        };
                        integrity: {
                            readonly type: "object";
                            readonly maxProperties: number;
                            readonly patternProperties: {
                                readonly "^.+$": {
                                    readonly type: "string";
                                    readonly pattern: "^sha256:[0-9a-f]{64}$";
                                };
                            };
                            readonly additionalProperties: false;
                        };
                        editorExtensionBuild: {
                            readonly type: "object";
                            readonly required: readonly ["proofVersion", "path"];
                            readonly properties: {
                                readonly proofVersion: {
                                    readonly const: 1;
                                };
                                readonly path: {
                                    readonly type: "string";
                                    readonly maxLength: 4096;
                                };
                            };
                            readonly additionalProperties: false;
                        };
                        network: Readonly<{
                            type: "array";
                            maxItems: 32;
                            items: {
                                oneOf: ({
                                    type: string;
                                    required: string[];
                                    properties: {
                                        id: Readonly<{
                                            type: "string";
                                            pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                            maxLength: 64;
                                        }>;
                                        origin: {
                                            type: string;
                                            format: string;
                                            pattern: string;
                                        };
                                        originSetting?: undefined;
                                        requireHttps?: undefined;
                                    };
                                    additionalProperties: boolean;
                                } | {
                                    type: string;
                                    required: string[];
                                    properties: {
                                        id: Readonly<{
                                            type: "string";
                                            pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                            maxLength: 64;
                                        }>;
                                        originSetting: {
                                            type: string;
                                            maxLength: 128;
                                        };
                                        requireHttps: {
                                            const: boolean;
                                        };
                                        origin?: undefined;
                                    };
                                    additionalProperties: boolean;
                                })[];
                            };
                        }>;
                        contributes: Readonly<{
                            type: "object";
                            minProperties: 1;
                            maxProperties: 10;
                            properties: {
                                views: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 256;
                                    items: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            icon: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                        };
                                        additionalProperties: false;
                                    }>;
                                };
                                commands: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 256;
                                    items: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            icon: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                        };
                                        additionalProperties: false;
                                    }>;
                                };
                                navigationItems: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 256;
                                    items: {
                                        required: string[];
                                        properties: {
                                            view: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            icon: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                        };
                                        type: "object";
                                        additionalProperties: false;
                                    };
                                };
                                searchPresentations: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 256;
                                    items: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            icon: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                        };
                                        additionalProperties: false;
                                    }>;
                                };
                                markdownBlocks: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 256;
                                    items: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            runtime: {
                                                enum: readonly ["native", "sandboxed-page", "live-sandboxed"];
                                            };
                                            rendererMode: {
                                                enum: readonly ["native-imperative", "live-declarative"];
                                            };
                                            configSchema: {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    version: {
                                                        const: number;
                                                    };
                                                    type: {
                                                        const: string;
                                                    };
                                                    properties: {
                                                        type: string;
                                                        maxProperties: 64;
                                                        patternProperties: {
                                                            [x: string]: Readonly<{
                                                                oneOf: ({
                                                                    type: string;
                                                                    required: string[];
                                                                    properties: {
                                                                        type: {
                                                                            const: string;
                                                                            enum?: undefined;
                                                                        };
                                                                        title: Readonly<{
                                                                            type: "string";
                                                                            minLength: 1;
                                                                            maxLength: 256;
                                                                        }>;
                                                                        description: {
                                                                            type: string;
                                                                            maxLength: 2048;
                                                                        };
                                                                        default: {
                                                                            type: string;
                                                                        };
                                                                        minimum?: undefined;
                                                                        maximum?: undefined;
                                                                        enum?: undefined;
                                                                        minLength?: undefined;
                                                                        maxLength?: undefined;
                                                                    };
                                                                    additionalProperties: boolean;
                                                                } | {
                                                                    type: string;
                                                                    required: string[];
                                                                    properties: {
                                                                        type: {
                                                                            enum: string[];
                                                                            const?: undefined;
                                                                        };
                                                                        title: Readonly<{
                                                                            type: "string";
                                                                            minLength: 1;
                                                                            maxLength: 256;
                                                                        }>;
                                                                        description: {
                                                                            type: string;
                                                                            maxLength: 2048;
                                                                        };
                                                                        default: {
                                                                            type: string;
                                                                        };
                                                                        minimum: {
                                                                            type: string;
                                                                        };
                                                                        maximum: {
                                                                            type: string;
                                                                        };
                                                                        enum?: undefined;
                                                                        minLength?: undefined;
                                                                        maxLength?: undefined;
                                                                    };
                                                                    additionalProperties: boolean;
                                                                } | {
                                                                    type: string;
                                                                    required: string[];
                                                                    properties: {
                                                                        type: {
                                                                            const: string;
                                                                            enum?: undefined;
                                                                        };
                                                                        title: Readonly<{
                                                                            type: "string";
                                                                            minLength: 1;
                                                                            maxLength: 256;
                                                                        }>;
                                                                        description: {
                                                                            type: string;
                                                                            maxLength: 2048;
                                                                        };
                                                                        default: {
                                                                            type: string;
                                                                        };
                                                                        enum: {
                                                                            type: string;
                                                                            minItems: number;
                                                                            maxItems: 64;
                                                                            uniqueItems: boolean;
                                                                            items: {
                                                                                type: string;
                                                                                maxLength: 2048;
                                                                            };
                                                                        };
                                                                        minLength: {
                                                                            type: string;
                                                                            minimum: number;
                                                                            maximum: number;
                                                                        };
                                                                        maxLength: {
                                                                            type: string;
                                                                            minimum: number;
                                                                            maximum: number;
                                                                        };
                                                                        minimum?: undefined;
                                                                        maximum?: undefined;
                                                                    };
                                                                    additionalProperties: boolean;
                                                                })[];
                                                            }>;
                                                        };
                                                        additionalProperties: boolean;
                                                    };
                                                    required: {
                                                        type: string;
                                                        maxItems: 64;
                                                        uniqueItems: boolean;
                                                        items: {
                                                            type: string;
                                                            pattern: string;
                                                            maxLength: 128;
                                                        };
                                                    };
                                                    additionalProperties: {
                                                        const: boolean;
                                                    };
                                                };
                                                additionalProperties: boolean;
                                            };
                                            permissions: {
                                                type: string;
                                                maxItems: 17;
                                                uniqueItems: boolean;
                                                items: {
                                                    enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                                };
                                            };
                                        };
                                        additionalProperties: false;
                                    }>;
                                };
                                editorExtensions: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 256;
                                    items: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            hostApiVersion: {
                                                const: "1.0.0";
                                            };
                                            appliesTo: {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    noteTypes: {
                                                        type: string;
                                                        minItems: number;
                                                        maxItems: 64;
                                                        uniqueItems: boolean;
                                                        items: Readonly<{
                                                            type: "string";
                                                            pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                            maxLength: 64;
                                                        }>;
                                                    };
                                                    modes: {
                                                        type: string;
                                                        minItems: number;
                                                        maxItems: 2;
                                                        uniqueItems: boolean;
                                                        items: {
                                                            enum: readonly ["edit", "read"];
                                                        };
                                                    };
                                                };
                                                additionalProperties: boolean;
                                            };
                                            priority: {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    tier: {
                                                        enum: readonly ["low", "normal", "high"];
                                                    };
                                                    order: {
                                                        type: string;
                                                        minimum: -1000;
                                                        maximum: 1000;
                                                    };
                                                };
                                                additionalProperties: boolean;
                                            };
                                            configSchema: {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    version: {
                                                        const: number;
                                                    };
                                                    type: {
                                                        const: string;
                                                    };
                                                    properties: {
                                                        type: string;
                                                        maxProperties: 64;
                                                        patternProperties: {
                                                            [x: string]: Readonly<{
                                                                oneOf: ({
                                                                    type: string;
                                                                    required: string[];
                                                                    properties: {
                                                                        type: {
                                                                            const: string;
                                                                            enum?: undefined;
                                                                        };
                                                                        title: Readonly<{
                                                                            type: "string";
                                                                            minLength: 1;
                                                                            maxLength: 256;
                                                                        }>;
                                                                        description: {
                                                                            type: string;
                                                                            maxLength: 2048;
                                                                        };
                                                                        default: {
                                                                            type: string;
                                                                        };
                                                                        minimum?: undefined;
                                                                        maximum?: undefined;
                                                                        enum?: undefined;
                                                                        minLength?: undefined;
                                                                        maxLength?: undefined;
                                                                    };
                                                                    additionalProperties: boolean;
                                                                } | {
                                                                    type: string;
                                                                    required: string[];
                                                                    properties: {
                                                                        type: {
                                                                            enum: string[];
                                                                            const?: undefined;
                                                                        };
                                                                        title: Readonly<{
                                                                            type: "string";
                                                                            minLength: 1;
                                                                            maxLength: 256;
                                                                        }>;
                                                                        description: {
                                                                            type: string;
                                                                            maxLength: 2048;
                                                                        };
                                                                        default: {
                                                                            type: string;
                                                                        };
                                                                        minimum: {
                                                                            type: string;
                                                                        };
                                                                        maximum: {
                                                                            type: string;
                                                                        };
                                                                        enum?: undefined;
                                                                        minLength?: undefined;
                                                                        maxLength?: undefined;
                                                                    };
                                                                    additionalProperties: boolean;
                                                                } | {
                                                                    type: string;
                                                                    required: string[];
                                                                    properties: {
                                                                        type: {
                                                                            const: string;
                                                                            enum?: undefined;
                                                                        };
                                                                        title: Readonly<{
                                                                            type: "string";
                                                                            minLength: 1;
                                                                            maxLength: 256;
                                                                        }>;
                                                                        description: {
                                                                            type: string;
                                                                            maxLength: 2048;
                                                                        };
                                                                        default: {
                                                                            type: string;
                                                                        };
                                                                        enum: {
                                                                            type: string;
                                                                            minItems: number;
                                                                            maxItems: 64;
                                                                            uniqueItems: boolean;
                                                                            items: {
                                                                                type: string;
                                                                                maxLength: 2048;
                                                                            };
                                                                        };
                                                                        minLength: {
                                                                            type: string;
                                                                            minimum: number;
                                                                            maximum: number;
                                                                        };
                                                                        maxLength: {
                                                                            type: string;
                                                                            minimum: number;
                                                                            maximum: number;
                                                                        };
                                                                        minimum?: undefined;
                                                                        maximum?: undefined;
                                                                    };
                                                                    additionalProperties: boolean;
                                                                })[];
                                                            }>;
                                                        };
                                                        additionalProperties: boolean;
                                                    };
                                                    required: {
                                                        type: string;
                                                        maxItems: 64;
                                                        uniqueItems: boolean;
                                                        items: {
                                                            type: string;
                                                            pattern: string;
                                                            maxLength: 128;
                                                        };
                                                    };
                                                    additionalProperties: {
                                                        const: boolean;
                                                    };
                                                };
                                                additionalProperties: boolean;
                                            };
                                        };
                                        additionalProperties: false;
                                    }>;
                                };
                                noteActions: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 256;
                                    items: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            icon: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            runtime: {
                                                const: string;
                                            };
                                            permissions: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 17;
                                                uniqueItems: boolean;
                                                items: {
                                                    enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                                };
                                                contains: {
                                                    const: string;
                                                };
                                            };
                                            surfaces: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 2;
                                                uniqueItems: boolean;
                                                items: {
                                                    enum: readonly ["editor", "search"];
                                                };
                                            };
                                            appliesTo: {
                                                type: string;
                                                properties: {
                                                    noteTypes: {
                                                        type: string;
                                                        minItems: number;
                                                        maxItems: 64;
                                                        uniqueItems: boolean;
                                                        items: Readonly<{
                                                            type: "string";
                                                            pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                            maxLength: 64;
                                                        }>;
                                                    };
                                                    allTags: {
                                                        type: string;
                                                        minItems: number;
                                                        maxItems: 64;
                                                        uniqueItems: boolean;
                                                        items: Readonly<{
                                                            type: "string";
                                                            minLength: 1;
                                                            maxLength: 128;
                                                        }>;
                                                    };
                                                    anyTags: {
                                                        type: string;
                                                        minItems: number;
                                                        maxItems: 64;
                                                        uniqueItems: boolean;
                                                        items: Readonly<{
                                                            type: "string";
                                                            minLength: 1;
                                                            maxLength: 128;
                                                        }>;
                                                    };
                                                    requiredProperties: {
                                                        type: string;
                                                        minItems: number;
                                                        maxItems: 64;
                                                        uniqueItems: boolean;
                                                        items: Readonly<{
                                                            type: "string";
                                                            minLength: 1;
                                                            maxLength: 128;
                                                        }>;
                                                    };
                                                };
                                                additionalProperties: boolean;
                                            };
                                        };
                                        additionalProperties: false;
                                    }>;
                                };
                                fileViewers: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 256;
                                    items: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            icon: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            runtime: {
                                                enum: readonly ["native", "sandboxed-page", "live-sandboxed"];
                                            };
                                            rendererMode: {
                                                enum: readonly ["native-imperative", "sandboxed-page", "live-declarative"];
                                            };
                                            permissions: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 17;
                                                uniqueItems: boolean;
                                                items: {
                                                    enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                                };
                                                allOf: {
                                                    contains: {
                                                        const: string;
                                                    };
                                                }[];
                                            };
                                            extensions: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 32;
                                                uniqueItems: boolean;
                                                items: {
                                                    type: string;
                                                    pattern: string;
                                                };
                                            };
                                            mediaTypes: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 32;
                                                uniqueItems: boolean;
                                                items: {
                                                    type: string;
                                                    pattern: string;
                                                };
                                            };
                                            maxBytes: {
                                                type: string;
                                                minimum: number;
                                                maximum: number;
                                            };
                                            content: {
                                                enum: string[];
                                            };
                                        };
                                        additionalProperties: false;
                                    }>;
                                };
                                settings: Readonly<{
                                    type: "object";
                                    required: string[];
                                    properties: {
                                        sections: {
                                            type: string;
                                            minItems: number;
                                            maxItems: 32;
                                            items: {
                                                type: string;
                                                required: string[];
                                                properties: {
                                                    id: Readonly<{
                                                        type: "string";
                                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                        maxLength: 64;
                                                    }>;
                                                    title: Readonly<{
                                                        type: "string";
                                                        minLength: 1;
                                                        maxLength: 256;
                                                    }>;
                                                    fields: {
                                                        type: string;
                                                        minItems: number;
                                                        maxItems: 256;
                                                        items: Readonly<{
                                                            type: "object";
                                                            required: string[];
                                                            properties: {
                                                                key: {
                                                                    type: string;
                                                                    pattern: string;
                                                                    maxLength: 128;
                                                                };
                                                                type: {
                                                                    enum: readonly ["text", "textarea", "number", "checkbox", "select", "url", "note", "folder", "asset", "secret"];
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                                description: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                required: {
                                                                    type: string;
                                                                };
                                                                storage: {
                                                                    enum: readonly ["synced", "local", "encrypted-secret"];
                                                                };
                                                                placeholder: {
                                                                    type: string;
                                                                    maxLength: 2048;
                                                                };
                                                                default: {
                                                                    type: string[];
                                                                };
                                                                minLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                };
                                                                maxLength: {
                                                                    type: string;
                                                                    minimum: number;
                                                                };
                                                                min: {
                                                                    type: string;
                                                                };
                                                                max: {
                                                                    type: string;
                                                                };
                                                                step: {
                                                                    type: string;
                                                                    exclusiveMinimum: number;
                                                                };
                                                                sensitiveName: {
                                                                    type: string;
                                                                };
                                                                options: {
                                                                    type: string;
                                                                    minItems: number;
                                                                    maxItems: 256;
                                                                    items: {
                                                                        type: string;
                                                                        required: string[];
                                                                        properties: {
                                                                            value: {
                                                                                type: string;
                                                                                maxLength: 128;
                                                                            };
                                                                            title: Readonly<{
                                                                                type: "string";
                                                                                minLength: 1;
                                                                                maxLength: 256;
                                                                            }>;
                                                                        };
                                                                        additionalProperties: boolean;
                                                                    };
                                                                };
                                                            };
                                                            additionalProperties: false;
                                                            allOf: {
                                                                if: {
                                                                    properties: {
                                                                        type: {
                                                                            const: string;
                                                                        };
                                                                    };
                                                                    required: string[];
                                                                };
                                                                then: {
                                                                    properties: {
                                                                        storage: {
                                                                            const: string;
                                                                        };
                                                                    };
                                                                };
                                                                else: {
                                                                    properties: {
                                                                        storage: {
                                                                            enum: string[];
                                                                        };
                                                                        sensitiveName: boolean;
                                                                    };
                                                                };
                                                            }[];
                                                        }>;
                                                    };
                                                };
                                                additionalProperties: boolean;
                                            };
                                        };
                                    };
                                    additionalProperties: false;
                                }>;
                                jobs: {
                                    type: string;
                                    minItems: number;
                                    maxItems: 32;
                                    items: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            title: Readonly<{
                                                type: "string";
                                                minLength: 1;
                                                maxLength: 256;
                                            }>;
                                            triggers: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 8;
                                                items: Readonly<{
                                                    oneOf: ({
                                                        type: string;
                                                        required: string[];
                                                        properties: {
                                                            type: {
                                                                const: string;
                                                            };
                                                            noteSetting?: undefined;
                                                            minutes?: undefined;
                                                            minutesSetting?: undefined;
                                                            command?: undefined;
                                                            pathSetting?: undefined;
                                                        };
                                                        additionalProperties: boolean;
                                                        oneOf?: undefined;
                                                    } | {
                                                        type: string;
                                                        required: string[];
                                                        properties: {
                                                            type: {
                                                                const: string;
                                                            };
                                                            noteSetting: {
                                                                type: string;
                                                                maxLength: 128;
                                                            };
                                                            minutes?: undefined;
                                                            minutesSetting?: undefined;
                                                            command?: undefined;
                                                            pathSetting?: undefined;
                                                        };
                                                        additionalProperties: boolean;
                                                        oneOf?: undefined;
                                                    } | {
                                                        type: string;
                                                        required: string[];
                                                        properties: {
                                                            type: {
                                                                const: string;
                                                            };
                                                            minutes: {
                                                                type: string;
                                                                minimum: 5;
                                                                maximum: 1440;
                                                            };
                                                            minutesSetting: {
                                                                type: string;
                                                                maxLength: 128;
                                                            };
                                                            noteSetting?: undefined;
                                                            command?: undefined;
                                                            pathSetting?: undefined;
                                                        };
                                                        oneOf: {
                                                            required: string[];
                                                        }[];
                                                        additionalProperties: boolean;
                                                    } | {
                                                        type: string;
                                                        required: string[];
                                                        properties: {
                                                            type: {
                                                                const: string;
                                                            };
                                                            command: Readonly<{
                                                                type: "string";
                                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                                maxLength: 64;
                                                            }>;
                                                            noteSetting?: undefined;
                                                            minutes?: undefined;
                                                            minutesSetting?: undefined;
                                                            pathSetting?: undefined;
                                                        };
                                                        additionalProperties: boolean;
                                                        oneOf?: undefined;
                                                    } | {
                                                        type: string;
                                                        required: string[];
                                                        properties: {
                                                            type: {
                                                                const: string;
                                                            };
                                                            pathSetting: {
                                                                type: string;
                                                                maxLength: 128;
                                                            };
                                                            noteSetting?: undefined;
                                                            minutes?: undefined;
                                                            minutesSetting?: undefined;
                                                            command?: undefined;
                                                        };
                                                        additionalProperties: boolean;
                                                        oneOf?: undefined;
                                                    })[];
                                                }>;
                                            };
                                            concurrency: {
                                                const: string;
                                            };
                                        };
                                        additionalProperties: false;
                                    }>;
                                };
                            };
                            additionalProperties: false;
                        }>;
                    };
                    type: "object";
                    required: readonly ["manifestVersion", "id", "name", "version", "apiVersion", "runtime", "platforms", "permissions", "contributes"];
                    additionalProperties: false;
                    oneOf: readonly [{
                        readonly properties: {
                            readonly runtime: {
                                readonly enum: readonly ["native", "sandboxed-page"];
                            };
                        };
                        readonly required: readonly ["entry", "integrity"];
                    }, {
                        readonly properties: {
                            readonly runtime: {
                                readonly const: "live-sandboxed";
                            };
                            readonly entry: false;
                            readonly styles: false;
                            readonly assets: false;
                            readonly integrity: false;
                            readonly editorExtensionBuild: false;
                        };
                    }];
                    allOf: readonly [{
                        readonly if: {
                            readonly properties: {
                                readonly runtime: {
                                    readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                                };
                            };
                            readonly required: readonly ["runtime"];
                        };
                        readonly then: {
                            readonly properties: {
                                readonly contributes: {
                                    readonly not: {
                                        readonly required: readonly ["searchPresentations"];
                                    };
                                };
                            };
                        };
                    }, {
                        readonly if: {
                            readonly properties: {
                                readonly runtime: {
                                    readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                                };
                            };
                            readonly required: readonly ["runtime"];
                        };
                        readonly then: {
                            readonly properties: {
                                readonly editorExtensionBuild: false;
                                readonly contributes: {
                                    readonly not: {
                                        readonly required: readonly ["editorExtensions"];
                                    };
                                };
                            };
                        };
                    }, {
                        readonly if: {
                            readonly properties: {
                                readonly runtime: {
                                    readonly const: "sandboxed-page";
                                };
                            };
                            readonly required: readonly ["runtime"];
                        };
                        readonly then: {
                            readonly properties: {
                                readonly contributes: {
                                    readonly not: {
                                        readonly required: readonly ["markdownBlocks"];
                                    };
                                };
                            };
                        };
                    }, {
                        readonly if: {
                            readonly properties: {
                                readonly runtime: {
                                    readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                                };
                            };
                            readonly required: readonly ["runtime"];
                        };
                        readonly then: {
                            readonly properties: {
                                readonly contributes: {
                                    readonly not: {
                                        readonly required: readonly ["noteActions"];
                                    };
                                };
                            };
                        };
                    }, {
                        readonly if: {
                            readonly properties: {
                                readonly runtime: {
                                    readonly const: "live-sandboxed";
                                };
                            };
                            readonly required: readonly ["runtime"];
                        };
                        readonly then: {
                            readonly properties: {
                                readonly contributes: {
                                    readonly properties: {
                                        readonly fileViewers: {
                                            readonly items: {
                                                readonly properties: {
                                                    readonly content: {
                                                        readonly const: "text";
                                                    };
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        };
                    }];
                    "x-thortiq-runtime-validation": readonly ["canonical NFC identities and paths", "exact integrity key equality", "cross-contribution references", "permission/runtime coherence", "setting-derived connection references"];
                };
                javascript: {
                    type: string;
                    "x-thortiq-maxUtf8Bytes": number;
                };
                css: {
                    type: string;
                    "x-thortiq-maxUtf8Bytes": number;
                };
                settingsSchema: Readonly<{
                    type: "object";
                    required: string[];
                    properties: {
                        sections: {
                            type: string;
                            minItems: number;
                            maxItems: 32;
                            items: {
                                type: string;
                                required: string[];
                                properties: {
                                    id: Readonly<{
                                        type: "string";
                                        pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                        maxLength: 64;
                                    }>;
                                    title: Readonly<{
                                        type: "string";
                                        minLength: 1;
                                        maxLength: 256;
                                    }>;
                                    fields: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 256;
                                        items: Readonly<{
                                            type: "object";
                                            required: string[];
                                            properties: {
                                                key: {
                                                    type: string;
                                                    pattern: string;
                                                    maxLength: 128;
                                                };
                                                type: {
                                                    enum: readonly ["text", "textarea", "number", "checkbox", "select", "url", "note", "folder", "asset", "secret"];
                                                };
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                description: {
                                                    type: string;
                                                    maxLength: 2048;
                                                };
                                                required: {
                                                    type: string;
                                                };
                                                storage: {
                                                    enum: readonly ["synced", "local", "encrypted-secret"];
                                                };
                                                placeholder: {
                                                    type: string;
                                                    maxLength: 2048;
                                                };
                                                default: {
                                                    type: string[];
                                                };
                                                minLength: {
                                                    type: string;
                                                    minimum: number;
                                                };
                                                maxLength: {
                                                    type: string;
                                                    minimum: number;
                                                };
                                                min: {
                                                    type: string;
                                                };
                                                max: {
                                                    type: string;
                                                };
                                                step: {
                                                    type: string;
                                                    exclusiveMinimum: number;
                                                };
                                                sensitiveName: {
                                                    type: string;
                                                };
                                                options: {
                                                    type: string;
                                                    minItems: number;
                                                    maxItems: 256;
                                                    items: {
                                                        type: string;
                                                        required: string[];
                                                        properties: {
                                                            value: {
                                                                type: string;
                                                                maxLength: 128;
                                                            };
                                                            title: Readonly<{
                                                                type: "string";
                                                                minLength: 1;
                                                                maxLength: 256;
                                                            }>;
                                                        };
                                                        additionalProperties: boolean;
                                                    };
                                                };
                                            };
                                            additionalProperties: false;
                                            allOf: {
                                                if: {
                                                    properties: {
                                                        type: {
                                                            const: string;
                                                        };
                                                    };
                                                    required: string[];
                                                };
                                                then: {
                                                    properties: {
                                                        storage: {
                                                            const: string;
                                                        };
                                                    };
                                                };
                                                else: {
                                                    properties: {
                                                        storage: {
                                                            enum: string[];
                                                        };
                                                        sensitiveName: boolean;
                                                    };
                                                };
                                            }[];
                                        }>;
                                    };
                                };
                                additionalProperties: boolean;
                            };
                        };
                    };
                    additionalProperties: false;
                }>;
            };
            additionalProperties: false;
        }>;
    };
    readonly additionalProperties: false;
}>;
export declare const LIVE_PLUGIN_REVISION_SUMMARY_V1_JSON_SCHEMA: Readonly<{
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://thortiq.local/schemas/live-plugin-revision-summary-v1.json";
    readonly title: "Thortiq Live Plugin Revision Summary v1";
    readonly type: "object";
    readonly required: readonly ["pluginId", "revision", "parentRevision", "authoredAt", "authorKind", "operation", "sizeBytes"];
    readonly properties: {
        readonly pluginId: {
            readonly type: "string";
            readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
            readonly maxLength: 64;
        };
        readonly revision: Readonly<{
            type: "string";
            pattern: "^sha256:[0-9a-f]{64}$";
        }>;
        readonly parentRevision: {
            readonly oneOf: readonly [Readonly<{
                type: "string";
                pattern: "^sha256:[0-9a-f]{64}$";
            }>, {
                readonly type: "null";
            }];
        };
        readonly authoredAt: {
            readonly type: "string";
            readonly format: "date-time";
        };
        readonly authorKind: {
            readonly enum: readonly ["user", "assistant", "system"];
        };
        readonly operation: {
            readonly enum: readonly ["create", "update", "restore", "reconcile"];
        };
        readonly sizeBytes: {
            readonly type: "integer";
            readonly minimum: 1;
            readonly maximum: number;
        };
    };
    readonly additionalProperties: false;
}>;
export declare const LIVE_PLUGIN_BRANCH_V1_JSON_SCHEMA: Readonly<{
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://thortiq.local/schemas/live-plugin-branch-v1.json";
    readonly title: "Thortiq Live Plugin Branch v1";
    readonly type: "object";
    readonly required: readonly ["pluginId", "headRevision", "parentRevision", "kind", "observedAt"];
    readonly properties: {
        readonly pluginId: {
            readonly type: "string";
            readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
            readonly maxLength: 64;
        };
        readonly headRevision: Readonly<{
            type: "string";
            pattern: "^sha256:[0-9a-f]{64}$";
        }>;
        readonly parentRevision: {
            readonly oneOf: readonly [Readonly<{
                type: "string";
                pattern: "^sha256:[0-9a-f]{64}$";
            }>, {
                readonly type: "null";
            }];
        };
        readonly kind: {
            readonly enum: readonly ["local", "remote", "conflict"];
        };
        readonly observedAt: {
            readonly type: "string";
            readonly format: "date-time";
        };
    };
    readonly additionalProperties: false;
}>;
export declare const LIVE_PLUGIN_CAS_RESULT_V1_JSON_SCHEMA: Readonly<{
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://thortiq.local/schemas/live-plugin-cas-result-v1.json";
    readonly title: "Thortiq Live Plugin CAS Result v1";
    readonly oneOf: readonly [{
        readonly type: "object";
        readonly required: readonly ["status", "bundle", "previousRevision"];
        readonly properties: {
            readonly status: {
                readonly enum: readonly ["created", "updated", "restored"];
            };
            readonly bundle: Readonly<{
                readonly $schema: "https://json-schema.org/draft/2020-12/schema";
                readonly $id: "https://thortiq.local/schemas/live-plugin-bundle-v1.json";
                readonly title: "Thortiq Live Plugin Bundle v1";
                readonly type: "object";
                readonly required: readonly ["formatVersion", "pluginId", "apiVersion", "revision", "parentRevision", "manifest", "javascript", "css", "provenance"];
                readonly properties: {
                    readonly provenance: Readonly<{
                        type: "object";
                        required: string[];
                        properties: {
                            schemaVersion: {
                                const: number;
                            };
                            authorKind: {
                                enum: readonly ["user", "assistant", "system"];
                            };
                            actorId: {
                                type: string;
                                minLength: number;
                                maxLength: 128;
                            };
                            authoredAt: {
                                type: string;
                                format: string;
                            };
                            operation: {
                                enum: readonly ["create", "update", "restore", "reconcile"];
                            };
                            toolId: {
                                type: string;
                                minLength: number;
                                maxLength: 128;
                            };
                        };
                        additionalProperties: false;
                    }>;
                    readonly manifest: {
                        $schema: undefined;
                        $id: undefined;
                        title: undefined;
                        properties: {
                            runtime: {
                                const: string;
                            };
                            manifestVersion: {
                                readonly const: 2;
                            };
                            id: {
                                readonly type: "string";
                                readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                readonly maxLength: 64;
                            };
                            name: Readonly<{
                                type: "string";
                                minLength: 1;
                                maxLength: 256;
                            }>;
                            description: {
                                readonly type: "string";
                                readonly maxLength: 2048;
                            };
                            author: Readonly<{
                                type: "string";
                                minLength: 1;
                                maxLength: 256;
                            }>;
                            version: {
                                readonly type: "string";
                                readonly pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?$";
                            };
                            apiVersion: {
                                readonly type: "string";
                                readonly maxLength: 64;
                            };
                            platforms: {
                                readonly type: "array";
                                readonly minItems: 1;
                                readonly maxItems: 3;
                                readonly uniqueItems: true;
                                readonly items: {
                                    readonly enum: readonly ["web", "capacitor", "desktop"];
                                };
                            };
                            permissions: {
                                readonly type: "array";
                                readonly maxItems: 17;
                                readonly uniqueItems: true;
                                readonly items: {
                                    readonly enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                };
                            };
                            entry: {
                                readonly type: "string";
                                readonly maxLength: 4096;
                            };
                            styles: {
                                readonly type: "array";
                                readonly minItems: 1;
                                readonly maxItems: number;
                                readonly uniqueItems: true;
                                readonly items: {
                                    readonly type: "string";
                                    readonly maxLength: 4096;
                                };
                            };
                            assets: {
                                readonly type: "array";
                                readonly minItems: 1;
                                readonly maxItems: number;
                                readonly uniqueItems: true;
                                readonly items: {
                                    readonly type: "string";
                                    readonly maxLength: 4096;
                                };
                            };
                            integrity: {
                                readonly type: "object";
                                readonly maxProperties: number;
                                readonly patternProperties: {
                                    readonly "^.+$": {
                                        readonly type: "string";
                                        readonly pattern: "^sha256:[0-9a-f]{64}$";
                                    };
                                };
                                readonly additionalProperties: false;
                            };
                            editorExtensionBuild: {
                                readonly type: "object";
                                readonly required: readonly ["proofVersion", "path"];
                                readonly properties: {
                                    readonly proofVersion: {
                                        readonly const: 1;
                                    };
                                    readonly path: {
                                        readonly type: "string";
                                        readonly maxLength: 4096;
                                    };
                                };
                                readonly additionalProperties: false;
                            };
                            network: Readonly<{
                                type: "array";
                                maxItems: 32;
                                items: {
                                    oneOf: ({
                                        type: string;
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            origin: {
                                                type: string;
                                                format: string;
                                                pattern: string;
                                            };
                                            originSetting?: undefined;
                                            requireHttps?: undefined;
                                        };
                                        additionalProperties: boolean;
                                    } | {
                                        type: string;
                                        required: string[];
                                        properties: {
                                            id: Readonly<{
                                                type: "string";
                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                maxLength: 64;
                                            }>;
                                            originSetting: {
                                                type: string;
                                                maxLength: 128;
                                            };
                                            requireHttps: {
                                                const: boolean;
                                            };
                                            origin?: undefined;
                                        };
                                        additionalProperties: boolean;
                                    })[];
                                };
                            }>;
                            contributes: Readonly<{
                                type: "object";
                                minProperties: 1;
                                maxProperties: 10;
                                properties: {
                                    views: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 256;
                                        items: Readonly<{
                                            type: "object";
                                            required: string[];
                                            properties: {
                                                id: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                icon: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                            };
                                            additionalProperties: false;
                                        }>;
                                    };
                                    commands: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 256;
                                        items: Readonly<{
                                            type: "object";
                                            required: string[];
                                            properties: {
                                                id: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                icon: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                            };
                                            additionalProperties: false;
                                        }>;
                                    };
                                    navigationItems: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 256;
                                        items: {
                                            required: string[];
                                            properties: {
                                                view: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                id: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                icon: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                            };
                                            type: "object";
                                            additionalProperties: false;
                                        };
                                    };
                                    searchPresentations: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 256;
                                        items: Readonly<{
                                            type: "object";
                                            required: string[];
                                            properties: {
                                                id: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                icon: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                            };
                                            additionalProperties: false;
                                        }>;
                                    };
                                    markdownBlocks: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 256;
                                        items: Readonly<{
                                            type: "object";
                                            required: string[];
                                            properties: {
                                                id: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                runtime: {
                                                    enum: readonly ["native", "sandboxed-page", "live-sandboxed"];
                                                };
                                                rendererMode: {
                                                    enum: readonly ["native-imperative", "live-declarative"];
                                                };
                                                configSchema: {
                                                    type: string;
                                                    required: string[];
                                                    properties: {
                                                        version: {
                                                            const: number;
                                                        };
                                                        type: {
                                                            const: string;
                                                        };
                                                        properties: {
                                                            type: string;
                                                            maxProperties: 64;
                                                            patternProperties: {
                                                                [x: string]: Readonly<{
                                                                    oneOf: ({
                                                                        type: string;
                                                                        required: string[];
                                                                        properties: {
                                                                            type: {
                                                                                const: string;
                                                                                enum?: undefined;
                                                                            };
                                                                            title: Readonly<{
                                                                                type: "string";
                                                                                minLength: 1;
                                                                                maxLength: 256;
                                                                            }>;
                                                                            description: {
                                                                                type: string;
                                                                                maxLength: 2048;
                                                                            };
                                                                            default: {
                                                                                type: string;
                                                                            };
                                                                            minimum?: undefined;
                                                                            maximum?: undefined;
                                                                            enum?: undefined;
                                                                            minLength?: undefined;
                                                                            maxLength?: undefined;
                                                                        };
                                                                        additionalProperties: boolean;
                                                                    } | {
                                                                        type: string;
                                                                        required: string[];
                                                                        properties: {
                                                                            type: {
                                                                                enum: string[];
                                                                                const?: undefined;
                                                                            };
                                                                            title: Readonly<{
                                                                                type: "string";
                                                                                minLength: 1;
                                                                                maxLength: 256;
                                                                            }>;
                                                                            description: {
                                                                                type: string;
                                                                                maxLength: 2048;
                                                                            };
                                                                            default: {
                                                                                type: string;
                                                                            };
                                                                            minimum: {
                                                                                type: string;
                                                                            };
                                                                            maximum: {
                                                                                type: string;
                                                                            };
                                                                            enum?: undefined;
                                                                            minLength?: undefined;
                                                                            maxLength?: undefined;
                                                                        };
                                                                        additionalProperties: boolean;
                                                                    } | {
                                                                        type: string;
                                                                        required: string[];
                                                                        properties: {
                                                                            type: {
                                                                                const: string;
                                                                                enum?: undefined;
                                                                            };
                                                                            title: Readonly<{
                                                                                type: "string";
                                                                                minLength: 1;
                                                                                maxLength: 256;
                                                                            }>;
                                                                            description: {
                                                                                type: string;
                                                                                maxLength: 2048;
                                                                            };
                                                                            default: {
                                                                                type: string;
                                                                            };
                                                                            enum: {
                                                                                type: string;
                                                                                minItems: number;
                                                                                maxItems: 64;
                                                                                uniqueItems: boolean;
                                                                                items: {
                                                                                    type: string;
                                                                                    maxLength: 2048;
                                                                                };
                                                                            };
                                                                            minLength: {
                                                                                type: string;
                                                                                minimum: number;
                                                                                maximum: number;
                                                                            };
                                                                            maxLength: {
                                                                                type: string;
                                                                                minimum: number;
                                                                                maximum: number;
                                                                            };
                                                                            minimum?: undefined;
                                                                            maximum?: undefined;
                                                                        };
                                                                        additionalProperties: boolean;
                                                                    })[];
                                                                }>;
                                                            };
                                                            additionalProperties: boolean;
                                                        };
                                                        required: {
                                                            type: string;
                                                            maxItems: 64;
                                                            uniqueItems: boolean;
                                                            items: {
                                                                type: string;
                                                                pattern: string;
                                                                maxLength: 128;
                                                            };
                                                        };
                                                        additionalProperties: {
                                                            const: boolean;
                                                        };
                                                    };
                                                    additionalProperties: boolean;
                                                };
                                                permissions: {
                                                    type: string;
                                                    maxItems: 17;
                                                    uniqueItems: boolean;
                                                    items: {
                                                        enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                                    };
                                                };
                                            };
                                            additionalProperties: false;
                                        }>;
                                    };
                                    editorExtensions: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 256;
                                        items: Readonly<{
                                            type: "object";
                                            required: string[];
                                            properties: {
                                                id: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                hostApiVersion: {
                                                    const: "1.0.0";
                                                };
                                                appliesTo: {
                                                    type: string;
                                                    required: string[];
                                                    properties: {
                                                        noteTypes: {
                                                            type: string;
                                                            minItems: number;
                                                            maxItems: 64;
                                                            uniqueItems: boolean;
                                                            items: Readonly<{
                                                                type: "string";
                                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                                maxLength: 64;
                                                            }>;
                                                        };
                                                        modes: {
                                                            type: string;
                                                            minItems: number;
                                                            maxItems: 2;
                                                            uniqueItems: boolean;
                                                            items: {
                                                                enum: readonly ["edit", "read"];
                                                            };
                                                        };
                                                    };
                                                    additionalProperties: boolean;
                                                };
                                                priority: {
                                                    type: string;
                                                    required: string[];
                                                    properties: {
                                                        tier: {
                                                            enum: readonly ["low", "normal", "high"];
                                                        };
                                                        order: {
                                                            type: string;
                                                            minimum: -1000;
                                                            maximum: 1000;
                                                        };
                                                    };
                                                    additionalProperties: boolean;
                                                };
                                                configSchema: {
                                                    type: string;
                                                    required: string[];
                                                    properties: {
                                                        version: {
                                                            const: number;
                                                        };
                                                        type: {
                                                            const: string;
                                                        };
                                                        properties: {
                                                            type: string;
                                                            maxProperties: 64;
                                                            patternProperties: {
                                                                [x: string]: Readonly<{
                                                                    oneOf: ({
                                                                        type: string;
                                                                        required: string[];
                                                                        properties: {
                                                                            type: {
                                                                                const: string;
                                                                                enum?: undefined;
                                                                            };
                                                                            title: Readonly<{
                                                                                type: "string";
                                                                                minLength: 1;
                                                                                maxLength: 256;
                                                                            }>;
                                                                            description: {
                                                                                type: string;
                                                                                maxLength: 2048;
                                                                            };
                                                                            default: {
                                                                                type: string;
                                                                            };
                                                                            minimum?: undefined;
                                                                            maximum?: undefined;
                                                                            enum?: undefined;
                                                                            minLength?: undefined;
                                                                            maxLength?: undefined;
                                                                        };
                                                                        additionalProperties: boolean;
                                                                    } | {
                                                                        type: string;
                                                                        required: string[];
                                                                        properties: {
                                                                            type: {
                                                                                enum: string[];
                                                                                const?: undefined;
                                                                            };
                                                                            title: Readonly<{
                                                                                type: "string";
                                                                                minLength: 1;
                                                                                maxLength: 256;
                                                                            }>;
                                                                            description: {
                                                                                type: string;
                                                                                maxLength: 2048;
                                                                            };
                                                                            default: {
                                                                                type: string;
                                                                            };
                                                                            minimum: {
                                                                                type: string;
                                                                            };
                                                                            maximum: {
                                                                                type: string;
                                                                            };
                                                                            enum?: undefined;
                                                                            minLength?: undefined;
                                                                            maxLength?: undefined;
                                                                        };
                                                                        additionalProperties: boolean;
                                                                    } | {
                                                                        type: string;
                                                                        required: string[];
                                                                        properties: {
                                                                            type: {
                                                                                const: string;
                                                                                enum?: undefined;
                                                                            };
                                                                            title: Readonly<{
                                                                                type: "string";
                                                                                minLength: 1;
                                                                                maxLength: 256;
                                                                            }>;
                                                                            description: {
                                                                                type: string;
                                                                                maxLength: 2048;
                                                                            };
                                                                            default: {
                                                                                type: string;
                                                                            };
                                                                            enum: {
                                                                                type: string;
                                                                                minItems: number;
                                                                                maxItems: 64;
                                                                                uniqueItems: boolean;
                                                                                items: {
                                                                                    type: string;
                                                                                    maxLength: 2048;
                                                                                };
                                                                            };
                                                                            minLength: {
                                                                                type: string;
                                                                                minimum: number;
                                                                                maximum: number;
                                                                            };
                                                                            maxLength: {
                                                                                type: string;
                                                                                minimum: number;
                                                                                maximum: number;
                                                                            };
                                                                            minimum?: undefined;
                                                                            maximum?: undefined;
                                                                        };
                                                                        additionalProperties: boolean;
                                                                    })[];
                                                                }>;
                                                            };
                                                            additionalProperties: boolean;
                                                        };
                                                        required: {
                                                            type: string;
                                                            maxItems: 64;
                                                            uniqueItems: boolean;
                                                            items: {
                                                                type: string;
                                                                pattern: string;
                                                                maxLength: 128;
                                                            };
                                                        };
                                                        additionalProperties: {
                                                            const: boolean;
                                                        };
                                                    };
                                                    additionalProperties: boolean;
                                                };
                                            };
                                            additionalProperties: false;
                                        }>;
                                    };
                                    noteActions: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 256;
                                        items: Readonly<{
                                            type: "object";
                                            required: string[];
                                            properties: {
                                                id: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                icon: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                runtime: {
                                                    const: string;
                                                };
                                                permissions: {
                                                    type: string;
                                                    minItems: number;
                                                    maxItems: 17;
                                                    uniqueItems: boolean;
                                                    items: {
                                                        enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                                    };
                                                    contains: {
                                                        const: string;
                                                    };
                                                };
                                                surfaces: {
                                                    type: string;
                                                    minItems: number;
                                                    maxItems: 2;
                                                    uniqueItems: boolean;
                                                    items: {
                                                        enum: readonly ["editor", "search"];
                                                    };
                                                };
                                                appliesTo: {
                                                    type: string;
                                                    properties: {
                                                        noteTypes: {
                                                            type: string;
                                                            minItems: number;
                                                            maxItems: 64;
                                                            uniqueItems: boolean;
                                                            items: Readonly<{
                                                                type: "string";
                                                                pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                                maxLength: 64;
                                                            }>;
                                                        };
                                                        allTags: {
                                                            type: string;
                                                            minItems: number;
                                                            maxItems: 64;
                                                            uniqueItems: boolean;
                                                            items: Readonly<{
                                                                type: "string";
                                                                minLength: 1;
                                                                maxLength: 128;
                                                            }>;
                                                        };
                                                        anyTags: {
                                                            type: string;
                                                            minItems: number;
                                                            maxItems: 64;
                                                            uniqueItems: boolean;
                                                            items: Readonly<{
                                                                type: "string";
                                                                minLength: 1;
                                                                maxLength: 128;
                                                            }>;
                                                        };
                                                        requiredProperties: {
                                                            type: string;
                                                            minItems: number;
                                                            maxItems: 64;
                                                            uniqueItems: boolean;
                                                            items: Readonly<{
                                                                type: "string";
                                                                minLength: 1;
                                                                maxLength: 128;
                                                            }>;
                                                        };
                                                    };
                                                    additionalProperties: boolean;
                                                };
                                            };
                                            additionalProperties: false;
                                        }>;
                                    };
                                    fileViewers: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 256;
                                        items: Readonly<{
                                            type: "object";
                                            required: string[];
                                            properties: {
                                                id: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                icon: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                runtime: {
                                                    enum: readonly ["native", "sandboxed-page", "live-sandboxed"];
                                                };
                                                rendererMode: {
                                                    enum: readonly ["native-imperative", "sandboxed-page", "live-declarative"];
                                                };
                                                permissions: {
                                                    type: string;
                                                    minItems: number;
                                                    maxItems: 17;
                                                    uniqueItems: boolean;
                                                    items: {
                                                        enum: readonly ["notes.read", "notes.write", "notes.properties.write", "notes.trash", "assets.read", "assets.write", "search.query", "metadata.read", "secrets.use", "network.request", "jobs.schedule", "ui.editor.embed", "ui.editor.extension", "ui.markdown.render", "ui.note.action", "ui.file.viewer", "workspace.navigate"];
                                                    };
                                                    allOf: {
                                                        contains: {
                                                            const: string;
                                                        };
                                                    }[];
                                                };
                                                extensions: {
                                                    type: string;
                                                    minItems: number;
                                                    maxItems: 32;
                                                    uniqueItems: boolean;
                                                    items: {
                                                        type: string;
                                                        pattern: string;
                                                    };
                                                };
                                                mediaTypes: {
                                                    type: string;
                                                    minItems: number;
                                                    maxItems: 32;
                                                    uniqueItems: boolean;
                                                    items: {
                                                        type: string;
                                                        pattern: string;
                                                    };
                                                };
                                                maxBytes: {
                                                    type: string;
                                                    minimum: number;
                                                    maximum: number;
                                                };
                                                content: {
                                                    enum: string[];
                                                };
                                            };
                                            additionalProperties: false;
                                        }>;
                                    };
                                    settings: Readonly<{
                                        type: "object";
                                        required: string[];
                                        properties: {
                                            sections: {
                                                type: string;
                                                minItems: number;
                                                maxItems: 32;
                                                items: {
                                                    type: string;
                                                    required: string[];
                                                    properties: {
                                                        id: Readonly<{
                                                            type: "string";
                                                            pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                            maxLength: 64;
                                                        }>;
                                                        title: Readonly<{
                                                            type: "string";
                                                            minLength: 1;
                                                            maxLength: 256;
                                                        }>;
                                                        fields: {
                                                            type: string;
                                                            minItems: number;
                                                            maxItems: 256;
                                                            items: Readonly<{
                                                                type: "object";
                                                                required: string[];
                                                                properties: {
                                                                    key: {
                                                                        type: string;
                                                                        pattern: string;
                                                                        maxLength: 128;
                                                                    };
                                                                    type: {
                                                                        enum: readonly ["text", "textarea", "number", "checkbox", "select", "url", "note", "folder", "asset", "secret"];
                                                                    };
                                                                    title: Readonly<{
                                                                        type: "string";
                                                                        minLength: 1;
                                                                        maxLength: 256;
                                                                    }>;
                                                                    description: {
                                                                        type: string;
                                                                        maxLength: 2048;
                                                                    };
                                                                    required: {
                                                                        type: string;
                                                                    };
                                                                    storage: {
                                                                        enum: readonly ["synced", "local", "encrypted-secret"];
                                                                    };
                                                                    placeholder: {
                                                                        type: string;
                                                                        maxLength: 2048;
                                                                    };
                                                                    default: {
                                                                        type: string[];
                                                                    };
                                                                    minLength: {
                                                                        type: string;
                                                                        minimum: number;
                                                                    };
                                                                    maxLength: {
                                                                        type: string;
                                                                        minimum: number;
                                                                    };
                                                                    min: {
                                                                        type: string;
                                                                    };
                                                                    max: {
                                                                        type: string;
                                                                    };
                                                                    step: {
                                                                        type: string;
                                                                        exclusiveMinimum: number;
                                                                    };
                                                                    sensitiveName: {
                                                                        type: string;
                                                                    };
                                                                    options: {
                                                                        type: string;
                                                                        minItems: number;
                                                                        maxItems: 256;
                                                                        items: {
                                                                            type: string;
                                                                            required: string[];
                                                                            properties: {
                                                                                value: {
                                                                                    type: string;
                                                                                    maxLength: 128;
                                                                                };
                                                                                title: Readonly<{
                                                                                    type: "string";
                                                                                    minLength: 1;
                                                                                    maxLength: 256;
                                                                                }>;
                                                                            };
                                                                            additionalProperties: boolean;
                                                                        };
                                                                    };
                                                                };
                                                                additionalProperties: false;
                                                                allOf: {
                                                                    if: {
                                                                        properties: {
                                                                            type: {
                                                                                const: string;
                                                                            };
                                                                        };
                                                                        required: string[];
                                                                    };
                                                                    then: {
                                                                        properties: {
                                                                            storage: {
                                                                                const: string;
                                                                            };
                                                                        };
                                                                    };
                                                                    else: {
                                                                        properties: {
                                                                            storage: {
                                                                                enum: string[];
                                                                            };
                                                                            sensitiveName: boolean;
                                                                        };
                                                                    };
                                                                }[];
                                                            }>;
                                                        };
                                                    };
                                                    additionalProperties: boolean;
                                                };
                                            };
                                        };
                                        additionalProperties: false;
                                    }>;
                                    jobs: {
                                        type: string;
                                        minItems: number;
                                        maxItems: 32;
                                        items: Readonly<{
                                            type: "object";
                                            required: string[];
                                            properties: {
                                                id: Readonly<{
                                                    type: "string";
                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                    maxLength: 64;
                                                }>;
                                                title: Readonly<{
                                                    type: "string";
                                                    minLength: 1;
                                                    maxLength: 256;
                                                }>;
                                                triggers: {
                                                    type: string;
                                                    minItems: number;
                                                    maxItems: 8;
                                                    items: Readonly<{
                                                        oneOf: ({
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                };
                                                                noteSetting?: undefined;
                                                                minutes?: undefined;
                                                                minutesSetting?: undefined;
                                                                command?: undefined;
                                                                pathSetting?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                            oneOf?: undefined;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                };
                                                                noteSetting: {
                                                                    type: string;
                                                                    maxLength: 128;
                                                                };
                                                                minutes?: undefined;
                                                                minutesSetting?: undefined;
                                                                command?: undefined;
                                                                pathSetting?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                            oneOf?: undefined;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                };
                                                                minutes: {
                                                                    type: string;
                                                                    minimum: 5;
                                                                    maximum: 1440;
                                                                };
                                                                minutesSetting: {
                                                                    type: string;
                                                                    maxLength: 128;
                                                                };
                                                                noteSetting?: undefined;
                                                                command?: undefined;
                                                                pathSetting?: undefined;
                                                            };
                                                            oneOf: {
                                                                required: string[];
                                                            }[];
                                                            additionalProperties: boolean;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                };
                                                                command: Readonly<{
                                                                    type: "string";
                                                                    pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                                                    maxLength: 64;
                                                                }>;
                                                                noteSetting?: undefined;
                                                                minutes?: undefined;
                                                                minutesSetting?: undefined;
                                                                pathSetting?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                            oneOf?: undefined;
                                                        } | {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                type: {
                                                                    const: string;
                                                                };
                                                                pathSetting: {
                                                                    type: string;
                                                                    maxLength: 128;
                                                                };
                                                                noteSetting?: undefined;
                                                                minutes?: undefined;
                                                                minutesSetting?: undefined;
                                                                command?: undefined;
                                                            };
                                                            additionalProperties: boolean;
                                                            oneOf?: undefined;
                                                        })[];
                                                    }>;
                                                };
                                                concurrency: {
                                                    const: string;
                                                };
                                            };
                                            additionalProperties: false;
                                        }>;
                                    };
                                };
                                additionalProperties: false;
                            }>;
                        };
                        type: "object";
                        required: readonly ["manifestVersion", "id", "name", "version", "apiVersion", "runtime", "platforms", "permissions", "contributes"];
                        additionalProperties: false;
                        oneOf: readonly [{
                            readonly properties: {
                                readonly runtime: {
                                    readonly enum: readonly ["native", "sandboxed-page"];
                                };
                            };
                            readonly required: readonly ["entry", "integrity"];
                        }, {
                            readonly properties: {
                                readonly runtime: {
                                    readonly const: "live-sandboxed";
                                };
                                readonly entry: false;
                                readonly styles: false;
                                readonly assets: false;
                                readonly integrity: false;
                                readonly editorExtensionBuild: false;
                            };
                        }];
                        allOf: readonly [{
                            readonly if: {
                                readonly properties: {
                                    readonly runtime: {
                                        readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                                    };
                                };
                                readonly required: readonly ["runtime"];
                            };
                            readonly then: {
                                readonly properties: {
                                    readonly contributes: {
                                        readonly not: {
                                            readonly required: readonly ["searchPresentations"];
                                        };
                                    };
                                };
                            };
                        }, {
                            readonly if: {
                                readonly properties: {
                                    readonly runtime: {
                                        readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                                    };
                                };
                                readonly required: readonly ["runtime"];
                            };
                            readonly then: {
                                readonly properties: {
                                    readonly editorExtensionBuild: false;
                                    readonly contributes: {
                                        readonly not: {
                                            readonly required: readonly ["editorExtensions"];
                                        };
                                    };
                                };
                            };
                        }, {
                            readonly if: {
                                readonly properties: {
                                    readonly runtime: {
                                        readonly const: "sandboxed-page";
                                    };
                                };
                                readonly required: readonly ["runtime"];
                            };
                            readonly then: {
                                readonly properties: {
                                    readonly contributes: {
                                        readonly not: {
                                            readonly required: readonly ["markdownBlocks"];
                                        };
                                    };
                                };
                            };
                        }, {
                            readonly if: {
                                readonly properties: {
                                    readonly runtime: {
                                        readonly enum: readonly ["sandboxed-page", "live-sandboxed"];
                                    };
                                };
                                readonly required: readonly ["runtime"];
                            };
                            readonly then: {
                                readonly properties: {
                                    readonly contributes: {
                                        readonly not: {
                                            readonly required: readonly ["noteActions"];
                                        };
                                    };
                                };
                            };
                        }, {
                            readonly if: {
                                readonly properties: {
                                    readonly runtime: {
                                        readonly const: "live-sandboxed";
                                    };
                                };
                                readonly required: readonly ["runtime"];
                            };
                            readonly then: {
                                readonly properties: {
                                    readonly contributes: {
                                        readonly properties: {
                                            readonly fileViewers: {
                                                readonly items: {
                                                    readonly properties: {
                                                        readonly content: {
                                                            readonly const: "text";
                                                        };
                                                    };
                                                };
                                            };
                                        };
                                    };
                                };
                            };
                        }];
                        "x-thortiq-runtime-validation": readonly ["canonical NFC identities and paths", "exact integrity key equality", "cross-contribution references", "permission/runtime coherence", "setting-derived connection references"];
                    };
                    readonly javascript: {
                        type: string;
                        "x-thortiq-maxUtf8Bytes": number;
                    };
                    readonly css: {
                        type: string;
                        "x-thortiq-maxUtf8Bytes": number;
                    };
                    readonly settingsSchema: Readonly<{
                        type: "object";
                        required: string[];
                        properties: {
                            sections: {
                                type: string;
                                minItems: number;
                                maxItems: 32;
                                items: {
                                    type: string;
                                    required: string[];
                                    properties: {
                                        id: Readonly<{
                                            type: "string";
                                            pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                                            maxLength: 64;
                                        }>;
                                        title: Readonly<{
                                            type: "string";
                                            minLength: 1;
                                            maxLength: 256;
                                        }>;
                                        fields: {
                                            type: string;
                                            minItems: number;
                                            maxItems: 256;
                                            items: Readonly<{
                                                type: "object";
                                                required: string[];
                                                properties: {
                                                    key: {
                                                        type: string;
                                                        pattern: string;
                                                        maxLength: 128;
                                                    };
                                                    type: {
                                                        enum: readonly ["text", "textarea", "number", "checkbox", "select", "url", "note", "folder", "asset", "secret"];
                                                    };
                                                    title: Readonly<{
                                                        type: "string";
                                                        minLength: 1;
                                                        maxLength: 256;
                                                    }>;
                                                    description: {
                                                        type: string;
                                                        maxLength: 2048;
                                                    };
                                                    required: {
                                                        type: string;
                                                    };
                                                    storage: {
                                                        enum: readonly ["synced", "local", "encrypted-secret"];
                                                    };
                                                    placeholder: {
                                                        type: string;
                                                        maxLength: 2048;
                                                    };
                                                    default: {
                                                        type: string[];
                                                    };
                                                    minLength: {
                                                        type: string;
                                                        minimum: number;
                                                    };
                                                    maxLength: {
                                                        type: string;
                                                        minimum: number;
                                                    };
                                                    min: {
                                                        type: string;
                                                    };
                                                    max: {
                                                        type: string;
                                                    };
                                                    step: {
                                                        type: string;
                                                        exclusiveMinimum: number;
                                                    };
                                                    sensitiveName: {
                                                        type: string;
                                                    };
                                                    options: {
                                                        type: string;
                                                        minItems: number;
                                                        maxItems: 256;
                                                        items: {
                                                            type: string;
                                                            required: string[];
                                                            properties: {
                                                                value: {
                                                                    type: string;
                                                                    maxLength: 128;
                                                                };
                                                                title: Readonly<{
                                                                    type: "string";
                                                                    minLength: 1;
                                                                    maxLength: 256;
                                                                }>;
                                                            };
                                                            additionalProperties: boolean;
                                                        };
                                                    };
                                                };
                                                additionalProperties: false;
                                                allOf: {
                                                    if: {
                                                        properties: {
                                                            type: {
                                                                const: string;
                                                            };
                                                        };
                                                        required: string[];
                                                    };
                                                    then: {
                                                        properties: {
                                                            storage: {
                                                                const: string;
                                                            };
                                                        };
                                                    };
                                                    else: {
                                                        properties: {
                                                            storage: {
                                                                enum: string[];
                                                            };
                                                            sensitiveName: boolean;
                                                        };
                                                    };
                                                }[];
                                            }>;
                                        };
                                    };
                                    additionalProperties: boolean;
                                };
                            };
                        };
                        additionalProperties: false;
                    }>;
                    readonly formatVersion: {
                        readonly const: 1;
                    };
                    readonly pluginId: {
                        readonly type: "string";
                        readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
                        readonly maxLength: 64;
                    };
                    readonly apiVersion: {
                        readonly type: "string";
                        readonly maxLength: 64;
                    };
                    readonly revision: Readonly<{
                        type: "string";
                        pattern: "^sha256:[0-9a-f]{64}$";
                    }>;
                    readonly parentRevision: {
                        readonly oneOf: readonly [Readonly<{
                            type: "string";
                            pattern: "^sha256:[0-9a-f]{64}$";
                        }>, {
                            readonly type: "null";
                        }];
                    };
                };
                readonly additionalProperties: false;
                readonly "x-thortiq-maxUtf8Bytes": number;
                readonly "x-thortiq-runtime-validation": readonly ["canonical LF line endings", "NFC normalization only for schema-defined identifiers and keys", "bundle and manifest identity equality", "duplicate settings schema equality", "SHA-256 over every authoritative field except revision", "manifest/settings/provenance aggregate UTF-8 limit"];
            }>;
            readonly previousRevision: {
                readonly oneOf: readonly [Readonly<{
                    type: "string";
                    pattern: "^sha256:[0-9a-f]{64}$";
                }>, {
                    readonly type: "null";
                }];
            };
        };
        readonly additionalProperties: false;
    }, {
        readonly type: "object";
        readonly required: readonly ["status", "expectedRevision", "actualRevision"];
        readonly properties: {
            readonly status: {
                readonly const: "stale";
            };
            readonly expectedRevision: {
                readonly oneOf: readonly [Readonly<{
                    type: "string";
                    pattern: "^sha256:[0-9a-f]{64}$";
                }>, {
                    readonly type: "null";
                }];
            };
            readonly actualRevision: {
                readonly oneOf: readonly [Readonly<{
                    type: "string";
                    pattern: "^sha256:[0-9a-f]{64}$";
                }>, {
                    readonly type: "null";
                }];
            };
        };
        readonly additionalProperties: false;
    }, {
        readonly type: "object";
        readonly required: readonly ["status"];
        readonly properties: {
            readonly status: {
                readonly const: "not-found";
            };
        };
        readonly additionalProperties: false;
    }, {
        readonly type: "object";
        readonly required: readonly ["status", "actualRevision"];
        readonly properties: {
            readonly status: {
                readonly const: "already-exists";
            };
            readonly actualRevision: Readonly<{
                type: "string";
                pattern: "^sha256:[0-9a-f]{64}$";
            }>;
        };
        readonly additionalProperties: false;
    }];
}>;
