/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
    "/api/ingestion/config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get Ingestion configuration */
        get: operations["get_ingestion_config"];
        put?: never;
        /** Save Ingestion configuration */
        post: operations["save_ingestion_config"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/ingestion/health": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Health check endpoint for ingestion service */
        get: operations["health_check"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/ingestion/process": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Process JSON ingestion request */
        post: operations["process_json"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/ingestion/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get ingestion status */
        get: operations["get_status"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/ingestion/validate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Validate JSON data without processing */
        post: operations["validate_json"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List current logs (backward compatibility) */
        get: operations["list_logs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/logs/config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get current logging configuration */
        get: operations["get_config"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/logs/config/reload": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Reload logging configuration from file */
        post: operations["reload_config"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/logs/features": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get available log features and their current levels */
        get: operations["get_features"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/logs/level": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /** Update feature-specific log level at runtime */
        put: operations["update_feature_level"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/logs/stream": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Stream logs via Server-Sent Events (backward compatibility) */
        get: operations["stream_logs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/mutation": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Execute a mutation. */
        post: operations["execute_mutation"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/query": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Execute a query. */
        post: operations["execute_query"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/schema/{name}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get a schema by name. */
        get: operations["get_schema"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/schema/{name}/approve": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List schemas by specific state
         * @description Approve a schema for queries and mutations
         */
        post: operations["approve_schema"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/schema/{name}/block": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Block a schema from queries and mutations */
        post: operations["block_schema"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/schemas": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List all schemas. */
        get: operations["list_schemas"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/schemas/load": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Load schemas from standard directories into memory as Available */
        post: operations["load_schemas"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/security/system-key": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["get_system_public_key"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/private-key": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get the node's private key
         * @description This endpoint returns the node's private key for use by the UI.
         *     The private key is generated automatically when the node is created.
         */
        get: operations["get_node_private_key"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/public-key": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get the node's public key
         * @description This endpoint returns the node's public key for verification purposes.
         *     The public key is generated automatically when the node is created.
         */
        get: operations["get_node_public_key"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/reset-database": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Reset the database and restart the node
         * @description This endpoint completely resets the database by:
         *     1. Stopping network services
         *     2. Closing the current database
         *     3. Recreating a new database instance
         *     4. Clearing all data and state
         *
         *     This is a destructive operation that cannot be undone.
         */
        post: operations["reset_database"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/system/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get system status information */
        get: operations["get_system_status"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/transforms": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["list_transforms"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/transforms/queue": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get: operations["get_transform_queue"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api/transforms/queue/{id}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post: operations["add_to_transform_queue"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        /**
         * @description Specifies the AI provider to use for ingestion.
         * @enum {string}
         */
        AIProvider: "OpenRouter" | "Ollama";
        /** @description Declarative schema definition used by declarative transforms. */
        DeclarativeSchemaDefinition: {
            fields?: string[] | null;
            key?: components["schemas"]["KeyConfig"] | null;
            /** @description Schema name (same as transform name) */
            name: string;
            schema_type: components["schemas"]["SchemaType"];
            transform_fields?: {
                [key: string]: string;
            } | null;
        };
        FieldCommon: {
            field_mappers: {
                [key: string]: string;
            };
            molecule_uuid?: string | null;
            transform?: components["schemas"]["Transform"] | null;
            writable?: boolean;
        };
        FieldDefinition: {
            field_expression?: string | null;
        };
        /** @description Enumeration over all field variants. */
        FieldVariant: {
            Single: components["schemas"]["SingleField"];
        } | {
            Range: components["schemas"]["RangeField"];
        } | {
            HashRange: components["schemas"]["HashRangeField"];
        };
        /** @description Field that combines hash and range functionality for indexing */
        HashRangeField: {
            inner: components["schemas"]["FieldCommon"];
            molecule?: components["schemas"]["MoleculeHashRange"] | null;
        };
        /** @description Configuration for the ingestion module. */
        IngestionConfig: {
            /** @description Whether to auto-execute mutations after generation. */
            auto_execute_mutations: boolean;
            /**
             * Format: int32
             * @description Default trust distance for mutations.
             */
            default_trust_distance: number;
            /** @description Whether ingestion is enabled. */
            enabled: boolean;
            /**
             * Format: int32
             * @description Maximum number of retries for API calls.
             */
            max_retries: number;
            ollama: components["schemas"]["OllamaConfig"];
            openrouter: components["schemas"]["OpenRouterConfig"];
            provider: components["schemas"]["AIProvider"];
            /**
             * Format: int64
             * @description Timeout for API calls in seconds.
             */
            timeout_seconds: number;
        };
        /** @description Request for processing JSON ingestion */
        IngestionRequest: {
            /** @description Whether to auto-execute mutations after generation */
            auto_execute?: boolean | null;
            /** @description JSON data to ingest */
            data: unknown;
            /** @description Public key for mutations */
            pub_key?: string | null;
            /**
             * Format: int32
             * @description Trust distance for mutations
             */
            trust_distance?: number | null;
        };
        /** @description Response from the ingestion process */
        IngestionResponse: {
            /** @description Any errors that occurred during processing */
            errors: string[];
            /** @description Number of mutations successfully executed */
            mutations_executed: number;
            /** @description Number of mutations generated */
            mutations_generated: number;
            /** @description Whether a new schema was created */
            new_schema_created: boolean;
            /** @description Name of the schema used (existing or newly created) */
            schema_used?: string | null;
            /** @description Whether the ingestion was successful */
            success: boolean;
        };
        KeyConfig: {
            hash_field?: string | null;
            range_field?: string | null;
        };
        /** @description Represents resolved key values for hash and range components. */
        KeyValue: {
            hash?: string | null;
            range?: string | null;
        };
        LogConfigResponse: {
            current_level: string;
            message: string;
        };
        LogLevelUpdate: {
            feature: string;
            level: string;
        };
        /** @description A reference to a single atom version. */
        Molecule: {
            atom_uuid: string;
            molecule_uuid: string;
            status: components["schemas"]["MoleculeStatus"];
            update_history: components["schemas"]["MoleculeUpdate"][];
            /** Format: date-time */
            updated_at: string;
        };
        /** @description A hash-range-based collection of atom references stored in a nested HashMap<BTreeMap> structure.
         *
         *     This molecule type supports complex indexing where atoms are organized by:
         *     - Hash field: Groups related atoms together
         *     - Range field: Provides ordered access within each hash group
         *
         *     Structure: HashMap<hash_value, BTreeMap<range_value, atom_uuid>> */
        MoleculeHashRange: {
            /** @description Atom UUIDs organized by hash and range values
             *     Structure: HashMap<hash_value, BTreeMap<range_value, atom_uuid>> */
            atom_uuids: {
                [key: string]: {
                    [key: string]: string;
                };
            };
            status: components["schemas"]["MoleculeStatus"];
            /** @description History of status updates */
            update_history: components["schemas"]["MoleculeUpdate"][];
            /** @description Order in which atoms were added (for deterministic sampling) */
            update_order?: components["schemas"]["KeyValue"][];
            /**
             * Format: date-time
             * @description Timestamp when this molecule was last updated
             */
            updated_at: string;
            /** @description Unique identifier for this molecule */
            uuid: string;
        };
        /** @description A range-based collection of atom references stored in a BTreeMap. */
        MoleculeRange: {
            atom_uuids: {
                [key: string]: string;
            };
            status: components["schemas"]["MoleculeStatus"];
            update_history: components["schemas"]["MoleculeUpdate"][];
            /** Format: date-time */
            updated_at: string;
            uuid: string;
        };
        /** @enum {string} */
        MoleculeStatus: "Active" | "Deleted";
        MoleculeUpdate: {
            source_pub_key: string;
            status: components["schemas"]["MoleculeStatus"];
            /** Format: date-time */
            timestamp: string;
        };
        /** @description Configuration for the Ollama AI provider. */
        OllamaConfig: {
            base_url: string;
            model: string;
        };
        /** @description Configuration for the OpenRouter AI provider. */
        OpenRouterConfig: {
            api_key: string;
            base_url: string;
            model: string;
        };
        /** @description Field storing a range of values. */
        RangeField: {
            inner: components["schemas"]["FieldCommon"];
            molecule?: components["schemas"]["MoleculeRange"] | null;
        };
        /** @description Request body for database reset */
        ResetDatabaseRequest: {
            confirm: boolean;
        };
        /** @description Response for database reset */
        ResetDatabaseResponse: {
            message: string;
            success: boolean;
        };
        /** @description Structure for saving AI provider configuration. */
        SavedConfig: {
            ollama: components["schemas"]["OllamaConfig"];
            openrouter: components["schemas"]["OpenRouterConfig"];
            provider: components["schemas"]["AIProvider"];
        };
        /** @description Defines the structure, permissions, and payment requirements for a data collection.
         *
         *     A Schema is the fundamental building block for data organization in the database.
         *     It defines:
         *     - The collection's name and identity
         *     - Field definitions with their types and constraints
         *     - Field-level permission policies
         *     - Payment requirements for data access
         *     - Field mappings for schema transformation
         *
         *     Schemas provide a contract for data storage and access, ensuring:
         *     - Consistent data structure
         *     - Proper access control
         *     - Payment validation
         *     - Data transformation rules */
        Schema: {
            /** @description Collection of fields with their definitions and configurations */
            fields: {
                [key: string]: components["schemas"]["FieldVariant"];
            };
            /** @description SHA256 hash of the schema content for integrity verification */
            hash?: string | null;
            key?: components["schemas"]["KeyConfig"] | null;
            /** @description Unique name identifying this schema */
            name: string;
            schema_type: components["schemas"]["SchemaType"];
        };
        /** @description Represents the schema-level type information. */
        SchemaType: "Single" | {
            /** @description Schema that stores data in a key range */
            Range: {
                keyconfig: components["schemas"]["KeyConfig"];
            };
        } | {
            /** @description Schema that uses hashed and ranged keys for partitioning */
            HashRange: {
                keyconfig: components["schemas"]["KeyConfig"];
            };
        };
        /** @description Field storing a single value. */
        SingleField: {
            inner: components["schemas"]["FieldCommon"];
            molecule?: components["schemas"]["Molecule"] | null;
        };
        Transform: components["schemas"]["DeclarativeSchemaDefinition"] & Record<string, never>;
    };
    responses: never;
    parameters: never;
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
    get_ingestion_config: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Ingestion config */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IngestionConfig"];
                };
            };
        };
    };
    save_ingestion_config: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SavedConfig"];
            };
        };
        responses: {
            /** @description Saved */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Failed */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    health_check: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Health OK */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
            /** @description Health not OK */
            503: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
        };
    };
    process_json: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["IngestionRequest"];
            };
        };
        responses: {
            /** @description Ingestion response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IngestionResponse"];
                };
            };
        };
    };
    get_status: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Ingestion status */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
        };
    };
    validate_json: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": unknown;
            };
        };
        responses: {
            /** @description Validation result */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
            /** @description Invalid */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    list_logs: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List logs */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
        };
    };
    get_config: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Logging configuration */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["LogConfigResponse"];
                };
            };
        };
    };
    reload_config: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Reloaded */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Bad request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    get_features: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Features */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
        };
    };
    update_feature_level: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["LogLevelUpdate"];
            };
        };
        responses: {
            /** @description Updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Bad request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    stream_logs: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Stream logs */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    execute_mutation: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": unknown;
            };
        };
        responses: {
            /** @description Mutation result */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
            /** @description Bad request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    execute_query: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": unknown;
            };
        };
        responses: {
            /** @description Query result */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
            /** @description Bad request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    get_schema: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Schema name */
                name: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Schema */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Schema"];
                };
            };
            /** @description Schema not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    approve_schema: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Schema name */
                name: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Approved */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    block_schema: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Schema name */
                name: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Blocked */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    list_schemas: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of schemas */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    load_schemas: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Load attempt summary */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    get_system_public_key: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description System key */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    get_node_private_key: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Node private key */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
        };
    };
    get_node_public_key: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Node public key */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
        };
    };
    reset_database: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["ResetDatabaseRequest"];
            };
        };
        responses: {
            /** @description Database reset result */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ResetDatabaseResponse"];
                };
            };
            /** @description Bad request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ResetDatabaseResponse"];
                };
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ResetDatabaseResponse"];
                };
            };
        };
    };
    get_system_status: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description System status */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
        };
    };
    list_transforms: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Transforms list */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    get_transform_queue: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Queue info */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": unknown;
                };
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    add_to_transform_queue: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description Transform id */
                id: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Queued */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Server error */
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
}
