@takaro/apiclient 0.0.0-dev.5018a18 → 0.0.0-dev.5055b67

package/dist/generated-management/api.js

@@ -183,6 +183,8 @@ export const EventCreateDTOEventNameEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
     PlayerConnected: 'player-connected',
     PlayerDisconnected: 'player-disconnected',
     ChatMessage: 'chat-message',
@@ -236,12 +238,39 @@ export const EventOutputDTOEventNameEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
     PlayerConnected: 'player-connected',
     PlayerDisconnected: 'player-disconnected',
     ChatMessage: 'chat-message',
     PlayerDeath: 'player-death',
     EntityKilled: 'entity-killed',
 };
+export const FixtureHistoryConflictDTOKindEnum = {
+    TakaroPlayer: 'takaro-player',
+    TakaroPog: 'takaro-pog',
+};
+export const FixtureHistoryDeleteInputDTOStoreEnum = {
+    Analytics: 'analytics',
+    Postgres: 'postgres',
+};
+export const FixtureHistoryEventDTOEventNameEnum = {
+    PlayerConnected: 'player-connected',
+    PlayerDisconnected: 'player-disconnected',
+    PlayerSyncSnapshot: 'player-sync-snapshot',
+    ChatMessage: 'chat-message',
+    CurrencyAdded: 'currency-added',
+    CurrencyDeducted: 'currency-deducted',
+    ShopOrderCreated: 'shop-order-created',
+    ShopOrderStatusChanged: 'shop-order-status-changed',
+};
+export const FixtureHistoryListingConflictDTOKindEnum = {
+    TakaroListing: 'takaro-listing',
+};
+export const FixtureHistoryOrderDTOStatusEnum = {
+    Completed: 'COMPLETED',
+    Canceled: 'CANCELED',
+};
 export const GameServerCreateDTOTypeEnum = {
     Sevendaystodie: 'SEVENDAYSTODIE',
     Rust: 'RUST',
@@ -266,6 +295,24 @@ export const GameServerUpdateDTOTypeEnum = {
     Generic: 'GENERIC',
     Mock: 'MOCK',
 };
+export const GetJobInputDTOTypeEnum = {
+    CsmmImport: 'csmmImport',
+    SeedModules: 'seedModules',
+    CleanEvents: 'cleanEvents',
+    CleanExpiringVariables: 'cleanExpiringVariables',
+    EnsureCronjobsScheduled: 'ensureCronjobsScheduled',
+    DeleteGameServers: 'deleteGameServers',
+    SyncItems: 'syncItems',
+    SyncEntities: 'syncEntities',
+    SyncBans: 'syncBans',
+    SyncMapImages: 'syncMapImages',
+    SyncMapUploads: 'syncMapUploads',
+    SyncSteam: 'syncSteam',
+    SyncDiscordRoles: 'syncDiscordRoles',
+    EmitRateLimitSummary: 'emitRateLimitSummary',
+    CleanRevokedApiKeys: 'cleanRevokedApiKeys',
+    CleanExecutionClaims: 'cleanExecutionClaims',
+};
 export const HookCreateDTOEventTypeEnum = {
     Log: 'log',
     PlayerConnected: 'player-connected',
@@ -320,6 +367,8 @@ export const HookCreateDTOEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const HookOutputDTOEventTypeEnum = {
     Log: 'log',
@@ -375,6 +424,8 @@ export const HookOutputDTOEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const HookTriggerDTOEventTypeEnum = {
     Log: 'log',
@@ -430,6 +481,8 @@ export const HookTriggerDTOEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const HookUpdateDTOEventTypeEnum = {
     Log: 'log',
@@ -485,6 +538,8 @@ export const HookUpdateDTOEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const IEntityDTOTypeEnum = {
     Hostile: 'hostile',
@@ -545,6 +600,8 @@ export const IHookEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const ITakaroQuerySortDirectionEnum = {
     Asc: 'asc',
@@ -592,6 +649,33 @@ export const ManagementDomainOutputDTOCustomDomainStateEnum = {
     Verified: 'VERIFIED',
     Failed: 'FAILED',
 };
+export const MapHorizontalAxisDTOFieldEnum = {
+    X: 'x',
+    Y: 'y',
+    Z: 'z',
+};
+export const MapHorizontalAxisDTODirectionEnum = {
+    Right: 'right',
+    Left: 'left',
+};
+export const MapPyramidDTOOriginEnum = {
+    Game: 'game',
+    Upload: 'upload',
+};
+export const MapSourceDTOTypeEnum = {
+    None: 'none',
+    Tiled: 'tiled',
+    Image: 'image',
+};
+export const MapVerticalAxisDTOFieldEnum = {
+    X: 'x',
+    Y: 'y',
+    Z: 'z',
+};
+export const MapVerticalAxisDTODirectionEnum = {
+    Up: 'up',
+    Down: 'down',
+};
 export const OrderStatusCountDTOStatusEnum = {
     Completed: 'COMPLETED',
     Paid: 'PAID',
@@ -674,6 +758,7 @@ export const SettingsOutputDTOKeyEnum = {
     DiscordRoleSyncPreferDiscord: 'discordRoleSyncPreferDiscord',
     UnknownCommandFeedbackEnabled: 'unknownCommandFeedbackEnabled',
     UnknownCommandFeedbackMessage: 'unknownCommandFeedbackMessage',
+    TakaroAiEnabled: 'takaroAiEnabled',
 };
 export const SettingsOutputDTOTypeEnum = {
     Override: 'override',
@@ -751,11 +836,24 @@ export const ShopListingUpdateDTORequiredVariableOperatorEnum = {
     Gt: 'gt',
     Lt: 'lt',
 };
+export const ShopOrderDeliveryItemDTOResultEnum = {
+    Delivered: 'DELIVERED',
+    Failed: 'FAILED',
+    Unknown: 'UNKNOWN',
+};
 export const ShopOrderOutputDTOStatusEnum = {
     Completed: 'COMPLETED',
     Paid: 'PAID',
     Canceled: 'CANCELED',
 };
+export const ShopOrderOutputDTODeliveryStatusEnum = {
+    NotApplicable: 'NOT_APPLICABLE',
+    NotAttempted: 'NOT_ATTEMPTED',
+    InProgress: 'IN_PROGRESS',
+    Delivered: 'DELIVERED',
+    Failed: 'FAILED',
+    Unknown: 'UNKNOWN',
+};
 export const ShopOrderUpdateDTOStatusEnum = {
     Completed: 'COMPLETED',
     Paid: 'PAID',
@@ -771,6 +869,49 @@ export const StorefrontDomainOutputDTOCustomDomainStateEnum = {
     Verified: 'VERIFIED',
     Failed: 'FAILED',
 };
+export const TakaroAiDomainOutputDTOOverrideStateEnum = {
+    None: 'none',
+    Active: 'active',
+    Expired: 'expired',
+};
+export const TakaroAiDomainOutputDTOStatusEnum = {
+    Available: 'available',
+    Grace: 'grace',
+    DailyLimitReached: 'dailyLimitReached',
+    LimitReached: 'limitReached',
+    Disabled: 'disabled',
+    NoAllowance: 'noAllowance',
+    NeedsGameServer: 'needsGameServer',
+};
+export const TakaroAiStaffChangeOutputDTOSubjectEnum = {
+    GlobalMultiplier: 'globalMultiplier',
+    DomainOverride: 'domainOverride',
+    MigrationCap: 'migrationCap',
+};
+export const TakaroAiStaffChangeOutputDTOActorKindEnum = {
+    StaffSession: 'staffSession',
+    AdminSecret: 'adminSecret',
+};
+export const TakaroAiUsageOutputDTOStatusEnum = {
+    Available: 'available',
+    Grace: 'grace',
+    DailyLimitReached: 'dailyLimitReached',
+    LimitReached: 'limitReached',
+    Disabled: 'disabled',
+    NoAllowance: 'noAllowance',
+    NeedsGameServer: 'needsGameServer',
+};
+export const TakaroEventDomainCreatedOriginEnum = {
+    Distributor: 'distributor',
+    Staff: 'staff',
+    Subscription: 'subscription',
+    AdminSecret: 'admin_secret',
+};
+export const TakaroEventItemsGivenLineResultEnum = {
+    Delivered: 'DELIVERED',
+    Failed: 'FAILED',
+    Unknown: 'UNKNOWN',
+};
 export const TakaroEventPlayerInventoryChangedChangeTypeEnum = {
     Added: 'added',
     Removed: 'removed',
@@ -781,6 +922,150 @@ export const TakaroEventRateLimitedScopeEnum = {
     Domain: 'domain',
     Global: 'global',
 };
+export const ThreadApprovalDecisionInputDTOOutcomeEnum = {
+    Approved: 'approved',
+    Denied: 'denied',
+};
+export const ThreadContextInputDTOTypeEnum = {
+    Player: 'player',
+    GameServer: 'gameServer',
+    Module: 'module',
+    ModuleVersion: 'moduleVersion',
+    Event: 'event',
+    CsmmImport: 'csmmImport',
+};
+export const ThreadCreateInputDTOOriginSurfaceEnum = {
+    CommandPalette: 'commandPalette',
+    PlayerSummary: 'playerSummary',
+    Modules: 'modules',
+    GameServerModules: 'gameServerModules',
+    GameServerOverview: 'gameServerOverview',
+    GameServerConsole: 'gameServerConsole',
+    DashboardBriefing: 'dashboardBriefing',
+    EventsFilter: 'eventsFilter',
+    RoleBuilder: 'roleBuilder',
+    ModuleConfig: 'moduleConfig',
+    GameServerShop: 'gameServerShop',
+    ModuleOverview: 'moduleOverview',
+    ModuleBuilder: 'moduleBuilder',
+    EventFailure: 'eventFailure',
+    CsmmMigration: 'csmmMigration',
+};
+export const ThreadOutputDTOStatusEnum = {
+    Idle: 'idle',
+    Working: 'working',
+    Stopping: 'stopping',
+    Failed: 'failed',
+    AwaitingApproval: 'awaitingApproval',
+    AwaitingReply: 'awaitingReply',
+};
+export const ThreadOutputDTOOriginSurfaceEnum = {
+    CommandPalette: 'commandPalette',
+    PlayerSummary: 'playerSummary',
+    Modules: 'modules',
+    GameServerModules: 'gameServerModules',
+    GameServerOverview: 'gameServerOverview',
+    GameServerConsole: 'gameServerConsole',
+    DashboardBriefing: 'dashboardBriefing',
+    EventsFilter: 'eventsFilter',
+    RoleBuilder: 'roleBuilder',
+    ModuleConfig: 'moduleConfig',
+    GameServerShop: 'gameServerShop',
+    ModuleOverview: 'moduleOverview',
+    ModuleBuilder: 'moduleBuilder',
+    EventFailure: 'eventFailure',
+    CsmmMigration: 'csmmMigration',
+};
+export const ThreadSearchInputAllowedFiltersStatusEnum = {
+    Idle: 'idle',
+    Working: 'working',
+    Stopping: 'stopping',
+    Failed: 'failed',
+    AwaitingApproval: 'awaitingApproval',
+    AwaitingReply: 'awaitingReply',
+};
+export const ThreadSearchInputAllowedFiltersOriginSurfaceEnum = {
+    CommandPalette: 'commandPalette',
+    PlayerSummary: 'playerSummary',
+    Modules: 'modules',
+    GameServerModules: 'gameServerModules',
+    GameServerOverview: 'gameServerOverview',
+    GameServerConsole: 'gameServerConsole',
+    DashboardBriefing: 'dashboardBriefing',
+    EventsFilter: 'eventsFilter',
+    RoleBuilder: 'roleBuilder',
+    ModuleConfig: 'moduleConfig',
+    GameServerShop: 'gameServerShop',
+    ModuleOverview: 'moduleOverview',
+    ModuleBuilder: 'moduleBuilder',
+    EventFailure: 'eventFailure',
+    CsmmMigration: 'csmmMigration',
+};
+export const ThreadSearchInputDTOSortDirectionEnum = {
+    Asc: 'asc',
+    Desc: 'desc',
+};
+export const ThreadStepApprovalDTOOutcomeEnum = {
+    Approved: 'approved',
+    Denied: 'denied',
+    AutoAllowed: 'autoAllowed',
+    Cancelled: 'cancelled',
+};
+export const ThreadStepOutputDTOKindEnum = {
+    UserMessage: 'userMessage',
+    ModelMessage: 'modelMessage',
+    ToolCall: 'toolCall',
+    ToolResult: 'toolResult',
+    ApprovalRequest: 'approvalRequest',
+    ApprovalOutcome: 'approvalOutcome',
+};
+export const ThreadStepReferenceDTOTypeEnum = {
+    Player: 'player',
+    GameServer: 'gameServer',
+    Module: 'module',
+    ModuleVersion: 'moduleVersion',
+    Event: 'event',
+    CsmmImport: 'csmmImport',
+};
+export const ThreadWithStepsOutputDTOStatusEnum = {
+    Idle: 'idle',
+    Working: 'working',
+    Stopping: 'stopping',
+    Failed: 'failed',
+    AwaitingApproval: 'awaitingApproval',
+    AwaitingReply: 'awaitingReply',
+};
+export const ThreadWithStepsOutputDTOOriginSurfaceEnum = {
+    CommandPalette: 'commandPalette',
+    PlayerSummary: 'playerSummary',
+    Modules: 'modules',
+    GameServerModules: 'gameServerModules',
+    GameServerOverview: 'gameServerOverview',
+    GameServerConsole: 'gameServerConsole',
+    DashboardBriefing: 'dashboardBriefing',
+    EventsFilter: 'eventsFilter',
+    RoleBuilder: 'roleBuilder',
+    ModuleConfig: 'moduleConfig',
+    GameServerShop: 'gameServerShop',
+    ModuleOverview: 'moduleOverview',
+    ModuleBuilder: 'moduleBuilder',
+    EventFailure: 'eventFailure',
+    CsmmMigration: 'csmmMigration',
+};
+export const TriggerJobInputDTOTypeEnum = {
+    SeedModules: 'seedModules',
+    CleanEvents: 'cleanEvents',
+    CleanExpiringVariables: 'cleanExpiringVariables',
+    EnsureCronjobsScheduled: 'ensureCronjobsScheduled',
+    DeleteGameServers: 'deleteGameServers',
+    SyncItems: 'syncItems',
+    SyncEntities: 'syncEntities',
+    SyncBans: 'syncBans',
+    SyncMapImages: 'syncMapImages',
+    SyncMapUploads: 'syncMapUploads',
+    SyncSteam: 'syncSteam',
+    SyncDiscordRoles: 'syncDiscordRoles',
+};
 export const UserSearchInputDTOExtendEnum = {
     Roles: 'roles',
 };
@@ -3148,69 +3433,88 @@ export class DomainApi extends BaseAPI {
     }
 }
 /**
- * MetaApi - axios parameter creator
+ * FixtureHistoryApi - axios parameter creator
  * @export
  */
-export const MetaApiAxiosParamCreator = function (configuration) {
+export const FixtureHistoryApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * <br> OperationId: `MetaGetHealth`
-         * @summary Get health
+         * <br> OperationId: `FixtureHistoryControllerActivity`
+         * @summary Write owned, back-dated events and location samples into Postgres (idempotent)
+         * @param {string} domainId
+         * @param {FixtureHistoryActivityInputDTO} [fixtureHistoryActivityInputDTO] FixtureHistoryActivityInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetHealth: async (options = {}) => {
-            const localVarPath = `/healthz`;
+        fixtureHistoryControllerActivity: async (domainId, fixtureHistoryActivityInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerActivity', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/activity`.replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(fixtureHistoryActivityInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * <br> OperationId: `MetaGetLiveness`
-         * @summary Get liveness
+         * <br> OperationId: `FixtureHistoryControllerAnalytics`
+         * @summary Write owned, back-dated events into the analytics store (inserts only missing ids)
+         * @param {string} domainId
+         * @param {FixtureHistoryAnalyticsInputDTO} [fixtureHistoryAnalyticsInputDTO] FixtureHistoryAnalyticsInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetLiveness: async (options = {}) => {
-            const localVarPath = `/livez`;
+        fixtureHistoryControllerAnalytics: async (domainId, fixtureHistoryAnalyticsInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerAnalytics', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/analytics`.replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(fixtureHistoryAnalyticsInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * <br> OperationId: `MetaGetMetrics`
-         * @summary Get metrics
+         * <br> OperationId: `FixtureHistoryControllerCapabilities`
+         * @summary What the writer can do for this domain, and the domain\'s event retention
+         * @param {string} domainId
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetMetrics: async (options = {}) => {
-            const localVarPath = `/metrics`;
+        fixtureHistoryControllerCapabilities: async (domainId, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerCapabilities', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/capabilities`.replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -3220,6 +3524,8 @@ export const MetaApiAxiosParamCreator = function (configuration) {
             const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -3229,173 +3535,1146 @@ export const MetaApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * <br> OperationId: `MetaGetOpenApi`
-         * @summary Get open api
+         * <br> OperationId: `FixtureHistoryControllerDelete`
+         * @summary Delete a bounded batch of this dataset\'s rows from one store; loop until remaining is 0
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {FixtureHistoryDeleteInputDTO} [fixtureHistoryDeleteInputDTO] FixtureHistoryDeleteInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetOpenApi: async (options = {}) => {
-            const localVarPath = `/openapi.json`;
+        fixtureHistoryControllerDelete: async (domainId, fixtureDatasetId, fixtureHistoryDeleteInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerDelete', 'domainId', domainId);
+            // verify required parameter 'fixtureDatasetId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerDelete', 'fixtureDatasetId', fixtureDatasetId);
+            const localVarPath = `/fixture-history/domains/{domainId}/datasets/{fixtureDatasetId}/delete`
+                .replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)))
+                .replace(`{${'fixtureDatasetId'}}`, encodeURIComponent(String(fixtureDatasetId)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(fixtureHistoryDeleteInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * <br> OperationId: `MetaGetOpenApiHtml`
-         * @summary Get open api html
+         * <br> OperationId: `FixtureHistoryControllerEconomyReadiness`
+         * @summary Per gameserver: whether economyEnabled is on (read-only; never written)
+         * @param {string} domainId
+         * @param {FixtureHistoryEconomyReadinessInputDTO} [fixtureHistoryEconomyReadinessInputDTO] FixtureHistoryEconomyReadinessInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetOpenApiHtml: async (options = {}) => {
-            const localVarPath = `/api.html`;
+        fixtureHistoryControllerEconomyReadiness: async (domainId, fixtureHistoryEconomyReadinessInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerEconomyReadiness', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/economy-readiness`.replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(fixtureHistoryEconomyReadinessInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * <br> OperationId: `MetaGetReadiness`
-         * @summary Get readiness
+         * One transaction. A planned row whose natural key is held by a row this dataset does not own is a conflict: nothing in the request is written and the conflicts are returned.<br> OperationId: `FixtureHistoryControllerIdentities`
+         * @summary Write owned, back-dated players and players-on-gameserver
+         * @param {string} domainId
+         * @param {FixtureHistoryIdentitiesInputDTO} [fixtureHistoryIdentitiesInputDTO] FixtureHistoryIdentitiesInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetReadiness: async (options = {}) => {
-            const localVarPath = `/readyz`;
+        fixtureHistoryControllerIdentities: async (domainId, fixtureHistoryIdentitiesInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerIdentities', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/identities`.replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(fixtureHistoryIdentitiesInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * <br> OperationId: `MetaGetRoot`
-         * @summary Get root
+         * <br> OperationId: `FixtureHistoryControllerInventory`
+         * @summary Write the terminal inventory baseline of owned players-on-gameserver (idempotent)
+         * @param {string} domainId
+         * @param {FixtureHistoryInventoryInputDTO} [fixtureHistoryInventoryInputDTO] FixtureHistoryInventoryInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetRoot: async (options = {}) => {
-            const localVarPath = `/`;
+        fixtureHistoryControllerInventory: async (domainId, fixtureHistoryInventoryInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerInventory', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/inventory`.replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(fixtureHistoryInventoryInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
-    };
-};
-/**
- * MetaApi - functional programming interface
- * @export
- */
-export const MetaApiFp = function (configuration) {
-    const localVarAxiosParamCreator = MetaApiAxiosParamCreator(configuration);
-    return {
         /**
-         * <br> OperationId: `MetaGetHealth`
-         * @summary Get health
+         * <br> OperationId: `FixtureHistoryControllerInventoryPage`
+         * @summary Page through the owned inventory baselines, by player-on-gameserver
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {string} [cursor]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async metaGetHealth(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetHealth(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetHealth']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        fixtureHistoryControllerInventoryPage: async (domainId, fixtureDatasetId, cursor, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerInventoryPage', 'domainId', domainId);
+            // verify required parameter 'fixtureDatasetId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerInventoryPage', 'fixtureDatasetId', fixtureDatasetId);
+            const localVarPath = `/fixture-history/domains/{domainId}/datasets/{fixtureDatasetId}/inventory`
+                .replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)))
+                .replace(`{${'fixtureDatasetId'}}`, encodeURIComponent(String(fixtureDatasetId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            if (cursor !== undefined) {
+                localVarQueryParameter['cursor'] = cursor;
+            }
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
         /**
-         * <br> OperationId: `MetaGetLiveness`
-         * @summary Get liveness
+         * One transaction. A listing whose id, or whose name on its gameserver, is held by a listing this dataset does not own is a conflict: nothing is written and the conflicts are returned.<br> OperationId: `FixtureHistoryControllerListings`
+         * @summary Write owned, back-dated shop listings
+         * @param {string} domainId
+         * @param {FixtureHistoryListingsInputDTO} [fixtureHistoryListingsInputDTO] FixtureHistoryListingsInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async metaGetLiveness(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetLiveness(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetLiveness']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        fixtureHistoryControllerListings: async (domainId, fixtureHistoryListingsInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerListings', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/listings`.replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(fixtureHistoryListingsInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
         /**
-         * <br> OperationId: `MetaGetMetrics`
-         * @summary Get metrics
+         * Never charges, refunds, delivers or runs a shop action: an order is written as a settled row.<br> OperationId: `FixtureHistoryControllerOrders`
+         * @summary Write owned, settled (COMPLETED or CANCELED) historical orders (idempotent)
+         * @param {string} domainId
+         * @param {FixtureHistoryOrdersInputDTO} [fixtureHistoryOrdersInputDTO] FixtureHistoryOrdersInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async metaGetMetrics(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetMetrics(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetMetrics']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        fixtureHistoryControllerOrders: async (domainId, fixtureHistoryOrdersInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerOrders', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/orders`.replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(fixtureHistoryOrdersInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
         /**
-         * <br> OperationId: `MetaGetOpenApi`
-         * @summary Get open api
+         * <br> OperationId: `FixtureHistoryControllerSummary`
+         * @summary Owned row counts per store, and unowned events naming owned players
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {FixtureHistoryControllerSummarySinceParameter} [since]
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async metaGetOpenApi(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetOpenApi(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetOpenApi']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        fixtureHistoryControllerSummary: async (domainId, fixtureDatasetId, since, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerSummary', 'domainId', domainId);
+            // verify required parameter 'fixtureDatasetId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerSummary', 'fixtureDatasetId', fixtureDatasetId);
+            const localVarPath = `/fixture-history/domains/{domainId}/datasets/{fixtureDatasetId}/summary`
+                .replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)))
+                .replace(`{${'fixtureDatasetId'}}`, encodeURIComponent(String(fixtureDatasetId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            if (since !== undefined) {
+                for (const [key, value] of Object.entries(since)) {
+                    localVarQueryParameter[key] = value;
+                }
+            }
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
         /**
-         * <br> OperationId: `MetaGetOpenApiHtml`
-         * @summary Get open api html
+         * <br> OperationId: `FixtureHistoryControllerTerminal`
+         * @summary Set the offline terminal state of owned players-on-gameserver
+         * @param {string} domainId
+         * @param {FixtureHistoryTerminalInputDTO} [fixtureHistoryTerminalInputDTO] FixtureHistoryTerminalInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async metaGetOpenApiHtml(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetOpenApiHtml(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetOpenApiHtml']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        fixtureHistoryControllerTerminal: async (domainId, fixtureHistoryTerminalInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerTerminal', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/terminal-state`.replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(fixtureHistoryTerminalInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerTerminalState`
+         * @summary Page through the terminal state of owned players-on-gameserver
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {string} [cursor]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerTerminalState: async (domainId, fixtureDatasetId, cursor, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerTerminalState', 'domainId', domainId);
+            // verify required parameter 'fixtureDatasetId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerTerminalState', 'fixtureDatasetId', fixtureDatasetId);
+            const localVarPath = `/fixture-history/domains/{domainId}/datasets/{fixtureDatasetId}/terminal-state`
+                .replace(`{${'domainId'}}`, encodeURIComponent(String(domainId)))
+                .replace(`{${'fixtureDatasetId'}}`, encodeURIComponent(String(fixtureDatasetId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            if (cursor !== undefined) {
+                localVarQueryParameter['cursor'] = cursor;
+            }
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * FixtureHistoryApi - functional programming interface
+ * @export
+ */
+export const FixtureHistoryApiFp = function (configuration) {
+    const localVarAxiosParamCreator = FixtureHistoryApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * <br> OperationId: `FixtureHistoryControllerActivity`
+         * @summary Write owned, back-dated events and location samples into Postgres (idempotent)
+         * @param {string} domainId
+         * @param {FixtureHistoryActivityInputDTO} [fixtureHistoryActivityInputDTO] FixtureHistoryActivityInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerActivity(domainId, fixtureHistoryActivityInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerActivity(domainId, fixtureHistoryActivityInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerActivity']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerAnalytics`
+         * @summary Write owned, back-dated events into the analytics store (inserts only missing ids)
+         * @param {string} domainId
+         * @param {FixtureHistoryAnalyticsInputDTO} [fixtureHistoryAnalyticsInputDTO] FixtureHistoryAnalyticsInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerAnalytics(domainId, fixtureHistoryAnalyticsInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerAnalytics(domainId, fixtureHistoryAnalyticsInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerAnalytics']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerCapabilities`
+         * @summary What the writer can do for this domain, and the domain\'s event retention
+         * @param {string} domainId
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerCapabilities(domainId, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerCapabilities(domainId, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerCapabilities']?.[localVarOperationServerIndex]
+                ?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerDelete`
+         * @summary Delete a bounded batch of this dataset\'s rows from one store; loop until remaining is 0
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {FixtureHistoryDeleteInputDTO} [fixtureHistoryDeleteInputDTO] FixtureHistoryDeleteInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerDelete(domainId, fixtureDatasetId, fixtureHistoryDeleteInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerDelete(domainId, fixtureDatasetId, fixtureHistoryDeleteInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerDelete']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerEconomyReadiness`
+         * @summary Per gameserver: whether economyEnabled is on (read-only; never written)
+         * @param {string} domainId
+         * @param {FixtureHistoryEconomyReadinessInputDTO} [fixtureHistoryEconomyReadinessInputDTO] FixtureHistoryEconomyReadinessInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerEconomyReadiness(domainId, fixtureHistoryEconomyReadinessInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerEconomyReadiness(domainId, fixtureHistoryEconomyReadinessInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerEconomyReadiness']?.[localVarOperationServerIndex]
+                ?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * One transaction. A planned row whose natural key is held by a row this dataset does not own is a conflict: nothing in the request is written and the conflicts are returned.<br> OperationId: `FixtureHistoryControllerIdentities`
+         * @summary Write owned, back-dated players and players-on-gameserver
+         * @param {string} domainId
+         * @param {FixtureHistoryIdentitiesInputDTO} [fixtureHistoryIdentitiesInputDTO] FixtureHistoryIdentitiesInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerIdentities(domainId, fixtureHistoryIdentitiesInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerIdentities(domainId, fixtureHistoryIdentitiesInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerIdentities']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerInventory`
+         * @summary Write the terminal inventory baseline of owned players-on-gameserver (idempotent)
+         * @param {string} domainId
+         * @param {FixtureHistoryInventoryInputDTO} [fixtureHistoryInventoryInputDTO] FixtureHistoryInventoryInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerInventory(domainId, fixtureHistoryInventoryInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerInventory(domainId, fixtureHistoryInventoryInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerInventory']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerInventoryPage`
+         * @summary Page through the owned inventory baselines, by player-on-gameserver
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {string} [cursor]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerInventoryPage(domainId, fixtureDatasetId, cursor, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerInventoryPage(domainId, fixtureDatasetId, cursor, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerInventoryPage']?.[localVarOperationServerIndex]
+                ?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * One transaction. A listing whose id, or whose name on its gameserver, is held by a listing this dataset does not own is a conflict: nothing is written and the conflicts are returned.<br> OperationId: `FixtureHistoryControllerListings`
+         * @summary Write owned, back-dated shop listings
+         * @param {string} domainId
+         * @param {FixtureHistoryListingsInputDTO} [fixtureHistoryListingsInputDTO] FixtureHistoryListingsInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerListings(domainId, fixtureHistoryListingsInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerListings(domainId, fixtureHistoryListingsInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerListings']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Never charges, refunds, delivers or runs a shop action: an order is written as a settled row.<br> OperationId: `FixtureHistoryControllerOrders`
+         * @summary Write owned, settled (COMPLETED or CANCELED) historical orders (idempotent)
+         * @param {string} domainId
+         * @param {FixtureHistoryOrdersInputDTO} [fixtureHistoryOrdersInputDTO] FixtureHistoryOrdersInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerOrders(domainId, fixtureHistoryOrdersInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerOrders(domainId, fixtureHistoryOrdersInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerOrders']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerSummary`
+         * @summary Owned row counts per store, and unowned events naming owned players
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {FixtureHistoryControllerSummarySinceParameter} [since]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerSummary(domainId, fixtureDatasetId, since, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerSummary(domainId, fixtureDatasetId, since, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerSummary']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerTerminal`
+         * @summary Set the offline terminal state of owned players-on-gameserver
+         * @param {string} domainId
+         * @param {FixtureHistoryTerminalInputDTO} [fixtureHistoryTerminalInputDTO] FixtureHistoryTerminalInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerTerminal(domainId, fixtureHistoryTerminalInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerTerminal(domainId, fixtureHistoryTerminalInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerTerminal']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerTerminalState`
+         * @summary Page through the terminal state of owned players-on-gameserver
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {string} [cursor]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerTerminalState(domainId, fixtureDatasetId, cursor, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerTerminalState(domainId, fixtureDatasetId, cursor, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerTerminalState']?.[localVarOperationServerIndex]
+                ?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    };
+};
+/**
+ * FixtureHistoryApi - factory interface
+ * @export
+ */
+export const FixtureHistoryApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = FixtureHistoryApiFp(configuration);
+    return {
+        /**
+         * <br> OperationId: `FixtureHistoryControllerActivity`
+         * @summary Write owned, back-dated events and location samples into Postgres (idempotent)
+         * @param {string} domainId
+         * @param {FixtureHistoryActivityInputDTO} [fixtureHistoryActivityInputDTO] FixtureHistoryActivityInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerActivity(domainId, fixtureHistoryActivityInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerActivity(domainId, fixtureHistoryActivityInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerAnalytics`
+         * @summary Write owned, back-dated events into the analytics store (inserts only missing ids)
+         * @param {string} domainId
+         * @param {FixtureHistoryAnalyticsInputDTO} [fixtureHistoryAnalyticsInputDTO] FixtureHistoryAnalyticsInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerAnalytics(domainId, fixtureHistoryAnalyticsInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerAnalytics(domainId, fixtureHistoryAnalyticsInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerCapabilities`
+         * @summary What the writer can do for this domain, and the domain\'s event retention
+         * @param {string} domainId
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerCapabilities(domainId, options) {
+            return localVarFp
+                .fixtureHistoryControllerCapabilities(domainId, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerDelete`
+         * @summary Delete a bounded batch of this dataset\'s rows from one store; loop until remaining is 0
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {FixtureHistoryDeleteInputDTO} [fixtureHistoryDeleteInputDTO] FixtureHistoryDeleteInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerDelete(domainId, fixtureDatasetId, fixtureHistoryDeleteInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerDelete(domainId, fixtureDatasetId, fixtureHistoryDeleteInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerEconomyReadiness`
+         * @summary Per gameserver: whether economyEnabled is on (read-only; never written)
+         * @param {string} domainId
+         * @param {FixtureHistoryEconomyReadinessInputDTO} [fixtureHistoryEconomyReadinessInputDTO] FixtureHistoryEconomyReadinessInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerEconomyReadiness(domainId, fixtureHistoryEconomyReadinessInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerEconomyReadiness(domainId, fixtureHistoryEconomyReadinessInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * One transaction. A planned row whose natural key is held by a row this dataset does not own is a conflict: nothing in the request is written and the conflicts are returned.<br> OperationId: `FixtureHistoryControllerIdentities`
+         * @summary Write owned, back-dated players and players-on-gameserver
+         * @param {string} domainId
+         * @param {FixtureHistoryIdentitiesInputDTO} [fixtureHistoryIdentitiesInputDTO] FixtureHistoryIdentitiesInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerIdentities(domainId, fixtureHistoryIdentitiesInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerIdentities(domainId, fixtureHistoryIdentitiesInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerInventory`
+         * @summary Write the terminal inventory baseline of owned players-on-gameserver (idempotent)
+         * @param {string} domainId
+         * @param {FixtureHistoryInventoryInputDTO} [fixtureHistoryInventoryInputDTO] FixtureHistoryInventoryInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerInventory(domainId, fixtureHistoryInventoryInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerInventory(domainId, fixtureHistoryInventoryInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerInventoryPage`
+         * @summary Page through the owned inventory baselines, by player-on-gameserver
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {string} [cursor]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerInventoryPage(domainId, fixtureDatasetId, cursor, options) {
+            return localVarFp
+                .fixtureHistoryControllerInventoryPage(domainId, fixtureDatasetId, cursor, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * One transaction. A listing whose id, or whose name on its gameserver, is held by a listing this dataset does not own is a conflict: nothing is written and the conflicts are returned.<br> OperationId: `FixtureHistoryControllerListings`
+         * @summary Write owned, back-dated shop listings
+         * @param {string} domainId
+         * @param {FixtureHistoryListingsInputDTO} [fixtureHistoryListingsInputDTO] FixtureHistoryListingsInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerListings(domainId, fixtureHistoryListingsInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerListings(domainId, fixtureHistoryListingsInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * Never charges, refunds, delivers or runs a shop action: an order is written as a settled row.<br> OperationId: `FixtureHistoryControllerOrders`
+         * @summary Write owned, settled (COMPLETED or CANCELED) historical orders (idempotent)
+         * @param {string} domainId
+         * @param {FixtureHistoryOrdersInputDTO} [fixtureHistoryOrdersInputDTO] FixtureHistoryOrdersInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerOrders(domainId, fixtureHistoryOrdersInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerOrders(domainId, fixtureHistoryOrdersInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerSummary`
+         * @summary Owned row counts per store, and unowned events naming owned players
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {FixtureHistoryControllerSummarySinceParameter} [since]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerSummary(domainId, fixtureDatasetId, since, options) {
+            return localVarFp
+                .fixtureHistoryControllerSummary(domainId, fixtureDatasetId, since, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerTerminal`
+         * @summary Set the offline terminal state of owned players-on-gameserver
+         * @param {string} domainId
+         * @param {FixtureHistoryTerminalInputDTO} [fixtureHistoryTerminalInputDTO] FixtureHistoryTerminalInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerTerminal(domainId, fixtureHistoryTerminalInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerTerminal(domainId, fixtureHistoryTerminalInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerTerminalState`
+         * @summary Page through the terminal state of owned players-on-gameserver
+         * @param {string} domainId
+         * @param {string} fixtureDatasetId
+         * @param {string} [cursor]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerTerminalState(domainId, fixtureDatasetId, cursor, options) {
+            return localVarFp
+                .fixtureHistoryControllerTerminalState(domainId, fixtureDatasetId, cursor, options)
+                .then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * FixtureHistoryApi - object-oriented interface
+ * @export
+ * @class FixtureHistoryApi
+ * @extends {BaseAPI}
+ */
+export class FixtureHistoryApi extends BaseAPI {
+    /**
+     * <br> OperationId: `FixtureHistoryControllerActivity`
+     * @summary Write owned, back-dated events and location samples into Postgres (idempotent)
+     * @param {string} domainId
+     * @param {FixtureHistoryActivityInputDTO} [fixtureHistoryActivityInputDTO] FixtureHistoryActivityInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerActivity(domainId, fixtureHistoryActivityInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerActivity(domainId, fixtureHistoryActivityInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerAnalytics`
+     * @summary Write owned, back-dated events into the analytics store (inserts only missing ids)
+     * @param {string} domainId
+     * @param {FixtureHistoryAnalyticsInputDTO} [fixtureHistoryAnalyticsInputDTO] FixtureHistoryAnalyticsInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerAnalytics(domainId, fixtureHistoryAnalyticsInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerAnalytics(domainId, fixtureHistoryAnalyticsInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerCapabilities`
+     * @summary What the writer can do for this domain, and the domain\'s event retention
+     * @param {string} domainId
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerCapabilities(domainId, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerCapabilities(domainId, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerDelete`
+     * @summary Delete a bounded batch of this dataset\'s rows from one store; loop until remaining is 0
+     * @param {string} domainId
+     * @param {string} fixtureDatasetId
+     * @param {FixtureHistoryDeleteInputDTO} [fixtureHistoryDeleteInputDTO] FixtureHistoryDeleteInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerDelete(domainId, fixtureDatasetId, fixtureHistoryDeleteInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerDelete(domainId, fixtureDatasetId, fixtureHistoryDeleteInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerEconomyReadiness`
+     * @summary Per gameserver: whether economyEnabled is on (read-only; never written)
+     * @param {string} domainId
+     * @param {FixtureHistoryEconomyReadinessInputDTO} [fixtureHistoryEconomyReadinessInputDTO] FixtureHistoryEconomyReadinessInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerEconomyReadiness(domainId, fixtureHistoryEconomyReadinessInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerEconomyReadiness(domainId, fixtureHistoryEconomyReadinessInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * One transaction. A planned row whose natural key is held by a row this dataset does not own is a conflict: nothing in the request is written and the conflicts are returned.<br> OperationId: `FixtureHistoryControllerIdentities`
+     * @summary Write owned, back-dated players and players-on-gameserver
+     * @param {string} domainId
+     * @param {FixtureHistoryIdentitiesInputDTO} [fixtureHistoryIdentitiesInputDTO] FixtureHistoryIdentitiesInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerIdentities(domainId, fixtureHistoryIdentitiesInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerIdentities(domainId, fixtureHistoryIdentitiesInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerInventory`
+     * @summary Write the terminal inventory baseline of owned players-on-gameserver (idempotent)
+     * @param {string} domainId
+     * @param {FixtureHistoryInventoryInputDTO} [fixtureHistoryInventoryInputDTO] FixtureHistoryInventoryInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerInventory(domainId, fixtureHistoryInventoryInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerInventory(domainId, fixtureHistoryInventoryInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerInventoryPage`
+     * @summary Page through the owned inventory baselines, by player-on-gameserver
+     * @param {string} domainId
+     * @param {string} fixtureDatasetId
+     * @param {string} [cursor]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerInventoryPage(domainId, fixtureDatasetId, cursor, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerInventoryPage(domainId, fixtureDatasetId, cursor, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * One transaction. A listing whose id, or whose name on its gameserver, is held by a listing this dataset does not own is a conflict: nothing is written and the conflicts are returned.<br> OperationId: `FixtureHistoryControllerListings`
+     * @summary Write owned, back-dated shop listings
+     * @param {string} domainId
+     * @param {FixtureHistoryListingsInputDTO} [fixtureHistoryListingsInputDTO] FixtureHistoryListingsInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerListings(domainId, fixtureHistoryListingsInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerListings(domainId, fixtureHistoryListingsInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Never charges, refunds, delivers or runs a shop action: an order is written as a settled row.<br> OperationId: `FixtureHistoryControllerOrders`
+     * @summary Write owned, settled (COMPLETED or CANCELED) historical orders (idempotent)
+     * @param {string} domainId
+     * @param {FixtureHistoryOrdersInputDTO} [fixtureHistoryOrdersInputDTO] FixtureHistoryOrdersInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerOrders(domainId, fixtureHistoryOrdersInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerOrders(domainId, fixtureHistoryOrdersInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerSummary`
+     * @summary Owned row counts per store, and unowned events naming owned players
+     * @param {string} domainId
+     * @param {string} fixtureDatasetId
+     * @param {FixtureHistoryControllerSummarySinceParameter} [since]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerSummary(domainId, fixtureDatasetId, since, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerSummary(domainId, fixtureDatasetId, since, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerTerminal`
+     * @summary Set the offline terminal state of owned players-on-gameserver
+     * @param {string} domainId
+     * @param {FixtureHistoryTerminalInputDTO} [fixtureHistoryTerminalInputDTO] FixtureHistoryTerminalInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerTerminal(domainId, fixtureHistoryTerminalInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerTerminal(domainId, fixtureHistoryTerminalInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerTerminalState`
+     * @summary Page through the terminal state of owned players-on-gameserver
+     * @param {string} domainId
+     * @param {string} fixtureDatasetId
+     * @param {string} [cursor]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerTerminalState(domainId, fixtureDatasetId, cursor, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerTerminalState(domainId, fixtureDatasetId, cursor, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+}
+/**
+ * MetaApi - axios parameter creator
+ * @export
+ */
+export const MetaApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * <br> OperationId: `MetaGetHealth`
+         * @summary Get health
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetHealth: async (options = {}) => {
+            const localVarPath = `/healthz`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * <br> OperationId: `MetaGetLiveness`
+         * @summary Get liveness
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetLiveness: async (options = {}) => {
+            const localVarPath = `/livez`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * <br> OperationId: `MetaGetOpenApi`
+         * @summary Get open api
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetOpenApi: async (options = {}) => {
+            const localVarPath = `/openapi.json`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * <br> OperationId: `MetaGetOpenApiHtml`
+         * @summary Get open api html
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetOpenApiHtml: async (options = {}) => {
+            const localVarPath = `/api.html`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * <br> OperationId: `MetaGetReadiness`
+         * @summary Get readiness
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetReadiness: async (options = {}) => {
+            const localVarPath = `/readyz`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * <br> OperationId: `MetaGetRoot`
+         * @summary Get root
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetRoot: async (options = {}) => {
+            const localVarPath = `/`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * MetaApi - functional programming interface
+ * @export
+ */
+export const MetaApiFp = function (configuration) {
+    const localVarAxiosParamCreator = MetaApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * <br> OperationId: `MetaGetHealth`
+         * @summary Get health
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async metaGetHealth(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetHealth(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetHealth']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `MetaGetLiveness`
+         * @summary Get liveness
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async metaGetLiveness(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetLiveness(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetLiveness']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `MetaGetOpenApi`
+         * @summary Get open api
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async metaGetOpenApi(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetOpenApi(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetOpenApi']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `MetaGetOpenApiHtml`
+         * @summary Get open api html
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async metaGetOpenApiHtml(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetOpenApiHtml(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetOpenApiHtml']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
          * <br> OperationId: `MetaGetReadiness`
@@ -3448,15 +4727,6 @@ export const MetaApiFactory = function (configuration, basePath, axios) {
         metaGetLiveness(options) {
             return localVarFp.metaGetLiveness(options).then((request) => request(axios, basePath));
         },
-        /**
-         * <br> OperationId: `MetaGetMetrics`
-         * @summary Get metrics
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        metaGetMetrics(options) {
-            return localVarFp.metaGetMetrics(options).then((request) => request(axios, basePath));
-        },
         /**
          * <br> OperationId: `MetaGetOpenApi`
          * @summary Get open api
@@ -3526,18 +4796,6 @@ export class MetaApi extends BaseAPI {
             .metaGetLiveness(options)
             .then((request) => request(this.axios, this.basePath));
     }
-    /**
-     * <br> OperationId: `MetaGetMetrics`
-     * @summary Get metrics
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MetaApi
-     */
-    metaGetMetrics(options) {
-        return MetaApiFp(this.configuration)
-            .metaGetMetrics(options)
-            .then((request) => request(this.axios, this.basePath));
-    }
     /**
      * <br> OperationId: `MetaGetOpenApi`
      * @summary Get open api
@@ -3904,13 +5162,268 @@ export class StaffAuthApi extends BaseAPI {
 export const StaffMeApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
-         * @summary Who this Staff session belongs to
+         * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
+         * @summary Who this Staff session belongs to
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffMeControllerMe: async (options = {}) => {
+            const localVarPath = `/staff/me`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication staffSession required
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * StaffMeApi - functional programming interface
+ * @export
+ */
+export const StaffMeApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffMeApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
+         * @summary Who this Staff session belongs to
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffMeControllerMe(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffMeControllerMe(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffMeApi.staffMeControllerMe']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    };
+};
+/**
+ * StaffMeApi - factory interface
+ * @export
+ */
+export const StaffMeApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = StaffMeApiFp(configuration);
+    return {
+        /**
+         * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
+         * @summary Who this Staff session belongs to
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffMeControllerMe(options) {
+            return localVarFp.staffMeControllerMe(options).then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * StaffMeApi - object-oriented interface
+ * @export
+ * @class StaffMeApi
+ * @extends {BaseAPI}
+ */
+export class StaffMeApi extends BaseAPI {
+    /**
+     * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
+     * @summary Who this Staff session belongs to
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffMeApi
+     */
+    staffMeControllerMe(options) {
+        return StaffMeApiFp(this.configuration)
+            .staffMeControllerMe(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+}
+/**
+ * StaffPlanApi - axios parameter creator
+ * @export
+ */
+export const StaffPlanApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * Every Plan the billing provider knows about, unfiltered by storefront lookup keys — the ids here are exactly what a Distributor’s allowedPlans accepts. A Viewer sees no prices; Operator and Owner do.<br> OperationId: `StaffPlanControllerList`
+         * @summary The Plan catalogue
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerList: async (options = {}) => {
+            const localVarPath = `/staff/plans`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication staffSession required
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * StaffPlanApi - functional programming interface
+ * @export
+ */
+export const StaffPlanApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffPlanApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * Every Plan the billing provider knows about, unfiltered by storefront lookup keys — the ids here are exactly what a Distributor’s allowedPlans accepts. A Viewer sees no prices; Operator and Owner do.<br> OperationId: `StaffPlanControllerList`
+         * @summary The Plan catalogue
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffPlanControllerList(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerList(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerList']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    };
+};
+/**
+ * StaffPlanApi - factory interface
+ * @export
+ */
+export const StaffPlanApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = StaffPlanApiFp(configuration);
+    return {
+        /**
+         * Every Plan the billing provider knows about, unfiltered by storefront lookup keys — the ids here are exactly what a Distributor’s allowedPlans accepts. A Viewer sees no prices; Operator and Owner do.<br> OperationId: `StaffPlanControllerList`
+         * @summary The Plan catalogue
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerList(options) {
+            return localVarFp.staffPlanControllerList(options).then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * StaffPlanApi - object-oriented interface
+ * @export
+ * @class StaffPlanApi
+ * @extends {BaseAPI}
+ */
+export class StaffPlanApi extends BaseAPI {
+    /**
+     * Every Plan the billing provider knows about, unfiltered by storefront lookup keys — the ids here are exactly what a Distributor’s allowedPlans accepts. A Viewer sees no prices; Operator and Owner do.<br> OperationId: `StaffPlanControllerList`
+     * @summary The Plan catalogue
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffPlanApi
+     */
+    staffPlanControllerList(options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerList(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+}
+/**
+ * StaffTakaroAiApi - axios parameter creator
+ * @export
+ */
+export const StaffTakaroAiApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * Staff only. The configured default override applies again. An expired override can be cleared.<br> OperationId: `StaffTakaroAiControllerClearDomainOverride`
+         * @summary Clear the Takaro AI override of a Domain
+         * @param {string} id
+         * @param {TakaroAiOverrideClearInputDTO} [takaroAiOverrideClearInputDTO] TakaroAiOverrideClearInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffTakaroAiControllerClearDomainOverride: async (id, takaroAiOverrideClearInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffTakaroAiControllerClearDomainOverride', 'id', id);
+            const localVarPath = `/staff/takaro-ai/domain/{id}/override`.replace(`{${'id'}}`, encodeURIComponent(String(id)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication staffSession required
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(takaroAiOverrideClearInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Staff only. Amounts are integer microdollars: Plan base, the effective monthly allowance, usage and total spend, plus the override and its change history.<br> OperationId: `StaffTakaroAiControllerGetDomain`
+         * @summary Takaro AI allowance, override and spend of a Domain
+         * @param {string} id
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffTakaroAiControllerGetDomain: async (id, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffTakaroAiControllerGetDomain', 'id', id);
+            const localVarPath = `/staff/takaro-ai/domain/{id}`.replace(`{${'id'}}`, encodeURIComponent(String(id)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication staffSession required
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Staff only. Amounts are integer microdollars: platform spend this month, today and in the spend alert window, the top Domains by spend, the global multiplier and its history, and the spend alerts.<br> OperationId: `StaffTakaroAiControllerGetPlatform`
+         * @summary Takaro AI platform spend and global multiplier
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffMeControllerMe: async (options = {}) => {
-            const localVarPath = `/staff/me`;
+        staffTakaroAiControllerGetPlatform: async (options = {}) => {
+            const localVarPath = `/staff/takaro-ai`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -3931,96 +5444,100 @@ export const StaffMeApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
-    };
-};
-/**
- * StaffMeApi - functional programming interface
- * @export
- */
-export const StaffMeApiFp = function (configuration) {
-    const localVarAxiosParamCreator = StaffMeApiAxiosParamCreator(configuration);
-    return {
         /**
-         * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
-         * @summary Who this Staff session belongs to
+         * Staff only. A factor on the Domain’s allowance, 0 to 1000, with an optional expiry in the future. 0 switches Takaro AI off for the Domain. The billing reconciler never writes it.<br> OperationId: `StaffTakaroAiControllerSetDomainOverride`
+         * @summary Set the Takaro AI override of a Domain
+         * @param {string} id
+         * @param {TakaroAiDomainOverrideInputDTO} [takaroAiDomainOverrideInputDTO] TakaroAiDomainOverrideInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async staffMeControllerMe(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.staffMeControllerMe(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StaffMeApi.staffMeControllerMe']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        staffTakaroAiControllerSetDomainOverride: async (id, takaroAiDomainOverrideInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffTakaroAiControllerSetDomainOverride', 'id', id);
+            const localVarPath = `/staff/takaro-ai/domain/{id}/override`.replace(`{${'id'}}`, encodeURIComponent(String(id)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication staffSession required
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(takaroAiDomainOverrideInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
-    };
-};
-/**
- * StaffMeApi - factory interface
- * @export
- */
-export const StaffMeApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = StaffMeApiFp(configuration);
-    return {
         /**
-         * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
-         * @summary Who this Staff session belongs to
+         * Staff only. A factor on every Domain’s monthly allowance, 0 to 10. Applies from the next usage evaluation; needs no restart. Recorded with who, when and the reason.<br> OperationId: `StaffTakaroAiControllerSetGlobalMultiplier`
+         * @summary Set the Takaro AI global multiplier
+         * @param {TakaroAiGlobalMultiplierInputDTO} [takaroAiGlobalMultiplierInputDTO] TakaroAiGlobalMultiplierInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffMeControllerMe(options) {
-            return localVarFp.staffMeControllerMe(options).then((request) => request(axios, basePath));
+        staffTakaroAiControllerSetGlobalMultiplier: async (takaroAiGlobalMultiplierInputDTO, options = {}) => {
+            const localVarPath = `/staff/takaro-ai/global-multiplier`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication staffSession required
+            // authentication adminAuth required
+            await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(takaroAiGlobalMultiplierInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
-    };
-};
-/**
- * StaffMeApi - object-oriented interface
- * @export
- * @class StaffMeApi
- * @extends {BaseAPI}
- */
-export class StaffMeApi extends BaseAPI {
-    /**
-     * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
-     * @summary Who this Staff session belongs to
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof StaffMeApi
-     */
-    staffMeControllerMe(options) {
-        return StaffMeApiFp(this.configuration)
-            .staffMeControllerMe(options)
-            .then((request) => request(this.axios, this.basePath));
-    }
-}
-/**
- * StaffPlanApi - axios parameter creator
- * @export
- */
-export const StaffPlanApiAxiosParamCreator = function (configuration) {
-    return {
         /**
-         * Every Plan the billing provider knows about, unfiltered by storefront lookup keys — the ids here are exactly what a Distributor’s allowedPlans accepts. A Viewer sees no prices; Operator and Owner do.<br> OperationId: `StaffPlanControllerList`
-         * @summary The Plan catalogue
+         * Staff only. What the Domain may spend in CSMM Migration Threads over its lifetime, in integer microdollars. Those Threads do not count against the allowance, so this cap is their only bound. `null` goes back to the configured default. Applies from the next message.<br> OperationId: `StaffTakaroAiControllerSetMigrationCap`
+         * @summary Set the CSMM Migration cap of a Domain
+         * @param {string} id
+         * @param {TakaroAiMigrationCapInputDTO} [takaroAiMigrationCapInputDTO] TakaroAiMigrationCapInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffPlanControllerList: async (options = {}) => {
-            const localVarPath = `/staff/plans`;
+        staffTakaroAiControllerSetMigrationCap: async (id, takaroAiMigrationCapInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffTakaroAiControllerSetMigrationCap', 'id', id);
+            const localVarPath = `/staff/takaro-ai/domain/{id}/migration-cap`.replace(`{${'id'}}`, encodeURIComponent(String(id)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
             if (configuration) {
                 baseOptions = configuration.baseOptions;
             }
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication staffSession required
             // authentication adminAuth required
             await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(takaroAiMigrationCapInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -4029,61 +5546,260 @@ export const StaffPlanApiAxiosParamCreator = function (configuration) {
     };
 };
 /**
- * StaffPlanApi - functional programming interface
+ * StaffTakaroAiApi - functional programming interface
  * @export
  */
-export const StaffPlanApiFp = function (configuration) {
-    const localVarAxiosParamCreator = StaffPlanApiAxiosParamCreator(configuration);
+export const StaffTakaroAiApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffTakaroAiApiAxiosParamCreator(configuration);
     return {
         /**
-         * Every Plan the billing provider knows about, unfiltered by storefront lookup keys — the ids here are exactly what a Distributor’s allowedPlans accepts. A Viewer sees no prices; Operator and Owner do.<br> OperationId: `StaffPlanControllerList`
-         * @summary The Plan catalogue
+         * Staff only. The configured default override applies again. An expired override can be cleared.<br> OperationId: `StaffTakaroAiControllerClearDomainOverride`
+         * @summary Clear the Takaro AI override of a Domain
+         * @param {string} id
+         * @param {TakaroAiOverrideClearInputDTO} [takaroAiOverrideClearInputDTO] TakaroAiOverrideClearInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async staffPlanControllerList(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerList(options);
+        async staffTakaroAiControllerClearDomainOverride(id, takaroAiOverrideClearInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffTakaroAiControllerClearDomainOverride(id, takaroAiOverrideClearInputDTO, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerList']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StaffTakaroAiApi.staffTakaroAiControllerClearDomainOverride']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Staff only. Amounts are integer microdollars: Plan base, the effective monthly allowance, usage and total spend, plus the override and its change history.<br> OperationId: `StaffTakaroAiControllerGetDomain`
+         * @summary Takaro AI allowance, override and spend of a Domain
+         * @param {string} id
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffTakaroAiControllerGetDomain(id, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffTakaroAiControllerGetDomain(id, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffTakaroAiApi.staffTakaroAiControllerGetDomain']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Staff only. Amounts are integer microdollars: platform spend this month, today and in the spend alert window, the top Domains by spend, the global multiplier and its history, and the spend alerts.<br> OperationId: `StaffTakaroAiControllerGetPlatform`
+         * @summary Takaro AI platform spend and global multiplier
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffTakaroAiControllerGetPlatform(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffTakaroAiControllerGetPlatform(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffTakaroAiApi.staffTakaroAiControllerGetPlatform']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Staff only. A factor on the Domain’s allowance, 0 to 1000, with an optional expiry in the future. 0 switches Takaro AI off for the Domain. The billing reconciler never writes it.<br> OperationId: `StaffTakaroAiControllerSetDomainOverride`
+         * @summary Set the Takaro AI override of a Domain
+         * @param {string} id
+         * @param {TakaroAiDomainOverrideInputDTO} [takaroAiDomainOverrideInputDTO] TakaroAiDomainOverrideInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffTakaroAiControllerSetDomainOverride(id, takaroAiDomainOverrideInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffTakaroAiControllerSetDomainOverride(id, takaroAiDomainOverrideInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffTakaroAiApi.staffTakaroAiControllerSetDomainOverride']?.[localVarOperationServerIndex]
+                ?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Staff only. A factor on every Domain’s monthly allowance, 0 to 10. Applies from the next usage evaluation; needs no restart. Recorded with who, when and the reason.<br> OperationId: `StaffTakaroAiControllerSetGlobalMultiplier`
+         * @summary Set the Takaro AI global multiplier
+         * @param {TakaroAiGlobalMultiplierInputDTO} [takaroAiGlobalMultiplierInputDTO] TakaroAiGlobalMultiplierInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffTakaroAiControllerSetGlobalMultiplier(takaroAiGlobalMultiplierInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffTakaroAiControllerSetGlobalMultiplier(takaroAiGlobalMultiplierInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffTakaroAiApi.staffTakaroAiControllerSetGlobalMultiplier']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Staff only. What the Domain may spend in CSMM Migration Threads over its lifetime, in integer microdollars. Those Threads do not count against the allowance, so this cap is their only bound. `null` goes back to the configured default. Applies from the next message.<br> OperationId: `StaffTakaroAiControllerSetMigrationCap`
+         * @summary Set the CSMM Migration cap of a Domain
+         * @param {string} id
+         * @param {TakaroAiMigrationCapInputDTO} [takaroAiMigrationCapInputDTO] TakaroAiMigrationCapInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffTakaroAiControllerSetMigrationCap(id, takaroAiMigrationCapInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffTakaroAiControllerSetMigrationCap(id, takaroAiMigrationCapInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffTakaroAiApi.staffTakaroAiControllerSetMigrationCap']?.[localVarOperationServerIndex]
+                ?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
 /**
- * StaffPlanApi - factory interface
+ * StaffTakaroAiApi - factory interface
  * @export
  */
-export const StaffPlanApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = StaffPlanApiFp(configuration);
+export const StaffTakaroAiApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = StaffTakaroAiApiFp(configuration);
     return {
         /**
-         * Every Plan the billing provider knows about, unfiltered by storefront lookup keys — the ids here are exactly what a Distributor’s allowedPlans accepts. A Viewer sees no prices; Operator and Owner do.<br> OperationId: `StaffPlanControllerList`
-         * @summary The Plan catalogue
+         * Staff only. The configured default override applies again. An expired override can be cleared.<br> OperationId: `StaffTakaroAiControllerClearDomainOverride`
+         * @summary Clear the Takaro AI override of a Domain
+         * @param {string} id
+         * @param {TakaroAiOverrideClearInputDTO} [takaroAiOverrideClearInputDTO] TakaroAiOverrideClearInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffPlanControllerList(options) {
-            return localVarFp.staffPlanControllerList(options).then((request) => request(axios, basePath));
+        staffTakaroAiControllerClearDomainOverride(id, takaroAiOverrideClearInputDTO, options) {
+            return localVarFp
+                .staffTakaroAiControllerClearDomainOverride(id, takaroAiOverrideClearInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * Staff only. Amounts are integer microdollars: Plan base, the effective monthly allowance, usage and total spend, plus the override and its change history.<br> OperationId: `StaffTakaroAiControllerGetDomain`
+         * @summary Takaro AI allowance, override and spend of a Domain
+         * @param {string} id
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffTakaroAiControllerGetDomain(id, options) {
+            return localVarFp.staffTakaroAiControllerGetDomain(id, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Staff only. Amounts are integer microdollars: platform spend this month, today and in the spend alert window, the top Domains by spend, the global multiplier and its history, and the spend alerts.<br> OperationId: `StaffTakaroAiControllerGetPlatform`
+         * @summary Takaro AI platform spend and global multiplier
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffTakaroAiControllerGetPlatform(options) {
+            return localVarFp.staffTakaroAiControllerGetPlatform(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Staff only. A factor on the Domain’s allowance, 0 to 1000, with an optional expiry in the future. 0 switches Takaro AI off for the Domain. The billing reconciler never writes it.<br> OperationId: `StaffTakaroAiControllerSetDomainOverride`
+         * @summary Set the Takaro AI override of a Domain
+         * @param {string} id
+         * @param {TakaroAiDomainOverrideInputDTO} [takaroAiDomainOverrideInputDTO] TakaroAiDomainOverrideInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffTakaroAiControllerSetDomainOverride(id, takaroAiDomainOverrideInputDTO, options) {
+            return localVarFp
+                .staffTakaroAiControllerSetDomainOverride(id, takaroAiDomainOverrideInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * Staff only. A factor on every Domain’s monthly allowance, 0 to 10. Applies from the next usage evaluation; needs no restart. Recorded with who, when and the reason.<br> OperationId: `StaffTakaroAiControllerSetGlobalMultiplier`
+         * @summary Set the Takaro AI global multiplier
+         * @param {TakaroAiGlobalMultiplierInputDTO} [takaroAiGlobalMultiplierInputDTO] TakaroAiGlobalMultiplierInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffTakaroAiControllerSetGlobalMultiplier(takaroAiGlobalMultiplierInputDTO, options) {
+            return localVarFp
+                .staffTakaroAiControllerSetGlobalMultiplier(takaroAiGlobalMultiplierInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * Staff only. What the Domain may spend in CSMM Migration Threads over its lifetime, in integer microdollars. Those Threads do not count against the allowance, so this cap is their only bound. `null` goes back to the configured default. Applies from the next message.<br> OperationId: `StaffTakaroAiControllerSetMigrationCap`
+         * @summary Set the CSMM Migration cap of a Domain
+         * @param {string} id
+         * @param {TakaroAiMigrationCapInputDTO} [takaroAiMigrationCapInputDTO] TakaroAiMigrationCapInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffTakaroAiControllerSetMigrationCap(id, takaroAiMigrationCapInputDTO, options) {
+            return localVarFp
+                .staffTakaroAiControllerSetMigrationCap(id, takaroAiMigrationCapInputDTO, options)
+                .then((request) => request(axios, basePath));
         },
     };
 };
 /**
- * StaffPlanApi - object-oriented interface
+ * StaffTakaroAiApi - object-oriented interface
  * @export
- * @class StaffPlanApi
+ * @class StaffTakaroAiApi
  * @extends {BaseAPI}
  */
-export class StaffPlanApi extends BaseAPI {
+export class StaffTakaroAiApi extends BaseAPI {
     /**
-     * Every Plan the billing provider knows about, unfiltered by storefront lookup keys — the ids here are exactly what a Distributor’s allowedPlans accepts. A Viewer sees no prices; Operator and Owner do.<br> OperationId: `StaffPlanControllerList`
-     * @summary The Plan catalogue
+     * Staff only. The configured default override applies again. An expired override can be cleared.<br> OperationId: `StaffTakaroAiControllerClearDomainOverride`
+     * @summary Clear the Takaro AI override of a Domain
+     * @param {string} id
+     * @param {TakaroAiOverrideClearInputDTO} [takaroAiOverrideClearInputDTO] TakaroAiOverrideClearInputDTO
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StaffPlanApi
+     * @memberof StaffTakaroAiApi
      */
-    staffPlanControllerList(options) {
-        return StaffPlanApiFp(this.configuration)
-            .staffPlanControllerList(options)
+    staffTakaroAiControllerClearDomainOverride(id, takaroAiOverrideClearInputDTO, options) {
+        return StaffTakaroAiApiFp(this.configuration)
+            .staffTakaroAiControllerClearDomainOverride(id, takaroAiOverrideClearInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Staff only. Amounts are integer microdollars: Plan base, the effective monthly allowance, usage and total spend, plus the override and its change history.<br> OperationId: `StaffTakaroAiControllerGetDomain`
+     * @summary Takaro AI allowance, override and spend of a Domain
+     * @param {string} id
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffTakaroAiApi
+     */
+    staffTakaroAiControllerGetDomain(id, options) {
+        return StaffTakaroAiApiFp(this.configuration)
+            .staffTakaroAiControllerGetDomain(id, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Staff only. Amounts are integer microdollars: platform spend this month, today and in the spend alert window, the top Domains by spend, the global multiplier and its history, and the spend alerts.<br> OperationId: `StaffTakaroAiControllerGetPlatform`
+     * @summary Takaro AI platform spend and global multiplier
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffTakaroAiApi
+     */
+    staffTakaroAiControllerGetPlatform(options) {
+        return StaffTakaroAiApiFp(this.configuration)
+            .staffTakaroAiControllerGetPlatform(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Staff only. A factor on the Domain’s allowance, 0 to 1000, with an optional expiry in the future. 0 switches Takaro AI off for the Domain. The billing reconciler never writes it.<br> OperationId: `StaffTakaroAiControllerSetDomainOverride`
+     * @summary Set the Takaro AI override of a Domain
+     * @param {string} id
+     * @param {TakaroAiDomainOverrideInputDTO} [takaroAiDomainOverrideInputDTO] TakaroAiDomainOverrideInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffTakaroAiApi
+     */
+    staffTakaroAiControllerSetDomainOverride(id, takaroAiDomainOverrideInputDTO, options) {
+        return StaffTakaroAiApiFp(this.configuration)
+            .staffTakaroAiControllerSetDomainOverride(id, takaroAiDomainOverrideInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Staff only. A factor on every Domain’s monthly allowance, 0 to 10. Applies from the next usage evaluation; needs no restart. Recorded with who, when and the reason.<br> OperationId: `StaffTakaroAiControllerSetGlobalMultiplier`
+     * @summary Set the Takaro AI global multiplier
+     * @param {TakaroAiGlobalMultiplierInputDTO} [takaroAiGlobalMultiplierInputDTO] TakaroAiGlobalMultiplierInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffTakaroAiApi
+     */
+    staffTakaroAiControllerSetGlobalMultiplier(takaroAiGlobalMultiplierInputDTO, options) {
+        return StaffTakaroAiApiFp(this.configuration)
+            .staffTakaroAiControllerSetGlobalMultiplier(takaroAiGlobalMultiplierInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Staff only. What the Domain may spend in CSMM Migration Threads over its lifetime, in integer microdollars. Those Threads do not count against the allowance, so this cap is their only bound. `null` goes back to the configured default. Applies from the next message.<br> OperationId: `StaffTakaroAiControllerSetMigrationCap`
+     * @summary Set the CSMM Migration cap of a Domain
+     * @param {string} id
+     * @param {TakaroAiMigrationCapInputDTO} [takaroAiMigrationCapInputDTO] TakaroAiMigrationCapInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffTakaroAiApi
+     */
+    staffTakaroAiControllerSetMigrationCap(id, takaroAiMigrationCapInputDTO, options) {
+        return StaffTakaroAiApiFp(this.configuration)
+            .staffTakaroAiControllerSetMigrationCap(id, takaroAiMigrationCapInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
 }