/**
 * Checked into the package through scripts/generate-artifacts.mjs. Cross-field
 * references and exact integrity-key equality are additionally enforced by
 * validatePluginManifestV2 and are called out through the extension keyword.
 */
export declare const PLUGIN_MANIFEST_V2_JSON_SCHEMA: Readonly<{
    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
    readonly $id: "https://thortiq.local/schemas/plugin-manifest-v2.json";
    readonly title: "Thortiq Plugin Manifest v2";
    readonly type: "object";
    readonly required: readonly ["manifestVersion", "id", "name", "version", "apiVersion", "runtime", "platforms", "permissions", "contributes"];
    readonly properties: {
        readonly manifestVersion: {
            readonly const: 2;
        };
        readonly id: {
            readonly type: "string";
            readonly pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
            readonly maxLength: 64;
        };
        readonly name: Readonly<{
            type: "string";
            minLength: 1;
            maxLength: 256;
        }>;
        readonly description: {
            readonly type: "string";
            readonly maxLength: 2048;
        };
        readonly author: Readonly<{
            type: "string";
            minLength: 1;
            maxLength: 256;
        }>;
        readonly 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.-]+)?$";
        };
        readonly apiVersion: {
            readonly type: "string";
            readonly maxLength: 64;
        };
        readonly runtime: {
            readonly enum: readonly ["native", "sandboxed-page", "live-sandboxed"];
        };
        readonly platforms: {
            readonly type: "array";
            readonly minItems: 1;
            readonly maxItems: 3;
            readonly uniqueItems: true;
            readonly items: {
                readonly enum: readonly ["web", "capacitor", "desktop"];
            };
        };
        readonly 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"];
            };
        };
        readonly entry: {
            readonly type: "string";
            readonly maxLength: 4096;
        };
        readonly styles: {
            readonly type: "array";
            readonly minItems: 1;
            readonly maxItems: number;
            readonly uniqueItems: true;
            readonly items: {
                readonly type: "string";
                readonly maxLength: 4096;
            };
        };
        readonly assets: {
            readonly type: "array";
            readonly minItems: 1;
            readonly maxItems: number;
            readonly uniqueItems: true;
            readonly items: {
                readonly type: "string";
                readonly maxLength: 4096;
            };
        };
        readonly integrity: {
            readonly type: "object";
            readonly maxProperties: number;
            readonly patternProperties: {
                readonly "^.+$": {
                    readonly type: "string";
                    readonly pattern: "^sha256:[0-9a-f]{64}$";
                };
            };
            readonly additionalProperties: false;
        };
        readonly 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;
        };
        readonly 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;
                })[];
            };
        }>;
        readonly 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;
        }>;
    };
    readonly additionalProperties: false;
    readonly 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;
        };
    }];
    readonly 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";
                                    };
                                };
                            };
                        };
                    };
                };
            };
        };
    }];
    readonly "x-thortiq-runtime-validation": readonly ["canonical NFC identities and paths", "exact integrity key equality", "cross-contribution references", "permission/runtime coherence", "setting-derived connection references"];
}>;
