XFE Git
XFE Studio Git
Git 首页 全局搜索
XFE 主站 文档 NuGet

XFEServerManager

【Java】我的世界XFE服务器管理器

公开
关注 0 Fork 0 Star 0
UTF-8
/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
    "/meta": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read public API and first-owner setup state */
        get: operations["getApiMetadata"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/setup": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Create the first owner with a physical-console token */
        post: operations["setupInitialOwner"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/bootstrap": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Deprecated alias for /setup
         * @deprecated
         */
        post: operations["bootstrapOwner"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/login": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Start an authenticated session */
        post: operations["login"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/session": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read the current session or anonymous setup state */
        get: operations["getCurrentSession"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/logout": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Revoke the current session */
        post: operations["logout"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/totp/enrollment": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Begin TOTP enrollment */
        post: operations["beginTotpEnrollment"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/totp/confirm": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Confirm TOTP and issue recovery codes */
        post: operations["confirmTotpEnrollment"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/reauthenticate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Refresh recent-authentication assurance with TOTP */
        post: operations["reauthenticate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/sessions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List account sessions */
        get: operations["listSessions"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/sessions/{sessionId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /** Revoke an account session */
        delete: operations["revokeSession"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/accounts": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List Web management accounts
         * @description Owner-only. Password hashes, TOTP secrets and recovery codes are never returned.
         */
        get: operations["listAccounts"];
        put?: never;
        /**
         * Create a Web management account
         * @description Owner-only; requires a TOTP-authenticated session and recent password authentication.
         */
        post: operations["createAccount"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/accounts/{accountId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Delete a Web management account
         * @description Owner-only with TOTP and recent authentication. Deleting the last owner is rejected atomically.
         */
        delete: operations["deleteAccount"];
        options?: never;
        head?: never;
        /**
         * Change an account role or disabled state
         * @description Owner-only with TOTP and recent authentication. Demoting or disabling the last owner is rejected atomically and changing an account revokes its existing sessions.
         */
        patch: operations["updateAccount"];
        trace?: never;
    };
    "/healthz": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read process health */
        get: operations["getHealth"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/events": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Stream management events */
        get: operations["streamEvents"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read server status */
        get: operations["getServerStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/features": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read effective feature availability */
        get: operations["getFeatureFlags"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read safety-filtered effective settings */
        get: operations["getSettings"];
        /**
         * Save editable server settings
         * @description Owner-only. Requires CSRF, TOTP and recent authentication. Runtime-safe fields hot-apply; restartRequired is true only while startup-only fields differ. Legacy message properties are read-only after their one-time trigger migration.
         */
        put: operations["updateSettings"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/triggers": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read trigger groups and their trigger definitions */
        get: operations["getTriggerWorkspace"];
        put?: never;
        /**
         * Create a trigger
         * @description Administrator or owner with recent TOTP authentication. Arbitrary command actions additionally require the owner-only console capability.
         */
        post: operations["createTrigger"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/triggers/catalog": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List supported events, conditions, actions, and searchable template variables */
        get: operations["getTriggerCatalog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/triggers/validate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Validate a visual trigger program or compile and validate XFE Script without saving */
        post: operations["validateTriggerProgram"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/triggers/simulate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Simulate a saved or inline Trigger Program V2 without executing side effects */
        post: operations["simulateTrigger"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/triggers/{triggerId}/variables": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                triggerId: string;
            };
            cookie?: never;
        };
        /** Read the trigger engine's current in-memory variable projection */
        get: operations["getTriggerVariableValues"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/triggers/{triggerId}/state": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                triggerId: string;
            };
            cookie?: never;
        };
        /** Read non-expired TTL and persistent variable rows */
        get: operations["getTriggerState"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /** Compare-and-set one durable trigger variable */
        patch: operations["patchTriggerState"];
        trace?: never;
    };
    "/trigger-executions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List retained trigger execution records (manual simulations in the current runtime) */
        get: operations["listTriggerExecutions"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-executions/{executionId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read an execution and its retained detailed trace */
        get: operations["getTriggerExecution"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-event-captures": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List bounded opt-in event capture sessions */
        get: operations["listTriggerEventCaptures"];
        put?: never;
        /** Start a redacted event capture session for at most 30 minutes and 500 samples */
        post: operations["startTriggerEventCapture"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-event-captures/{captureId}/samples": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List redacted samples in a capture session */
        get: operations["listTriggerEventSamples"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-event-samples/{sampleId}/simulate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Replay a redacted sample through the read-only simulator */
        post: operations["simulateTriggerEventSample"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-libraries": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List installed declarative trigger library versions */
        get: operations["listTriggerLibraries"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-libraries/validate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Validate an .xfelib manifest, dependency DAG, engine range, types, and risk */
        post: operations["validateTriggerLibrary"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-libraries/import": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Install a validated declarative .xfelib package */
        post: operations["importTriggerLibrary"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-libraries/upgrade": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Upgrade an installed namespace after compatibility validation */
        post: operations["upgradeTriggerLibrary"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-libraries/{namespace}/rollback": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Activate a previous compatible library version */
        post: operations["rollbackTriggerLibrary"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-libraries/{namespace}/{version}/export": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Export an installed declarative .xfelib package */
        get: operations["exportTriggerLibrary"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/triggers/{triggerId}": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                triggerId: string;
            };
            cookie?: never;
        };
        get?: never;
        /** Replace a trigger with optimistic revision checking */
        put: operations["updateTrigger"];
        post?: never;
        /** Delete a trigger */
        delete: operations["deleteTrigger"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-groups": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Create a trigger group */
        post: operations["createTriggerGroup"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/trigger-groups/{groupId}": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                groupId: string;
            };
            cookie?: never;
        };
        get?: never;
        /** Replace a trigger group with optimistic revision checking */
        put: operations["updateTriggerGroup"];
        post?: never;
        /** Delete a trigger group and its triggers */
        delete: operations["deleteTriggerGroup"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/menus": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List interactive UI menu documents */
        get: operations["listMenus"];
        put?: never;
        /** Create an interactive UI menu */
        post: operations["createMenu"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/menus/catalog": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List menu positions, controls, events and compatible menu.control triggers */
        get: operations["getMenuCatalog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/menus/images": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Search uploaded images and vanilla/mod item, block and texture resources */
        get: operations["searchMenuImages"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/menus/images/preview": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Resolve an uploaded, vanilla, or installed-mod image reference for browser preview */
        get: operations["getMenuImagePreview"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/menus/{menuId}": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                menuId: string;
            };
            cookie?: never;
        };
        get?: never;
        /** Replace a menu with optimistic revision checking */
        put: operations["updateMenu"];
        post?: never;
        /** Delete an unreferenced menu */
        delete: operations["deleteMenu"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/menu-assets": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Upload a bounded PNG or JPEG menu image */
        post: operations["uploadMenuImage"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/menu-assets/{assetId}": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                assetId: string;
            };
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /** Delete an image that is not referenced by a menu */
        delete: operations["deleteMenuImage"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/menu-assets/{assetId}/content": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read one uploaded image as a data URL for the Web editor */
        get: operations["getMenuImageContent"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/economy": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read the economy workspace and aggregate overview */
        get: operations["getEconomyWorkspace"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/economy/currencies": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List every configured currency */
        get: operations["listCurrencies"];
        put?: never;
        /** Create a currency */
        post: operations["createCurrency"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/economy/currencies/{currencyId}": {
        parameters: {
            query?: never;
            header?: never;
            path: {
                currencyId: string;
            };
            cookie?: never;
        };
        get?: never;
        /** Replace a currency with optimistic revision checking */
        put: operations["updateCurrency"];
        post?: never;
        /** Delete an unused non-primary currency */
        delete: operations["deleteCurrency"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/economy/accounts": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Search player economy accounts */
        get: operations["listEconomyAccounts"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/economy/transactions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Search the immutable economy ledger */
        get: operations["listEconomyTransactions"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/economy/adjustments": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Deposit, withdraw or set one player's exact balance */
        post: operations["adjustEconomyBalance"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/economy/transfers": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Atomically transfer currency between two players */
        post: operations["transferEconomyBalance"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/metrics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Export OpenMetrics */
        get: operations["getMetrics"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/players": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List players */
        get: operations["listPlayers"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/players/{playerId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read player details */
        get: operations["getPlayer"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/players/{playerId}/actions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Preview or execute an online-player action */
        post: operations["executePlayerAction"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/players/{playerId}/inventory": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read an online player's inventory */
        get: operations["getPlayerInventory"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /** Compare-and-swap inventory slots */
        patch: operations["updatePlayerInventory"];
        trace?: never;
    };
    "/players/{playerId}/ender-chest": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read an online player's ender chest */
        get: operations["getPlayerEnderChest"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /** Compare-and-swap ender-chest slots */
        patch: operations["updatePlayerEnderChest"];
        trace?: never;
    };
    "/policies": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List policy versions */
        get: operations["listPolicies"];
        put?: never;
        /** Create a policy draft */
        post: operations["createPolicyDraft"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/policies/{versionId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read a policy version */
        get: operations["getPolicyVersion"];
        put?: never;
        post?: never;
        /** Discard the current unpublished draft */
        delete: operations["discardPolicyDraft"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/policies/{versionId}/validate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Validate a policy draft */
        post: operations["validatePolicy"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/policies/{versionId}/diff": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Diff a policy version against another revision */
        get: operations["diffPolicy"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/policies/simulate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Simulate policy decisions */
        post: operations["simulatePolicy"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/policies/{versionId}/publish": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Publish a validated policy */
        post: operations["publishPolicy"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/policies/{versionId}/rollback": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Restore a historical policy */
        post: operations["rollbackPolicy"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/audit": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Search audit events */
        get: operations["listAuditEvents"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Submit a structured player or system operation */
        post: operations["submitOperation"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/{operationId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read operation status */
        get: operations["getOperation"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/{operationId}/cancel": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Cancel an operation */
        post: operations["cancelOperation"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/console/commands": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Execute an owner console command
         * @description Owner-only and disabled by default. The session must have TOTP assurance and recent password reauthentication.
         */
        post: operations["executeConsoleCommand"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/moderation/cases": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List moderation cases */
        get: operations["listModerationCases"];
        put?: never;
        /** Open a moderation case */
        post: operations["createModerationCase"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/moderation/cases/{caseId}/actions/{actionId}/revoke": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Revoke one sanction action in a moderation case */
        post: operations["revokeModerationAction"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/maintenance": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Read maintenance state */
        get: operations["getMaintenance"];
        /** Change maintenance state */
        put: operations["setMaintenance"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/maintenance/schedules": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Schedule a structured action
         * @description Schedules only structured actions, never arbitrary console commands. Graceful stops announce their target on creation, every five minutes in the final hour, and every second in the final minute.
         */
        post: operations["createMaintenanceSchedule"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/maintenance/announcements": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Broadcast an audited announcement immediately */
        post: operations["announceMaintenanceMessage"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/claims": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List claims */
        get: operations["listClaims"];
        put?: never;
        /** Create a claim */
        post: operations["createClaim"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/claims/{claimId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /** Delete a claim using an optimistic revision check */
        delete: operations["deleteClaim"];
        options?: never;
        head?: never;
        /** Update a claim */
        patch: operations["updateClaim"];
        trace?: never;
    };
    "/claims/{claimId}/transfer": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Begin an owner-to-owner claim transfer */
        post: operations["beginClaimTransfer"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/claims/transfers/{transferToken}/confirm": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Confirm a claim transfer as its intended recipient */
        post: operations["confirmClaimTransfer"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/world/changes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Search world changes */
        get: operations["lookupWorldChanges"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/rollbacks/preview": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Preview a rollback */
        post: operations["previewRollback"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/rollbacks": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Execute a rollback preview */
        post: operations["executeRollback"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/rollbacks/{operationId}/pause": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Pause a rollback */
        post: operations["pauseRollback"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/rollbacks/{operationId}/resume": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Resume a rollback */
        post: operations["resumeRollback"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/rollbacks/{operationId}/cancel": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Cancel an active rollback after reconciling any in-flight item */
        post: operations["cancelRollback"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/rollbacks/{operationId}/redo/preview": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Preview redo of a completed rollback */
        post: operations["previewRedoRollback"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        ApiMetadata: {
            name: string;
            /** @constant */
            apiVersion: "v1";
            setupRequired: boolean;
            serverReady: boolean;
        };
        SetupRequest: {
            bootstrapToken: string;
            username: components["schemas"]["AccountUsername"];
            password: string;
        };
        Actor: {
            /** Format: uuid */
            id: string;
            displayName: string;
            roles: ("observer" | "helper" | "moderator" | "administrator" | "owner")[];
            permissions: string[];
            totpEnabled: boolean;
            totpVerified: boolean;
            reauthenticationRequired: boolean;
        };
        SessionInfo: {
            authenticated: boolean;
            actor?: components["schemas"]["Actor"];
            csrfToken?: string;
            bootstrapRequired: boolean;
            /** Format: date-time */
            expiresAt?: string;
        };
        Session: {
            /** Format: uuid */
            id: string;
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            lastSeenAt: string;
            /** Format: date-time */
            expiresAt: string;
            current: boolean;
            /** @description Redacted source label */
            source?: string;
        };
        AccountUsername: string;
        /** @enum {string} */
        AccountRole: "observer" | "helper" | "moderator" | "administrator" | "owner";
        Account: {
            /** Format: uuid */
            id: string;
            username: components["schemas"]["AccountUsername"];
            role: components["schemas"]["AccountRole"];
            totpEnabled: boolean;
            disabled: boolean;
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
            /** Format: date-time */
            lastLoginAt?: string | null;
        };
        AccountCreate: {
            username: components["schemas"]["AccountUsername"];
            password: string;
            role: components["schemas"]["AccountRole"];
        };
        AccountPatch: {
            role?: components["schemas"]["AccountRole"];
            disabled?: boolean;
        };
        Problem: {
            /** Format: uri-reference */
            type: string;
            title: string;
            status: number;
            detail: string;
            /** Format: uri-reference */
            instance?: string | null;
            requestId: string;
            extensions?: {
                [key: string]: unknown;
            };
        };
        PageMetadata: {
            nextCursor?: string | null;
            hasMore: boolean;
        };
        Health: {
            /** @enum {string} */
            http: "running" | "starting" | "stopping" | "stopped" | "failed";
            serverReady: boolean;
            sseClients: number;
        };
        ServerStatus: {
            /** Format: date-time */
            sampledAt: string;
            serverName?: string;
            minecraftVersion?: string;
            forgeVersion?: string;
            onlineMode?: boolean;
            uptimeSeconds: number;
            tps?: number;
            mspt?: {
                average?: number;
                p95?: number;
                p99?: number;
                jitter?: number;
            };
            cpuLoad?: number;
            heapUsedBytes?: number;
            heapMaxBytes?: number;
            gcPauseMs?: number;
            diskFreeBytes?: number;
            playersOnline: number;
            playersMax?: number;
            averagePingMs?: number;
            dimensions?: {
                id?: string;
                loadedChunks?: number;
                entities?: number;
            }[];
            samples?: {
                /** Format: date-time */
                at: string;
                tps?: number;
                mspt?: number;
            }[];
        };
        FeatureFlags: {
            consoleEnabled: boolean;
            moderationEnabled: boolean;
            claimsEnabled: boolean;
            worldTrackingEnabled: boolean;
            rollbackEnabled: boolean;
            /** @description Legacy compatibility status; authoring moved to triggers. */
            joinExperienceEnabled: boolean;
            metricsEnabled: boolean;
        };
        ServerSettings: {
            bindAddress: string;
            port: number;
            trustedProxyCidrs: string[];
            /** Format: uri */
            publicBaseUrl?: string;
            idleSessionSeconds?: number;
            absoluteSessionSeconds?: number;
            recentAuthenticationSeconds?: number;
            httpThreads?: number;
            maximumSseClients?: number;
            webConsoleEnabled?: boolean;
            rawItemEditingEnabled?: boolean;
            metricsEnabled?: boolean;
            moderationEnabled?: boolean;
            claimsEnabled?: boolean;
            worldTrackingEnabled?: boolean;
            rollbackEnabled?: boolean;
            /** @deprecated */
            readonly joinExperienceEnabled?: boolean;
            /** @deprecated */
            readonly joinWelcomeEnabled?: boolean;
            /** @deprecated */
            readonly joinWelcomeMessage?: string;
            /** @deprecated */
            readonly firstJoinMessageEnabled?: boolean;
            /** @deprecated */
            readonly firstJoinMessage?: string;
            /** @deprecated */
            readonly dailyAnnouncementsEnabled?: boolean;
            /** @deprecated */
            readonly dailyAnnouncements?: string[];
            /** @example Asia/Shanghai */
            announcementTimeZone?: string;
            /**
             * @description Sender prefix inherited by plain messages and rich messages that do not define an explicit sender. Applied immediately without a restart.
             * @default XFEServerManager
             */
            defaultMessageSender: string;
            /** @deprecated */
            readonly rulesReminderEnabled?: boolean;
            /** @deprecated */
            readonly rulesMessage?: string;
            /** @deprecated */
            readonly maintenanceJoinReminderEnabled?: boolean;
            crashProtection: components["schemas"]["CrashProtectionSettings"];
            restartRequired?: boolean;
            features: components["schemas"]["FeatureFlags"];
            serverLocale?: string;
            /** @constant */
            metricsRequireToken: true;
            offlineMode: boolean;
            sparkDetected: boolean;
            blueMapDetected: boolean;
        };
        /** @description Runtime-safe preemptive limits for entity floods, command-block loops, slow ticks, loaded chunks, and memory pressure. Players and existing living entities are never removed. */
        CrashProtectionSettings: {
            /** @default true */
            enabled: boolean;
            /** @default 100 */
            scanIntervalTicks: number;
            /** @default 2000 */
            itemEntitiesPerDimension: number;
            /** @default 256 */
            itemEntitiesPerChunk: number;
            /** @default 2000 */
            livingEntitiesPerDimension: number;
            /** @default 128 */
            livingEntitiesPerChunk: number;
            /** @default 5000 */
            totalEntitiesPerDimension: number;
            /** @default 512 */
            totalEntitiesPerChunk: number;
            /** @default 512 */
            entitiesPerNamespacePerDimension: number;
            /** @default 8000 */
            loadedChunksPerDimension: number;
            /** @default 400 */
            spawnBurstLimit: number;
            /** @default 100 */
            spawnBurstWindowTicks: number;
            /** @default 100 */
            commandBlockCommandsPerSecond: number;
            /** @default 200 */
            slowTickMillis: number;
            /** @default 3 */
            consecutiveSlowTicks: number;
            /** @default 90 */
            heapUsagePercent: number;
            /** @default true */
            blockExcessSpawns: boolean;
            /** @default true */
            removeExcessItems: boolean;
            /** @default true */
            stopRunawayCommandBlocks: boolean;
        };
        PlayerSummary: {
            /** Format: uuid */
            uuid: string;
            name: string;
            online: boolean;
            pingMs?: number;
            roles?: string[];
            opLevel?: number;
            gameMode?: string;
            health?: number;
            foodLevel?: number;
            location?: components["schemas"]["Position"] & {
                dimension: string;
            };
        };
        PlayerDetail: components["schemas"]["PlayerSummary"] & {
            /** Format: date-time */
            connectedAt?: string;
        };
        PlayerPage: {
            items: components["schemas"]["PlayerSummary"][];
            nextCursor?: string;
        };
        Position: {
            x: number;
            y: number;
            z: number;
        };
        Reason: {
            reason: string;
        };
        PlayerActionRequest: {
            /** @enum {string} */
            action: "message" | "kick" | "teleport" | "recall" | "heal" | "feed" | "gamemode" | "clear_effects" | "whitelist" | "ban";
            reason: string;
            value?: string;
            /**
             * Format: uuid
             * @deprecated
             * @description Optional UI cross-check; the path and frozen preview UUID are authoritative.
             */
            confirmedTargetUuid?: string;
            /** Format: uuid */
            previewToken?: string;
        };
        ItemStack: {
            slot: number;
            itemId: string;
            count: number;
            structuredData: {
                [key: string]: string;
            };
            /** @description True when server-side NBT/data components exist but are deliberately redacted. */
            readonly opaqueDataPresent: boolean;
            /** @description Non-reversible change marker; never a restorable raw payload. */
            readonly opaqueDataFingerprint: string;
        };
        ItemStackPatch: {
            slot: number;
            itemId: string;
            count: number;
            structuredData: {
                [key: string]: string;
            };
        };
        InventorySnapshot: {
            /** Format: uuid */
            playerUuid: string;
            /** @enum {string} */
            container: "inventory" | "ender_chest";
            revision: number;
            online: boolean;
            slots: components["schemas"]["ItemStack"][];
        };
        InventoryPatch: {
            expectedRevision: number;
            updates: components["schemas"]["ItemStackPatch"][];
            reason: string;
            /** @default false */
            rawEditingRequested: boolean;
        };
        InventorySlotDiff: {
            slot: number;
            before: components["schemas"]["ItemStack"];
            after: components["schemas"]["ItemStack"];
        };
        InventoryUpdateResult: components["schemas"]["Operation"] & {
            /** Format: int64 */
            revision: number;
            diffs: components["schemas"]["InventorySlotDiff"][];
        };
        PolicyDraft: {
            /** Format: int64 */
            expectedActiveVersion: number;
            description: string;
            rules: {
                [key: string]: unknown;
            }[];
        };
        PolicyPublishRequest: {
            /** Format: int64 */
            version: number;
            reason: string;
        };
        PolicyMutationRequest: {
            /** Format: int64 */
            expectedActiveVersion: number;
            reason: string;
        };
        PolicyVersion: {
            id: string;
            /** Format: int64 */
            version: number;
            name: string;
            description?: string;
            /** @enum {string} */
            state: "DRAFT" | "ACTIVE" | "ARCHIVED";
            groupCount: number;
            ruleCount: number;
            /** Format: date-time */
            updatedAt: string;
            updatedBy?: string;
            checksum?: string;
            rules?: components["schemas"]["PolicyRule"][];
            validation?: components["schemas"]["PolicyValidation"];
        };
        PolicyRule: {
            id: string;
            enabled: boolean;
            groupId: string;
            groupName: string;
            groupEnabled: boolean;
            /** @enum {string} */
            tier: "DEFAULT" | "OP_LEVEL" | "ROLE" | "UUID" | "HARD_SAFETY";
            subject: {
                [key: string]: unknown;
            };
            command: {
                [key: string]: unknown;
            };
            /** @enum {string} */
            effect: "PASS_THROUGH" | "DENY" | "GRANT" | "CONSTRAIN";
            constraints: {
                [key: string]: unknown;
            };
            reason: string;
        };
        PolicyPage: {
            items: components["schemas"]["PolicyVersion"][];
            nextCursor: string | null;
        };
        PolicyValidation: {
            valid: boolean;
            errors: components["schemas"]["PolicyValidationIssue"][];
            warnings: components["schemas"]["PolicyValidationIssue"][];
        };
        PolicyValidationIssue: {
            ruleId: string;
            code: string;
            message: string;
        };
        PolicySimulationRequest: {
            command: string;
            /** Format: uuid */
            playerUuid?: string | null;
        };
        PolicyDecision: {
            /** @enum {string} */
            decision: "PASS_THROUGH" | "DENY" | "GRANT" | "CONSTRAIN";
            explanation: string[];
            matchedRuleIds: string[];
            normalizedCommand: string;
        };
        AuditEvent: {
            /** Format: uuid */
            id: string;
            /** Format: date-time */
            at: string;
            actor: string;
            source: string;
            target?: string | null;
            action: string;
            reason?: string | null;
            requestId?: string;
            result: string;
            durationMs?: number;
        };
        AuditPage: {
            items: components["schemas"]["AuditEvent"][];
            nextCursor: string | null;
        };
        OperationRequest: {
            action: string;
            target?: unknown;
            reason: string;
            parameters?: {
                [key: string]: unknown;
            };
            /** Format: uuid */
            previewToken?: string;
        };
        Operation: {
            /** Format: uuid */
            id: string;
            kind: string;
            /** @enum {string} */
            state: "PREVIEW_REQUIRED" | "QUEUED" | "RUNNING" | "PAUSED" | "SUCCEEDED" | "PARTIAL" | "FAILED" | "CANCELLED";
            /** Format: date-time */
            createdAt?: string;
            /** Format: date-time */
            completedAt?: string;
            /** Format: date-time */
            expiresAt?: string;
            progress?: number;
            message?: string;
            requestId?: string;
            /** Format: uuid */
            previewToken?: string;
            targets?: {
                /** Format: uuid */
                uuid: string;
                name?: string;
            }[];
            result?: {
                [key: string]: unknown;
            } | number;
            results?: {
                [key: string]: unknown;
            }[];
            revision?: number;
            diffs?: {
                [key: string]: unknown;
            }[];
            error?: components["schemas"]["Problem"];
        };
        CreateModerationCase: {
            /** Format: uuid */
            playerId: string;
            /** @enum {string} */
            action: "warn" | "mute" | "kick" | "tempban" | "ban";
            reason: string;
            /** @description Player-facing message; defaults to reason when omitted. */
            message?: string;
            /** @description Required for tempban. Examples include 30m, 2h, 7d, or an ISO-8601 duration. */
            duration?: string;
            templateId?: string | null;
            /** Format: date-time */
            expiresAt?: string | null;
            evidenceUrls?: string[];
            staffNote?: string;
        };
        ModerationCase: {
            /** Format: uuid */
            id: string;
            /** Format: uuid */
            playerId: string;
            action: string;
            reason: string;
            message?: string;
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            expiresAt?: string | null;
            active: boolean;
            /** @description Seconds remaining, or -1 for a permanent/no-expiry action. */
            remainingSeconds?: number;
            evidenceUrls?: string[];
        };
        ModerationCasePage: {
            items: components["schemas"]["ModerationCase"][];
            page: components["schemas"]["PageMetadata"];
        };
        MaintenanceState: {
            enabled: boolean;
            whitelistOnly: boolean;
            message?: string;
            defaultMessageSender: string;
            /** Format: date-time */
            endsAt?: string | null;
            schedules: components["schemas"]["ScheduledAction"][];
        };
        MaintenanceRequest: {
            enabled: boolean;
            /** @default true */
            whitelistOnly: boolean;
            message?: string;
            /** Format: date-time */
            endsAt?: string | null;
            countdownSeconds?: number;
            reason: string;
        };
        ScheduledAction: {
            /** Format: uuid */
            readonly id?: string;
            /** @enum {string} */
            kind: "announce" | "enable_maintenance" | "disable_maintenance" | "save_flush" | "graceful_stop";
            /** Format: date-time */
            executeAt: string;
            arguments?: {
                [key: string]: unknown;
            };
            reason: string;
            /** @enum {string} */
            readonly status?: "PENDING" | "CLAIMED" | "COMPLETED" | "CANCELLED";
            readonly attempts?: number;
            /** Format: date-time */
            readonly leaseUntil?: string | null;
            /** Format: date-time */
            readonly completedAt?: string | null;
            readonly lastError?: string;
            readonly createdBy?: string;
        };
        TriggerWorkspace: {
            groups: components["schemas"]["TriggerGroup"][];
            totalTriggers: number;
        };
        TriggerCatalog: {
            /** @constant */
            schemaVersion: 2;
            catalogRevision: number;
            events: string[];
            operators: string[];
            actions: string[];
            actionParameters: {
                [key: string]: string[];
            };
            variables: components["schemas"]["TriggerVariableDefinition"][];
            categories?: ("events" | "eventResponses" | "valueFunctions" | "conditionFunctions" | "actions" | "types")[];
            variableLifetimes?: ("session" | "ttl" | "persistent")[];
            variableStorageScopes?: ("server" | "player" | "dimension" | "trigger" | "execution" | "chunk" | "entity")[];
            budgets?: {
                [key: string]: number;
            };
            descriptors?: {
                id: string;
                /** @enum {string} */
                kind: "EVENT" | "EVENT_RESPONSE" | "VALUE_FUNCTION" | "CONDITION_FUNCTION" | "ACTION" | "TYPE";
                displayName: string;
                description?: string;
                parameters: {
                    [key: string]: unknown;
                }[];
                returnType: string;
                /** @enum {string} */
                purity: "PURE" | "SNAPSHOT_QUERY" | "WORLD_QUERY" | "SIDE_EFFECT";
                /** @enum {string} */
                threadAffinity: "BACKGROUND" | "SERVER";
                /** @enum {string} */
                risk: "SAFE" | "ADMINISTRATOR" | "OWNER";
                supportedPlatforms: string[];
                applicableEvents: string[];
            }[];
            templates?: {
                id: string;
                name: string;
                description: string;
                integrations: string[];
                program: components["schemas"]["TriggerProgramV2"];
            }[];
            /** @description Isolated ServiceLoader provider failures; valid extensions remain available. */
            extensionDiagnostics?: string[];
            variableSyntax: components["schemas"]["TriggerVariableSyntax"];
            defaultMessageSender: string;
        };
        TriggerVariableDefinition: {
            /** @description Variable expression without the surrounding braces */
            key: string;
            nameZh: string;
            nameEn: string;
            descriptionZh: string;
            descriptionEn: string;
            category: string;
            /** @description Semantic UI scopes such as global, player-event, world, command, or schedule */
            scopes: string[];
            /** @description Complete placeholder ready for insertion */
            example: string;
            /** @description Example resolved value, or an empty string when no fixed sample is useful */
            sampleValue: string;
            formatHint: string;
            /** @enum {string} */
            type: "string" | "number" | "boolean" | "instant" | "datetime";
            /** @description Exact event IDs or bounded glob patterns; `*` means every event */
            events: string[];
            templateAllowed: boolean;
            conditionAllowed: boolean;
        };
        TriggerVariableSyntax: {
            /** @example {variable} */
            delimiter: string;
            /** @example {server.time:uuuu-MM-dd HH:mm:ss} */
            formattedTime: string;
            formatHint: string;
        };
        TriggerMutationResult: {
            trigger: components["schemas"]["Trigger"];
            workspace: components["schemas"]["TriggerWorkspace"];
        };
        TriggerValidation: {
            /** @constant */
            valid: true;
            event: components["schemas"]["TriggerEvent"];
            /** @enum {string} */
            conditionMode: "all" | "any";
            conditions: components["schemas"]["TriggerCondition"][];
            /** @description Root action nodes. The program is limited to 4096 nodes and 32 nesting levels. */
            actions: components["schemas"]["TriggerAction"][];
        };
        TriggerScriptValidationRequest: {
            script: string;
        };
        TriggerVisualValidationRequest: {
            event: components["schemas"]["TriggerEvent"];
            /** @enum {string} */
            conditionMode: "all" | "any";
            conditions: components["schemas"]["TriggerCondition"][];
            /** @description Root action nodes. The program is limited to 4096 nodes and 32 nesting levels. */
            actions: components["schemas"]["TriggerAction"][];
        };
        DeletionResult: {
            /** @constant */
            deleted: true;
            /** Format: uuid */
            id: string;
        };
        TriggerGroup: components["schemas"]["TriggerGroupInput"] & {
            /** Format: uuid */
            id: string;
            revision: number;
            triggers: components["schemas"]["Trigger"][];
            createdBy: string;
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
            migrated: boolean;
        };
        TriggerGroupInput: {
            name: string;
            description?: string;
            enabled: boolean;
            expectedRevision?: number;
        };
        Trigger: components["schemas"]["TriggerInput"] & {
            /** @constant */
            schemaVersion: 2;
            /** Format: uuid */
            id: string;
            revision: number;
            createdBy: string;
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
            migrated: boolean;
            events: components["schemas"]["TriggerEventBindingV2"][];
            declarations: components["schemas"]["TriggerVariableDeclarationV2"][];
            functions: components["schemas"]["TriggerFunctionV2"][];
            statements: components["schemas"]["TriggerStatementV2"][];
        };
        TriggerInput: {
            /**
             * @default 1
             * @enum {integer}
             */
            schemaVersion: 1 | 2;
            /** Format: uuid */
            groupId: string;
            name: string;
            description?: string;
            enabled: boolean;
            /** @enum {string} */
            mode: "visual" | "code";
            event?: components["schemas"]["TriggerEvent"];
            /** @enum {string} */
            conditionMode?: "all" | "any";
            conditions?: components["schemas"]["TriggerCondition"][];
            /** @description Root action nodes. The program is limited to 4096 nodes and 32 nesting levels. */
            actions?: components["schemas"]["TriggerAction"][];
            script?: string;
            expectedRevision?: number;
        } & ({
            /** @constant */
            mode?: "visual";
        } | {
            /** @constant */
            mode?: "code";
        } | {
            /** @constant */
            schemaVersion: 2;
            events: components["schemas"]["TriggerEventBindingV2"][];
            declarations: components["schemas"]["TriggerVariableDeclarationV2"][];
            functions: components["schemas"]["TriggerFunctionV2"][];
            statements: components["schemas"]["TriggerStatementV2"][];
        });
        TriggerEvent: {
            type: string;
            /** @description schedule.daily uses time and timezone. schedule.interval accepts legacy total seconds or hours/minutes/seconds components, normalizes them to total seconds (1..31536000), and aligns execution to server-local wall-clock boundaries. player.command_trigger uses command plus an optional legacy whitespace-separated arguments declaration. protection.* events use threshold and cooldownSeconds; count-based item/mob/entity events also accept scope=dimension|chunk, mod_entity_overflow accepts namespace, and slow_tick accepts consecutive. */
            configuration: {
                [key: string]: string;
            };
            /** @description Recursive Brigadier alternatives for player.command_trigger. Siblings are alternatives and children form the next input level. */
            arguments?: components["schemas"]["TriggerCommandArgument"][];
            /** @description Strongly typed trigger-local or server-global state declarations. Missing visibility/storage fields migrate as trigger-local trigger storage. */
            variables?: components["schemas"]["TriggerStateVariable"][];
        };
        TriggerCommandArgument: {
            name: string;
            /** @description A supported vanilla Brigadier argument family or literal. */
            type: string;
            literal: string;
            optional: boolean;
            errorMessage: string;
            minimum: string;
            maximum: string;
            suggestions: string[];
            children: components["schemas"]["TriggerCommandArgument"][];
        };
        TriggerStateVariable: {
            name: string;
            /** @description Scalar/object-reference type, record, legacy list, or recursively nested array<T>, set<T>, optional<T>, or dictionary<K,V>; dictionary keys must be scalar. */
            type: string;
            /** @description Scalars use their text form; arrays and dictionaries use strictly typed JSON. */
            initialValue: string;
            /**
             * @default trigger
             * @enum {string}
             */
            visibility: "trigger" | "global";
            /**
             * @description Selects the identity used to address one variable value.
             * @enum {string}
             */
            storage?: "server" | "player" | "dimension" | "trigger" | "execution" | "chunk" | "entity";
            /**
             * @default session
             * @enum {string}
             */
            lifetime: "session" | "ttl" | "persistent";
            ttlSeconds?: number | null;
            readonly revision?: number;
        };
        TriggerEventBindingV2: {
            /** Format: uuid */
            nodeId: string;
            type: string;
            configuration: {
                [key: string]: string;
            };
        };
        TriggerVariableDeclarationV2: {
            /** Format: uuid */
            nodeId: string;
            name: string;
            valueType: string;
            initialValue?: components["schemas"]["TriggerExpressionV2"];
            /** @enum {string} */
            visibility: "trigger" | "global";
            /** @enum {string} */
            storage: "server" | "player" | "dimension" | "trigger" | "execution" | "chunk" | "entity";
            /** @enum {string} */
            lifetime: "SESSION" | "TTL" | "PERSISTENT";
            ttlSeconds?: number | null;
        };
        TriggerFunctionParameterV2: {
            name: string;
            valueType: string;
            /** @enum {string} */
            mode: "IN" | "OUT" | "INOUT";
        };
        TriggerFunctionV2: {
            /** Format: uuid */
            nodeId: string;
            name: string;
            parameters: components["schemas"]["TriggerFunctionParameterV2"][];
            returnType: string;
            locals: components["schemas"]["TriggerVariableDeclarationV2"][];
            statements: components["schemas"]["TriggerStatementV2"][];
        };
        TriggerExpressionV2: {
            /** Format: uuid */
            nodeId: string;
            /** @enum {string} */
            kind: "LITERAL" | "REFERENCE" | "UNARY" | "BINARY" | "FUNCTION" | "INDEX" | "COALESCE" | "CONVERT";
            valueType: string;
            literal?: unknown;
            name: string;
            arguments: components["schemas"]["TriggerExpressionV2"][];
        };
        TriggerSwitchCaseV2: {
            /** Format: uuid */
            nodeId: string;
            match: components["schemas"]["TriggerExpressionV2"];
            statements: components["schemas"]["TriggerStatementV2"][];
        };
        TriggerStatementV2: {
            /** Format: uuid */
            nodeId: string;
            /** @enum {string} */
            kind: "ACTION" | "SET" | "IF" | "SWITCH" | "REPEAT" | "WHILE" | "FOREACH" | "BREAK" | "CONTINUE" | "CALL" | "RETURN" | "TRY";
            name: string;
            inputs: {
                [key: string]: components["schemas"]["TriggerExpressionV2"];
            };
            expression?: components["schemas"]["TriggerExpressionV2"];
            cases: components["schemas"]["TriggerSwitchCaseV2"][];
            statements: components["schemas"]["TriggerStatementV2"][];
            elseStatements: components["schemas"]["TriggerStatementV2"][];
        };
        TriggerProgramV2: {
            /** @constant */
            schemaVersion: 2;
            events: components["schemas"]["TriggerEventBindingV2"][];
            declarations: components["schemas"]["TriggerVariableDeclarationV2"][];
            functions: components["schemas"]["TriggerFunctionV2"][];
            statements: components["schemas"]["TriggerStatementV2"][];
        };
        TriggerProgramV2Validation: components["schemas"]["TriggerProgramV2"] & {
            /** @constant */
            valid: true;
        };
        TriggerVariableValues: {
            /** Format: uuid */
            triggerId: string;
            values: {
                [key: string]: unknown;
            };
            /** Format: date-time */
            observedAt: string;
        };
        TriggerDurableStateValue: {
            /** Format: uuid */
            triggerId: string;
            variableName: string;
            storage: string;
            storageKey: string;
            valueType: string;
            valueJson: string;
            /** Format: date-time */
            expiresAt?: string | null;
            revision: number;
            /** Format: date-time */
            updatedAt: string;
        };
        TriggerDurableState: {
            /** Format: uuid */
            triggerId: string;
            values: components["schemas"]["TriggerDurableStateValue"][];
            /** Format: date-time */
            observedAt: string;
        };
        TriggerStatePatch: {
            variableName: string;
            storageKey: string;
            value: unknown;
            expectedRevision: number;
        };
        TriggerSimulationRequest: {
            /** Format: uuid */
            triggerId?: string;
            program?: components["schemas"]["TriggerProgramV2"];
            event?: {
                [key: string]: unknown;
            };
            variables?: {
                [key: string]: unknown;
            };
            /**
             * Format: int64
             * @default 0
             */
            seed: number;
            /** Format: date-time */
            instant?: string;
        } & (unknown | unknown);
        TriggerTraceStep: {
            /** Format: int64 */
            sequence: number;
            /** Format: uuid */
            nodeId?: string | null;
            kind: string;
            result?: unknown;
            writes: {
                [key: string]: unknown;
            };
            instructions: number;
            /** Format: date-time */
            createdAt?: string;
        };
        TriggerPlannedAction: {
            /** Format: uuid */
            nodeId: string;
            type: string;
            parameters: {
                [key: string]: unknown;
            };
            idempotencyKey: string;
        };
        TriggerSimulationResult: {
            /** Format: uuid */
            executionId: string;
            /** @enum {string} */
            status: "COMPLETED" | "FAILED";
            error: string;
            variables: {
                [key: string]: unknown;
            };
            actions: components["schemas"]["TriggerPlannedAction"][];
            trace: components["schemas"]["TriggerTraceStep"][];
            instructions: number;
            /** Format: int64 */
            seed: number;
        };
        TriggerExecution: {
            /** Format: uuid */
            executionId: string;
            /** Format: uuid */
            triggerId?: string | null;
            triggerRevision: number;
            eventType: string;
            /** @enum {string} */
            status: "QUEUED" | "RUNNING" | "WAITING" | "COMPLETED" | "FAILED" | "CANCELLED" | "NEEDS_REVIEW" | "SIMULATED";
            /** Format: int64 */
            seed: number;
            summary: {
                [key: string]: unknown;
            };
            error: string;
            /** Format: date-time */
            startedAt: string;
            /** Format: date-time */
            updatedAt: string;
            /** Format: date-time */
            completedAt?: string | null;
            steps: components["schemas"]["TriggerTraceStep"][];
        };
        TriggerSimulationResponse: {
            program: components["schemas"]["TriggerProgramV2"];
            result: components["schemas"]["TriggerSimulationResult"];
            execution: components["schemas"]["TriggerExecution"];
        };
        TriggerEventCapture: {
            /** Format: uuid */
            captureId: string;
            createdBy: string;
            eventTypes: string[];
            /** Format: date-time */
            expiresAt: string;
            maximumSamples: number;
            sampleCount: number;
            /** Format: date-time */
            createdAt: string;
        };
        TriggerEventSample: {
            /** Format: uuid */
            sampleId: string;
            /** Format: uuid */
            captureId: string;
            eventType: string;
            context: {
                [key: string]: unknown;
            };
            /** Format: date-time */
            capturedAt: string;
        };
        TriggerLibraryManifest: {
            namespace: string;
            /** @description Semantic version */
            version: string;
            /** @example >=2.0.0 */
            engineRequirement: string;
            dependencies: {
                [key: string]: string;
            };
            displayName: string;
            description: string;
        };
        /** @description At most 2 MiB. This declarative format has no executable bytecode or script entry point. */
        TriggerLibraryPackage: {
            manifest: components["schemas"]["TriggerLibraryManifest"];
            triggers: {
                [key: string]: components["schemas"]["TriggerProgramV2"];
            };
            variables: {
                [key: string]: unknown;
            };
            functions: {
                [key: string]: unknown;
            };
            templates: {
                [key: string]: unknown;
            };
        };
        TriggerLibraryInstallation: {
            namespace: string;
            version: string;
            manifest: components["schemas"]["TriggerLibraryManifest"];
            active: boolean;
            installedBy: string;
            /** Format: date-time */
            installedAt: string;
        };
        TriggerCondition: {
            field: string;
            /** @enum {string} */
            operator: "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "not_starts_with" | "ends_with" | "not_ends_with" | "matches" | "not_matches" | "gt" | "gte" | "lt" | "lte" | "between" | "not_between" | "in" | "not_in" | "empty" | "not_empty" | "true" | "false" | "exists" | "not_exists";
            value: string;
        };
        /** @description An executable action, or a structural condition whose children run only when its field/operator/value passes. Only condition nodes may have children; programs are limited to 4096 nodes and 32 nesting levels. */
        TriggerAction: {
            /** @enum {string} */
            type: "condition" | "send_player" | "broadcast" | "title" | "actionbar" | "sound" | "server_command" | "player_command" | "kick" | "teleport" | "give_item" | "clear_inventory" | "set_gamemode" | "add_effect" | "remove_effects" | "heal" | "feed" | "set_health" | "set_food" | "set_experience" | "set_spawnpoint" | "scoreboard_set" | "scoreboard_add" | "team_join" | "team_leave" | "advancement_grant" | "advancement_revoke" | "spawn_entity" | "damage_entity" | "teleport_entity" | "remove_entity" | "set_entity_attribute" | "tag_entity" | "set_block" | "fill_blocks" | "explosion" | "lightning" | "set_time" | "set_weather" | "set_difficulty" | "set_gamerule" | "world_border" | "whitelist_add" | "whitelist_remove" | "ban" | "pardon" | "log" | "variable" | "wait" | "run_trigger" | "open_menu" | "close_menu" | "economy_deposit" | "economy_withdraw" | "economy_set_balance" | "economy_transfer" | "economy_deposit_player" | "economy_withdraw_player" | "economy_set_player_balance" | "economy_transfer_players";
            /** @description Condition nodes use field, operator, and value. Command actions accept showFeedback=true|false and default to false. Rich message envelopes are limited to 256 segments and 8192 visible characters and are validated on save. */
            parameters: {
                [key: string]: string;
            };
            /** @description Non-empty for condition nodes; omitted or empty for executable actions. */
            children?: components["schemas"]["TriggerAction"][];
        };
        MenuWorkspace: {
            menus: components["schemas"]["Menu"][];
            totalMenus: number;
        };
        MenuSaveResult: {
            menu: components["schemas"]["Menu"];
            workspace: components["schemas"]["MenuWorkspace"];
        };
        Menu: components["schemas"]["MenuInput"] & {
            /** Format: uuid */
            id: string;
            revision: number;
            createdBy: string;
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
        };
        MenuInput: {
            name: string;
            description?: string;
            width: number;
            height: number;
            /** @enum {string} */
            popupPosition: "center" | "top" | "bottom" | "left" | "right" | "top_left" | "top_right" | "bottom_left" | "bottom_right" | "custom";
            offsetX?: number;
            offsetY?: number;
            /** @default false */
            pauseGame: boolean;
            backgroundColor: string;
            controls: components["schemas"]["MenuControl"][];
        };
        MenuControl: {
            id: string;
            /** @enum {string} */
            type: "text" | "rich_text" | "button" | "icon_button" | "image" | "panel" | "border" | "progress" | "input" | "checkbox" | "slider" | "item_slot" | "separator" | "spacer";
            x: number;
            y: number;
            width: number;
            height: number;
            zIndex: number;
            visibleWhen: string;
            properties: {
                [key: string]: string;
            };
            events: components["schemas"]["MenuControlEvent"][];
        };
        MenuControlEvent: {
            /** @enum {string} */
            event: "click" | "double_click" | "change" | "submit" | "toggle" | "hover" | "focus" | "blur";
            /** @description Empty, or UUID of a menu.control trigger. */
            triggerId: string;
            /** @description Empty, or UUID of an existing acyclic submenu. */
            submenuId: string;
            closeMenu: boolean;
        };
        MenuCatalog: {
            controlTypes: string[];
            popupPositions: string[];
            controlEvents: string[];
            triggers: {
                /** Format: uuid */
                id: string;
                name: string;
                enabled: boolean;
            }[];
        };
        MenuImage: {
            /** Format: uuid */
            id?: string;
            /** @description uploaded:, texture:, item:, or block: reference. */
            reference: string;
            name: string;
            /** @enum {string} */
            type: "uploaded" | "texture" | "item" | "block";
            source: string;
            /** @enum {string} */
            mimeType?: "image/png" | "image/jpeg";
            width?: number;
            height?: number;
            sha256?: string;
            dataUrl?: string;
        };
        /** @description Exact base-10 amount. Floating-point JSON numbers are intentionally not accepted. */
        EconomyAmount: string;
        CurrencyFields: {
            code: string;
            name: string;
            symbol: string;
            /** @description uploaded:, texture:, item:, or block: reference. */
            icon: string;
            fractionDigits: number;
            initialBalance: components["schemas"]["EconomyAmount"];
            minimumBalance: components["schemas"]["EconomyAmount"];
            maximumBalance: components["schemas"]["EconomyAmount"];
            /** @description Allows player-initiated command payments; audited management and trigger transfers remain available. */
            playerTransferAllowed: boolean;
            enabled: boolean;
            primary: boolean;
        };
        CurrencyInput: components["schemas"]["CurrencyFields"] & {
            reason: string;
        };
        Currency: components["schemas"]["CurrencyFields"] & {
            /** Format: uuid */
            id: string;
            revision: number;
            createdBy: string;
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
        };
        EconomyBalance: {
            /** Format: uuid */
            currencyId: string;
            currencyCode: string;
            currencyName: string;
            symbol: string;
            icon: string;
            fractionDigits: number;
            amount: components["schemas"]["EconomyAmount"];
            revision: number;
            currencyEnabled: boolean;
            /** Format: date-time */
            updatedAt: string;
        };
        EconomyAccount: {
            /** Format: uuid */
            playerId: string;
            playerName: string;
            balances: components["schemas"]["EconomyBalance"][];
            /** Format: date-time */
            updatedAt: string;
        };
        EconomyTransaction: {
            /** Format: uuid */
            id: string;
            /** Format: uuid */
            currencyId: string;
            currencyCode: string;
            /** @enum {string} */
            kind: "initial" | "deposit" | "withdraw" | "set" | "transfer";
            /** Format: uuid */
            sourcePlayerId?: string;
            sourcePlayerName: string;
            /** Format: uuid */
            targetPlayerId?: string;
            targetPlayerName: string;
            amount: components["schemas"]["EconomyAmount"];
            sourceBalanceBefore: string;
            sourceBalanceAfter: string;
            targetBalanceBefore: string;
            targetBalanceAfter: string;
            reason: string;
            actor: string;
            /** @enum {string} */
            origin: "system" | "web" | "command" | "trigger";
            correlationId: string;
            /** Format: date-time */
            createdAt: string;
        };
        EconomyCurrencySummary: {
            /** Format: uuid */
            currencyId: string;
            code: string;
            name: string;
            symbol: string;
            icon: string;
            fractionDigits: number;
            enabled: boolean;
            primary: boolean;
            accountCount: number;
            totalSupply: components["schemas"]["EconomyAmount"];
            minimumBalance: components["schemas"]["EconomyAmount"];
            maximumBalance: components["schemas"]["EconomyAmount"];
            transactionCount: number;
            transferVolume24h: components["schemas"]["EconomyAmount"];
        };
        EconomyWorkspace: {
            currencies: components["schemas"]["Currency"][];
            overview: {
                currencies: components["schemas"]["EconomyCurrencySummary"][];
                /** Format: date-time */
                observedAt: string;
            };
        };
        EconomyChange: {
            currency: components["schemas"]["Currency"];
            transaction: components["schemas"]["EconomyTransaction"];
            sourceBalance?: components["schemas"]["EconomyBalance"];
            targetBalance?: components["schemas"]["EconomyBalance"];
        };
        ChunkPosition: {
            x: number;
            z: number;
        };
        Claim: {
            /** Format: uuid */
            id: string;
            name?: string;
            dimension: string;
            /** Format: uuid */
            ownerId: string;
            chunks: components["schemas"]["ChunkPosition"][];
            members: {
                [key: string]: "manager" | "member" | "trusted";
            };
            flags: {
                [key: string]: boolean;
            };
            revision: number;
        };
        CreateClaim: {
            name: string;
            dimension: string;
            chunks: components["schemas"]["ChunkPosition"][];
            /** @default false */
            adminOverride: boolean;
        };
        ClaimPatch: {
            expectedRevision: number;
            name?: string;
            chunks?: components["schemas"]["ChunkPosition"][];
            members?: {
                [key: string]: string;
            };
            flags?: {
                [key: string]: boolean;
            };
            /** Format: uuid */
            transferTo?: string;
            transferConfirmation?: string;
            reason: string;
        };
        ClaimPage: {
            items: components["schemas"]["Claim"][];
            page: components["schemas"]["PageMetadata"];
        };
        WorldChange: {
            /** Format: uuid */
            id: string;
            /** Format: date-time */
            timestamp: string;
            tick: number;
            dimension: string;
            position: components["schemas"]["Position"];
            /** Format: uuid */
            actorId?: string | null;
            cause?: string;
            action: string;
            resourceId: string;
            modFingerprint?: string | null;
            restorable: boolean;
            incompatibility?: string | null;
            /** Format: uuid */
            transactionId?: string;
        };
        WorldChangePage: {
            items: components["schemas"]["WorldChange"][];
            page: components["schemas"]["PageMetadata"];
            gaps: {
                /** Format: date-time */
                from?: string;
                /** Format: date-time */
                to?: string;
                reason?: string;
            }[];
        };
        RollbackSelection: {
            /** Format: date-time */
            from: string;
            /** Format: date-time */
            to: string;
            /** Format: uuid */
            actorId?: string | null;
            dimension?: string | null;
            center?: components["schemas"]["Position"];
            radius?: number;
            /** Format: uuid */
            claimId?: string | null;
            actions?: string[];
            /** @default false */
            includeEntitiesAndItems: boolean;
            reason: string;
        };
        RollbackPreview: {
            /** Format: uuid */
            id: string;
            /** Format: int64 */
            watermark: number;
            /** Format: date-time */
            expiresAt: string;
            selected: number;
            applicable: number;
            conflicts: number;
            unloadedChunks: number;
            gaps: number;
            incompatible: number;
            estimatedChunkLoads?: number;
            confirmationToken: string;
        };
    };
    responses: {
        /** @description RFC 9457 problem details */
        Problem: {
            headers: {
                "X-Request-ID": components["headers"]["RequestId"];
                [name: string]: unknown;
            };
            content: {
                "application/problem+json": components["schemas"]["Problem"];
            };
        };
        /** @description Preview requirement, accepted job, or operation completed within the bounded dispatch window */
        AcceptedOperation: {
            headers: {
                /** @description Relative operation status URL */
                Location?: string;
                "X-Request-ID": components["headers"]["RequestId"];
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["Operation"];
            };
        };
    };
    parameters: {
        /** @description Opaque cursor from the previous page; clients must not parse it. */
        Cursor: string;
        Limit: number;
        LastEventId: string;
        /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
        IdempotencyKey: string;
        /** @description Session-bound double-submit token required for same-origin mutations. */
        CsrfToken: string;
        PlayerId: string;
        AccountId: string;
        VersionId: string;
        OperationId: string;
        CaseId: string;
        ActionId: string;
        ClaimId: string;
    };
    requestBodies: never;
    headers: {
        /** @description Correlation ID generated by the server or accepted from a validated request header */
        RequestId: string;
    };
    pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
    getApiMetadata: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Public control-plane metadata */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ApiMetadata"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    setupInitialOwner: {
        parameters: {
            query?: never;
            header: {
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SetupRequest"];
            };
        };
        responses: {
            /** @description First owner created, token consumed, and session cookie issued */
            201: {
                headers: {
                    "Set-Cookie"?: string;
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SessionInfo"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    bootstrapOwner: {
        parameters: {
            query?: never;
            header: {
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SetupRequest"];
            };
        };
        responses: {
            /** @description First owner created, token consumed, and session cookie issued */
            201: {
                headers: {
                    "Set-Cookie"?: string;
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SessionInfo"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    login: {
        parameters: {
            query?: never;
            header: {
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    username: string;
                    password: string;
                    totp?: string | null;
                    recoveryCode?: string | null;
                };
            };
        };
        responses: {
            /** @description Session cookie and CSRF token issued */
            200: {
                headers: {
                    "Set-Cookie"?: string;
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SessionInfo"];
                };
            };
            /** @description Login or account-wide second-factor attempt limit reached */
            429: {
                headers: {
                    "Retry-After"?: number;
                    [name: string]: unknown;
                };
                content: {
                    "application/problem+json": components["schemas"]["Problem"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getCurrentSession: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Current browser session state */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SessionInfo"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    logout: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Session revoked */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            default: components["responses"]["Problem"];
        };
    };
    beginTotpEnrollment: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    password: string;
                };
            };
        };
        responses: {
            /** @description Unconfirmed TOTP secret and provisioning URI */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        secret: string;
                        /** Format: uri */
                        provisioningUri: string;
                        /** Format: date-time */
                        expiresAt: string;
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    confirmTotpEnrollment: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    code: string;
                };
            };
        };
        responses: {
            /** @description One-time recovery codes; retrying the same idempotency key repeats only this response */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        recoveryCodes: string[];
                    };
                };
            };
            /** @description Three unsuccessful second-factor attempts were made for this account within ten minutes */
            429: {
                headers: {
                    "Retry-After"?: number;
                    [name: string]: unknown;
                };
                content: {
                    "application/problem+json": components["schemas"]["Problem"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    reauthenticate: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Optional legacy reauthentication path; the Web UI uses TOTP only. */
                    password?: string | null;
                    totp?: string;
                    recoveryCode?: string | null;
                };
            };
        };
        responses: {
            /** @description The current server-side session now has recent-authentication assurance */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Three unsuccessful second-factor attempts were made for this account within ten minutes */
            429: {
                headers: {
                    "Retry-After"?: number;
                    [name: string]: unknown;
                };
                content: {
                    "application/problem+json": components["schemas"]["Problem"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    listSessions: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Active sessions with redacted source information */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Session"][];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    revokeSession: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                sessionId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Session revoked or already absent */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            default: components["responses"]["Problem"];
        };
    };
    listAccounts: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Safety-filtered management accounts */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Account"][];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    createAccount: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AccountCreate"];
            };
        };
        responses: {
            /** @description Account created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Account"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    deleteAccount: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                accountId: components["parameters"]["AccountId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Account and its sessions deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    updateAccount: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                accountId: components["parameters"]["AccountId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AccountPatch"];
            };
        };
        responses: {
            /** @description Account updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Account"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    getHealth: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Process health (not authorization readiness) */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Health"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    streamEvents: {
        parameters: {
            query?: never;
            header?: {
                "Last-Event-ID"?: components["parameters"]["LastEventId"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Server-sent events. Event types include status, operation, alert, policy and gap. */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "text/event-stream": string;
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getServerStatus: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Current server status snapshot */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ServerStatus"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getFeatureFlags: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Configuration flags intersected with platform capabilities */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["FeatureFlags"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getSettings: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Live settings plus any startup-only configuration waiting for restart */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ServerSettings"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    updateSettings: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["ServerSettings"];
            };
        };
        responses: {
            /** @description Configuration persisted and runtime-safe fields applied */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Operation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getTriggerWorkspace: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Complete trigger workspace */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerWorkspace"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    createTrigger: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerInput"];
            };
        };
        responses: {
            /** @description Trigger created and trigger index refreshed */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerMutationResult"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getTriggerCatalog: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Trigger authoring catalog */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerCatalog"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    validateTriggerProgram: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerScriptValidationRequest"] | components["schemas"]["TriggerVisualValidationRequest"] | components["schemas"]["TriggerProgramV2"];
            };
        };
        responses: {
            /** @description Compiled event-condition-action program */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerValidation"] | components["schemas"]["TriggerProgramV2Validation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    simulateTrigger: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerSimulationRequest"];
            };
        };
        responses: {
            /** @description Deterministic trace and planned side effects */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerSimulationResponse"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getTriggerVariableValues: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                triggerId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Live variable values */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerVariableValues"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getTriggerState: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                triggerId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Durable variable state */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerDurableState"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    patchTriggerState: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                triggerId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerStatePatch"];
            };
        };
        responses: {
            /** @description Updated state row */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerDurableStateValue"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    listTriggerExecutions: {
        parameters: {
            query?: {
                limit?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Execution summaries */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: components["schemas"]["TriggerExecution"][];
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getTriggerExecution: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                executionId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Execution detail */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerExecution"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    listTriggerEventCaptures: {
        parameters: {
            query?: {
                limit?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Capture sessions and sample counts */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: components["schemas"]["TriggerEventCapture"][];
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    startTriggerEventCapture: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    eventTypes: string[];
                    /** @default 300 */
                    durationSeconds?: number;
                    /** @default 100 */
                    maximumSamples?: number;
                };
            };
        };
        responses: {
            /** @description Capture session started */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerEventCapture"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    listTriggerEventSamples: {
        parameters: {
            query?: {
                limit?: number;
            };
            header?: never;
            path: {
                captureId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Captured samples */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: components["schemas"]["TriggerEventSample"][];
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    simulateTriggerEventSample: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                sampleId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerSimulationRequest"];
            };
        };
        responses: {
            /** @description Deterministic simulation plus the source sample */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerSimulationResponse"] & {
                        sample: components["schemas"]["TriggerEventSample"];
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    listTriggerLibraries: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Installed versions; exactly one version per namespace may be active */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: components["schemas"]["TriggerLibraryInstallation"][];
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    validateTriggerLibrary: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerLibraryPackage"];
            };
        };
        responses: {
            /** @description Dependency and package validation result */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        [key: string]: unknown;
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    importTriggerLibrary: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerLibraryPackage"];
            };
        };
        responses: {
            /** @description Installed active library version */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerLibraryInstallation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    upgradeTriggerLibrary: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerLibraryPackage"];
            };
        };
        responses: {
            /** @description Upgraded active library version */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerLibraryInstallation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    rollbackTriggerLibrary: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                namespace: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    version: string;
                };
            };
        };
        responses: {
            /** @description Reactivated version */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerLibraryInstallation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    exportTriggerLibrary: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                namespace: string;
                version: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Declarative package without executable bytecode */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerLibraryPackage"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    updateTrigger: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                triggerId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerInput"] & Record<string, never>;
            };
        };
        responses: {
            /** @description Trigger updated and trigger index refreshed */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerMutationResult"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    deleteTrigger: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                triggerId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    expectedRevision: number;
                };
            };
        };
        responses: {
            /** @description Trigger deleted */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DeletionResult"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    createTriggerGroup: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerGroupInput"];
            };
        };
        responses: {
            /** @description Trigger group created */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerWorkspace"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    updateTriggerGroup: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                groupId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TriggerGroupInput"] & Record<string, never>;
            };
        };
        responses: {
            /** @description Trigger group updated */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TriggerWorkspace"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    deleteTriggerGroup: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                groupId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    expectedRevision: number;
                };
            };
        };
        responses: {
            /** @description Trigger group deleted with all contained triggers */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DeletionResult"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    listMenus: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Menu workspace */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["MenuWorkspace"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    createMenu: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["MenuInput"];
            };
        };
        responses: {
            /** @description Menu saved and immediately available to triggers */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["MenuSaveResult"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getMenuCatalog: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Menu editor catalog */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["MenuCatalog"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    searchMenuImages: {
        parameters: {
            query?: {
                query?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Bounded image search result */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: components["schemas"]["MenuImage"][];
                        query: string;
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getMenuImagePreview: {
        parameters: {
            query: {
                reference: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Bounded PNG/JPEG preview represented as a data URL */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        reference: string;
                        /** @enum {string} */
                        mimeType: "image/png" | "image/jpeg";
                        dataUrl: string;
                    };
                };
            };
            404: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    updateMenu: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                menuId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["MenuInput"] & {
                    expectedRevision: number;
                };
            };
        };
        responses: {
            /** @description Menu updated */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["MenuSaveResult"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    deleteMenu: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                menuId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    expectedRevision: number;
                };
            };
        };
        responses: {
            /** @description Menu deleted */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    uploadMenuImage: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    name: string;
                    /** @description Base64 PNG/JPEG data URL; decoded content is limited to 256 KiB. */
                    dataUrl: string;
                };
            };
        };
        responses: {
            /** @description Image stored */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["MenuImage"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    deleteMenuImage: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                assetId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Image deleted */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    getMenuImageContent: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                assetId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Image data */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** Format: uuid */
                        id: string;
                        /** @enum {string} */
                        mimeType: "image/png" | "image/jpeg";
                        dataUrl: string;
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getEconomyWorkspace: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Currencies and aggregate metrics */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["EconomyWorkspace"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    listCurrencies: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Currency definitions, primary first */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Currency"][];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    createCurrency: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CurrencyInput"];
            };
        };
        responses: {
            /** @description Currency created and immediately available to accounts and triggers */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    updateCurrency: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                currencyId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CurrencyInput"] & {
                    expectedRevision: number;
                };
            };
        };
        responses: {
            /** @description Currency updated */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    deleteCurrency: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                currencyId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    expectedRevision: number;
                    reason: string;
                };
            };
        };
        responses: {
            /** @description Unused currency deleted */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    listEconomyAccounts: {
        parameters: {
            query?: {
                query?: string;
                limit?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Economy accounts and all currency balances */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: components["schemas"]["EconomyAccount"][];
                        nextCursor?: string;
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    listEconomyTransactions: {
        parameters: {
            query?: {
                query?: string;
                player?: string;
                currency?: string;
                kind?: "initial" | "deposit" | "withdraw" | "set" | "transfer";
                before?: string;
                limit?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Ledger entries ordered newest first */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        items: components["schemas"]["EconomyTransaction"][];
                        nextCursor?: string;
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    adjustEconomyBalance: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** Format: uuid */
                    playerId: string;
                    playerName: string;
                    /** @description Currency UUID or code. */
                    currency: string;
                    /** @enum {string} */
                    operation: "deposit" | "withdraw" | "set";
                    amount: components["schemas"]["EconomyAmount"];
                    reason: string;
                    expectedRevision?: number;
                };
            };
        };
        responses: {
            /** @description Balance changed atomically and ledger entry committed */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["EconomyChange"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    transferEconomyBalance: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** Format: uuid */
                    sourcePlayerId: string;
                    sourcePlayerName: string;
                    /** Format: uuid */
                    targetPlayerId: string;
                    targetPlayerName: string;
                    /** @description Currency UUID or code. */
                    currency: string;
                    amount: components["schemas"]["EconomyAmount"];
                    reason: string;
                    expectedSourceRevision?: number;
                };
            };
        };
        responses: {
            /** @description Both balances and one ledger entry committed in one transaction */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["EconomyChange"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    getMetrics: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Token-protected OpenMetrics exposition */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/openmetrics-text": string;
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    listPlayers: {
        parameters: {
            query?: {
                /** @description Opaque cursor from the previous page; clients must not parse it. */
                cursor?: components["parameters"]["Cursor"];
                limit?: components["parameters"]["Limit"];
                online?: boolean;
                /** @description Case-insensitive player name or UUID search text. */
                query?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Player page */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PlayerPage"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getPlayer: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                playerId: components["parameters"]["PlayerId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Player details */
            200: {
                headers: {
                    /** @description Player snapshot revision */
                    ETag?: string;
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PlayerDetail"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    executePlayerAction: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                playerId: components["parameters"]["PlayerId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["PlayerActionRequest"];
            };
        };
        responses: {
            /** @description Returns PREVIEW_REQUIRED with a frozen target/token, or an accepted/completed operation */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Operation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getPlayerInventory: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                playerId: components["parameters"]["PlayerId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Online player inventory and ender chest revisions */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["InventorySnapshot"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    updatePlayerInventory: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                playerId: components["parameters"]["PlayerId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["InventoryPatch"];
            };
        };
        responses: {
            /** @description Audited compare-and-swap result and slot diff */
            202: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["InventoryUpdateResult"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    getPlayerEnderChest: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                playerId: components["parameters"]["PlayerId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Ender-chest slots and compare-and-swap revision */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["InventorySnapshot"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    updatePlayerEnderChest: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                playerId: components["parameters"]["PlayerId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["InventoryPatch"];
            };
        };
        responses: {
            /** @description Audited compare-and-swap result and slot diff */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["InventoryUpdateResult"];
                };
            };
            409: components["responses"]["Problem"];
            default: components["responses"]["Problem"];
        };
    };
    listPolicies: {
        parameters: {
            query?: {
                /** @description Opaque cursor from the previous page; clients must not parse it. */
                cursor?: components["parameters"]["Cursor"];
                limit?: components["parameters"]["Limit"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Immutable policy versions */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PolicyPage"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    createPolicyDraft: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["PolicyDraft"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    getPolicyVersion: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                versionId: components["parameters"]["VersionId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Policy version with validation and diff */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PolicyVersion"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    discardPolicyDraft: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                versionId: components["parameters"]["VersionId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["PolicyMutationRequest"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    validatePolicy: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                versionId: components["parameters"]["VersionId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Validation result; this does not publish the policy */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PolicyValidation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    diffPolicy: {
        parameters: {
            query?: {
                from?: number;
            };
            header?: never;
            path: {
                versionId: components["parameters"]["VersionId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Rule-level immutable version diff */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        [key: string]: unknown;
                    };
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    simulatePolicy: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["PolicySimulationRequest"];
            };
        };
        responses: {
            /** @description Explained active-policy decision without executing the command */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PolicyDecision"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    publishPolicy: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                versionId: components["parameters"]["VersionId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["PolicyPublishRequest"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    rollbackPolicy: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                versionId: components["parameters"]["VersionId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["PolicyMutationRequest"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    listAuditEvents: {
        parameters: {
            query?: {
                /** @description Opaque cursor from the previous page; clients must not parse it. */
                cursor?: components["parameters"]["Cursor"];
                limit?: components["parameters"]["Limit"];
                actor?: string;
                action?: string;
                /**
                 * @deprecated
                 * @description Compatibility alias for the action filter.
                 */
                query?: string;
                target?: string;
                requestId?: string;
                from?: string;
                to?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Redacted audit page */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AuditPage"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    submitOperation: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["OperationRequest"];
            };
        };
        responses: {
            /** @description Preview requirement, running job, or completed operation */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Operation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    getOperation: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                operationId: components["parameters"]["OperationId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Operation state and result summary */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Operation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    cancelOperation: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                operationId: components["parameters"]["OperationId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Operation tracking or pending preview cancelled */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Operation"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    executeConsoleCommand: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    command: string;
                    reason: string;
                };
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    listModerationCases: {
        parameters: {
            query?: {
                /** @description Opaque cursor from the previous page; clients must not parse it. */
                cursor?: components["parameters"]["Cursor"];
                limit?: components["parameters"]["Limit"];
                playerId?: string;
                active?: boolean;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Moderation case page */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ModerationCasePage"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    createModerationCase: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateModerationCase"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    revokeModerationAction: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                caseId: components["parameters"]["CaseId"];
                actionId: components["parameters"]["ActionId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["Reason"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    getMaintenance: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Maintenance mode and upcoming plans */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["MaintenanceState"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    setMaintenance: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["MaintenanceRequest"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    createMaintenanceSchedule: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["ScheduledAction"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    announceMaintenanceMessage: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    message: string;
                    reason: string;
                };
            };
        };
        responses: {
            /** @description Announcement broadcast */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            default: components["responses"]["Problem"];
        };
    };
    listClaims: {
        parameters: {
            query?: {
                /** @description Opaque cursor from the previous page; clients must not parse it. */
                cursor?: components["parameters"]["Cursor"];
                limit?: components["parameters"]["Limit"];
                dimension?: string;
                ownerId?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Claim page */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ClaimPage"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    createClaim: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateClaim"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    deleteClaim: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                claimId: components["parameters"]["ClaimId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** Format: int64 */
                    revision: number;
                    reason: string;
                };
            };
        };
        responses: {
            /** @description Deleted claim snapshot */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            default: components["responses"]["Problem"];
        };
    };
    updateClaim: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                claimId: components["parameters"]["ClaimId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/merge-patch+json": components["schemas"]["ClaimPatch"];
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    beginClaimTransfer: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                claimId: components["parameters"]["ClaimId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** Format: uuid */
                    actorId: string;
                    /** Format: uuid */
                    newOwnerId: string;
                    /** @default 10m */
                    validity?: string;
                    reason: string;
                };
            };
        };
        responses: {
            /** @description Short-lived single-use transfer ticket */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            default: components["responses"]["Problem"];
        };
    };
    confirmClaimTransfer: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                transferToken: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** Format: uuid */
                    acceptingPlayerId: string;
                    reason: string;
                };
            };
        };
        responses: {
            /** @description Updated claim with its new owner */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            default: components["responses"]["Problem"];
        };
    };
    lookupWorldChanges: {
        parameters: {
            query?: {
                /** @description Opaque cursor from the previous page; clients must not parse it. */
                cursor?: components["parameters"]["Cursor"];
                limit?: components["parameters"]["Limit"];
                actorId?: string;
                dimension?: string;
                x?: number;
                y?: number;
                z?: number;
                radius?: number;
                claimId?: string;
                action?: string;
                resourceId?: string;
                from?: string;
                to?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description World event page; gaps are returned explicitly */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WorldChangePage"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    previewRollback: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RollbackSelection"];
            };
        };
        responses: {
            /** @description Dry-run fixed to a watermark; does not modify the world */
            200: {
                headers: {
                    "X-Request-ID": components["headers"]["RequestId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["RollbackPreview"];
                };
            };
            default: components["responses"]["Problem"];
        };
    };
    executeRollback: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** Format: uuid */
                    previewId: string;
                    confirmationToken: string;
                    reason: string;
                    /** @default false */
                    forceConflicts?: boolean;
                    /** @default false */
                    loadChunks?: boolean;
                };
            };
        };
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    pauseRollback: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                operationId: components["parameters"]["OperationId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    resumeRollback: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                operationId: components["parameters"]["OperationId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            202: components["responses"]["AcceptedOperation"];
            default: components["responses"]["Problem"];
        };
    };
    cancelRollback: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                operationId: components["parameters"]["OperationId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Cancelled rollback checkpoint */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            default: components["responses"]["Problem"];
        };
    };
    previewRedoRollback: {
        parameters: {
            query?: never;
            header: {
                /** @description Session-bound double-submit token required for same-origin mutations. */
                "X-CSRF-Token": components["parameters"]["CsrfToken"];
                /** @description Unique key for this logical mutation; reuse it when retrying an uncertain response. */
                "Idempotency-Key": components["parameters"]["IdempotencyKey"];
            };
            path: {
                operationId: components["parameters"]["OperationId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Fixed-watermark redo preview */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            default: components["responses"]["Problem"];
        };
    };
}