@takaro/apiclient 0.0.0-dev.56b1587 → 0.0.0-dev.573074e

package/dist/generated-management/api.js

@@ -47,14 +47,17 @@ export const ApiKeySearchInputDTOSortDirectionEnum = {
     Asc: 'asc',
     Desc: 'desc',
 };
-export const DistributorBackedDomainOutputDTOStateEnum = {
-    Active: 'ACTIVE',
-    Disabled: 'DISABLED',
-    Maintenance: 'MAINTENANCE',
+export const ConnectorMigrationOutputDTOStatusEnum = {
+    Pending: 'pending',
+    Completed: 'completed',
+    Cancelled: 'cancelled',
+    Reverted: 'reverted',
 };
-export const DistributorBackedDomainSearchInputDTOSortDirectionEnum = {
-    Asc: 'asc',
-    Desc: 'desc',
+export const ConnectorMigrationOutputDTOLegacyTypeEnum = {
+    Sevendaystodie: 'SEVENDAYSTODIE',
+    Rust: 'RUST',
+    Generic: 'GENERIC',
+    Mock: 'MOCK',
 };
 export const DistributorDomainSearchInputAllowedFiltersStateEnum = {
     Active: 'ACTIVE',
@@ -86,6 +89,21 @@ export const DomainCreateInputDTOStateEnum = {
     Disabled: 'DISABLED',
     Maintenance: 'MAINTENANCE',
 };
+export const DomainLimitOutputDTOSourceEnum = {
+    Plan: 'plan',
+    Override: 'override',
+    Adoption: 'adoption',
+    Unmanaged: 'unmanaged',
+};
+export const DomainLimitOverrideChangeOutputDTOActionEnum = {
+    Set: 'set',
+    Clear: 'clear',
+};
+export const DomainLimitOverrideChangeOutputDTOActorKindEnum = {
+    StaffSession: 'staffSession',
+    AdminSecret: 'adminSecret',
+    System: 'system',
+};
 export const DomainOutputDTOStateEnum = {
     Active: 'ACTIVE',
     Disabled: 'DISABLED',
@@ -183,6 +201,12 @@ export const EventCreateDTOEventNameEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    ConnectorMigrationStarted: 'connector-migration-started',
+    ConnectorMigrationCompleted: 'connector-migration-completed',
+    ConnectorMigrationCancelled: 'connector-migration-cancelled',
+    ConnectorMigrationReverted: 'connector-migration-reverted',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
     PlayerConnected: 'player-connected',
     PlayerDisconnected: 'player-disconnected',
     ChatMessage: 'chat-message',
@@ -236,12 +260,43 @@ export const EventOutputDTOEventNameEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    ConnectorMigrationStarted: 'connector-migration-started',
+    ConnectorMigrationCompleted: 'connector-migration-completed',
+    ConnectorMigrationCancelled: 'connector-migration-cancelled',
+    ConnectorMigrationReverted: 'connector-migration-reverted',
+    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 +321,26 @@ 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',
+    DeleteClickHouseEvents: 'deleteClickHouseEvents',
+    CleanConnectorMigrations: 'cleanConnectorMigrations',
+};
 export const HookCreateDTOEventTypeEnum = {
     Log: 'log',
     PlayerConnected: 'player-connected',
@@ -320,6 +395,12 @@ export const HookCreateDTOEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    ConnectorMigrationStarted: 'connector-migration-started',
+    ConnectorMigrationCompleted: 'connector-migration-completed',
+    ConnectorMigrationCancelled: 'connector-migration-cancelled',
+    ConnectorMigrationReverted: 'connector-migration-reverted',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const HookOutputDTOEventTypeEnum = {
     Log: 'log',
@@ -375,6 +456,12 @@ export const HookOutputDTOEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    ConnectorMigrationStarted: 'connector-migration-started',
+    ConnectorMigrationCompleted: 'connector-migration-completed',
+    ConnectorMigrationCancelled: 'connector-migration-cancelled',
+    ConnectorMigrationReverted: 'connector-migration-reverted',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const HookTriggerDTOEventTypeEnum = {
     Log: 'log',
@@ -430,6 +517,12 @@ export const HookTriggerDTOEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    ConnectorMigrationStarted: 'connector-migration-started',
+    ConnectorMigrationCompleted: 'connector-migration-completed',
+    ConnectorMigrationCancelled: 'connector-migration-cancelled',
+    ConnectorMigrationReverted: 'connector-migration-reverted',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const HookUpdateDTOEventTypeEnum = {
     Log: 'log',
@@ -485,6 +578,12 @@ export const HookUpdateDTOEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    ConnectorMigrationStarted: 'connector-migration-started',
+    ConnectorMigrationCompleted: 'connector-migration-completed',
+    ConnectorMigrationCancelled: 'connector-migration-cancelled',
+    ConnectorMigrationReverted: 'connector-migration-reverted',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const IEntityDTOTypeEnum = {
     Hostile: 'hostile',
@@ -545,6 +644,12 @@ export const IHookEventTypeEnum = {
     DomainCreated: 'domain-created',
     DomainRegistrationTokenRegenerated: 'domain-registration-token-regenerated',
     DomainPlanChanged: 'domain-plan-changed',
+    ConnectorMigrationStarted: 'connector-migration-started',
+    ConnectorMigrationCompleted: 'connector-migration-completed',
+    ConnectorMigrationCancelled: 'connector-migration-cancelled',
+    ConnectorMigrationReverted: 'connector-migration-reverted',
+    DiscordGuildEnabled: 'discord-guild-enabled',
+    ItemsGiven: 'items-given',
 };
 export const ITakaroQuerySortDirectionEnum = {
     Asc: 'asc',
@@ -592,6 +697,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',
@@ -629,11 +761,15 @@ export const PERMISSIONS = {
     SendDiscordMessage: 'SEND_DISCORD_MESSAGE',
     ManageApiKeys: 'MANAGE_API_KEYS',
 };
-export const PlanPriceDTOIntervalEnum = {
-    Day: 'day',
-    Week: 'week',
-    Month: 'month',
-    Year: 'year',
+export const PlanChangeOutputDTOActionEnum = {
+    Create: 'create',
+    Update: 'update',
+    Archive: 'archive',
+};
+export const PlanChangeOutputDTOActorKindEnum = {
+    StaffSession: 'staffSession',
+    AdminSecret: 'adminSecret',
+    System: 'system',
 };
 export const PlayerOnGameServerSearchInputDTOExtendEnum = {
     GameServer: 'gameServer',
@@ -674,6 +810,7 @@ export const SettingsOutputDTOKeyEnum = {
     DiscordRoleSyncPreferDiscord: 'discordRoleSyncPreferDiscord',
     UnknownCommandFeedbackEnabled: 'unknownCommandFeedbackEnabled',
     UnknownCommandFeedbackMessage: 'unknownCommandFeedbackMessage',
+    TakaroAiEnabled: 'takaroAiEnabled',
 };
 export const SettingsOutputDTOTypeEnum = {
     Override: 'override',
@@ -751,11 +888,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 +921,55 @@ export const StorefrontDomainOutputDTOCustomDomainStateEnum = {
     Verified: 'VERIFIED',
     Failed: 'FAILED',
 };
+export const StripePriceDTOIntervalEnum = {
+    Day: 'day',
+    Week: 'week',
+    Month: 'month',
+    Year: 'year',
+};
+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 +980,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',
 };
@@ -1545,7 +1888,7 @@ export class DistributorApi extends BaseAPI {
 export const DistributorSelfServiceApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * Creates a domain attributed to the calling distributor (ADR 0024 — attribution, never ownership). The response carries the domain and its `serverRegistrationToken`, so a provisioning script can inject the token into a game server without a second call. Limits come from the chosen Plan, applied by the billing reconciler within seconds; a domain created without a `planId` starts on the platform defaults. A Plan outside `allowedPlans` is refused with a 400. A Distributor Service Account holding the domain’s root role is created with the domain; every management verb on the domain is recorded in its event feed as that account.<br> OperationId: `DistributorSelfServiceControllerCreateDomain`
+         * Creates a domain attributed to the calling distributor (ADR 0024 — attribution, never ownership). The response carries the domain and its `serverRegistrationToken`, so a provisioning script can inject the token into a game server without a second call. Limits come from the chosen Plan and apply at creation; a domain created without a `planId` starts on the platform defaults. A Plan outside `allowedPlans` is refused with a 400. A Distributor Service Account holding the domain’s root role is created with the domain; every management verb on the domain is recorded in its event feed as that account.<br> OperationId: `DistributorSelfServiceControllerCreateDomain`
          * @summary Create a domain
          * @param {DistributorDomainCreateInputDTO} [distributorDomainCreateInputDTO] DistributorDomainCreateInputDTO
          * @param {*} [options] Override http request option.
@@ -1855,7 +2198,7 @@ export const DistributorSelfServiceApiAxiosParamCreator = function (configuratio
             };
         },
         /**
-         * Moves the domain onto another of the Plans allowed for the calling distributor and enqueues the reconciliation that writes the Plan’s limits onto the domain, normally within seconds. Downgrading a customer who cancelled means moving the domain to the free Plan — it keeps running at free limits, and its state never changes. A Plan outside the allowed list is a 400; another distributor’s domain is a 404, never a 403. Idempotent: setting the Plan the domain is already on re-runs the reconciliation and writes nothing.<br> OperationId: `DistributorSelfServiceControllerSetDomainPlan`
+         * Moves the domain onto another of the Plans allowed for the calling distributor; the Plan’s limits apply before the response. Downgrading a customer who cancelled means moving the domain to the free Plan — it keeps running at free limits, and its state never changes. A Plan outside the allowed list is a 400; another distributor’s domain is a 404, never a 403. Idempotent: setting the Plan the domain is already on re-applies its limits and records nothing.<br> OperationId: `DistributorSelfServiceControllerSetDomainPlan`
          * @summary Change one of my domains’ Plan
          * @param {string} id
          * @param {DistributorDomainPlanInputDTO} [distributorDomainPlanInputDTO] DistributorDomainPlanInputDTO
@@ -1898,7 +2241,7 @@ export const DistributorSelfServiceApiFp = function (configuration) {
     const localVarAxiosParamCreator = DistributorSelfServiceApiAxiosParamCreator(configuration);
     return {
         /**
-         * Creates a domain attributed to the calling distributor (ADR 0024 — attribution, never ownership). The response carries the domain and its `serverRegistrationToken`, so a provisioning script can inject the token into a game server without a second call. Limits come from the chosen Plan, applied by the billing reconciler within seconds; a domain created without a `planId` starts on the platform defaults. A Plan outside `allowedPlans` is refused with a 400. A Distributor Service Account holding the domain’s root role is created with the domain; every management verb on the domain is recorded in its event feed as that account.<br> OperationId: `DistributorSelfServiceControllerCreateDomain`
+         * Creates a domain attributed to the calling distributor (ADR 0024 — attribution, never ownership). The response carries the domain and its `serverRegistrationToken`, so a provisioning script can inject the token into a game server without a second call. Limits come from the chosen Plan and apply at creation; a domain created without a `planId` starts on the platform defaults. A Plan outside `allowedPlans` is refused with a 400. A Distributor Service Account holding the domain’s root role is created with the domain; every management verb on the domain is recorded in its event feed as that account.<br> OperationId: `DistributorSelfServiceControllerCreateDomain`
          * @summary Create a domain
          * @param {DistributorDomainCreateInputDTO} [distributorDomainCreateInputDTO] DistributorDomainCreateInputDTO
          * @param {*} [options] Override http request option.
@@ -2028,7 +2371,7 @@ export const DistributorSelfServiceApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Moves the domain onto another of the Plans allowed for the calling distributor and enqueues the reconciliation that writes the Plan’s limits onto the domain, normally within seconds. Downgrading a customer who cancelled means moving the domain to the free Plan — it keeps running at free limits, and its state never changes. A Plan outside the allowed list is a 400; another distributor’s domain is a 404, never a 403. Idempotent: setting the Plan the domain is already on re-runs the reconciliation and writes nothing.<br> OperationId: `DistributorSelfServiceControllerSetDomainPlan`
+         * Moves the domain onto another of the Plans allowed for the calling distributor; the Plan’s limits apply before the response. Downgrading a customer who cancelled means moving the domain to the free Plan — it keeps running at free limits, and its state never changes. A Plan outside the allowed list is a 400; another distributor’s domain is a 404, never a 403. Idempotent: setting the Plan the domain is already on re-applies its limits and records nothing.<br> OperationId: `DistributorSelfServiceControllerSetDomainPlan`
          * @summary Change one of my domains’ Plan
          * @param {string} id
          * @param {DistributorDomainPlanInputDTO} [distributorDomainPlanInputDTO] DistributorDomainPlanInputDTO
@@ -2051,7 +2394,7 @@ export const DistributorSelfServiceApiFactory = function (configuration, basePat
     const localVarFp = DistributorSelfServiceApiFp(configuration);
     return {
         /**
-         * Creates a domain attributed to the calling distributor (ADR 0024 — attribution, never ownership). The response carries the domain and its `serverRegistrationToken`, so a provisioning script can inject the token into a game server without a second call. Limits come from the chosen Plan, applied by the billing reconciler within seconds; a domain created without a `planId` starts on the platform defaults. A Plan outside `allowedPlans` is refused with a 400. A Distributor Service Account holding the domain’s root role is created with the domain; every management verb on the domain is recorded in its event feed as that account.<br> OperationId: `DistributorSelfServiceControllerCreateDomain`
+         * Creates a domain attributed to the calling distributor (ADR 0024 — attribution, never ownership). The response carries the domain and its `serverRegistrationToken`, so a provisioning script can inject the token into a game server without a second call. Limits come from the chosen Plan and apply at creation; a domain created without a `planId` starts on the platform defaults. A Plan outside `allowedPlans` is refused with a 400. A Distributor Service Account holding the domain’s root role is created with the domain; every management verb on the domain is recorded in its event feed as that account.<br> OperationId: `DistributorSelfServiceControllerCreateDomain`
          * @summary Create a domain
          * @param {DistributorDomainCreateInputDTO} [distributorDomainCreateInputDTO] DistributorDomainCreateInputDTO
          * @param {*} [options] Override http request option.
@@ -2169,7 +2512,7 @@ export const DistributorSelfServiceApiFactory = function (configuration, basePat
                 .then((request) => request(axios, basePath));
         },
         /**
-         * Moves the domain onto another of the Plans allowed for the calling distributor and enqueues the reconciliation that writes the Plan’s limits onto the domain, normally within seconds. Downgrading a customer who cancelled means moving the domain to the free Plan — it keeps running at free limits, and its state never changes. A Plan outside the allowed list is a 400; another distributor’s domain is a 404, never a 403. Idempotent: setting the Plan the domain is already on re-runs the reconciliation and writes nothing.<br> OperationId: `DistributorSelfServiceControllerSetDomainPlan`
+         * Moves the domain onto another of the Plans allowed for the calling distributor; the Plan’s limits apply before the response. Downgrading a customer who cancelled means moving the domain to the free Plan — it keeps running at free limits, and its state never changes. A Plan outside the allowed list is a 400; another distributor’s domain is a 404, never a 403. Idempotent: setting the Plan the domain is already on re-applies its limits and records nothing.<br> OperationId: `DistributorSelfServiceControllerSetDomainPlan`
          * @summary Change one of my domains’ Plan
          * @param {string} id
          * @param {DistributorDomainPlanInputDTO} [distributorDomainPlanInputDTO] DistributorDomainPlanInputDTO
@@ -2191,7 +2534,7 @@ export const DistributorSelfServiceApiFactory = function (configuration, basePat
  */
 export class DistributorSelfServiceApi extends BaseAPI {
     /**
-     * Creates a domain attributed to the calling distributor (ADR 0024 — attribution, never ownership). The response carries the domain and its `serverRegistrationToken`, so a provisioning script can inject the token into a game server without a second call. Limits come from the chosen Plan, applied by the billing reconciler within seconds; a domain created without a `planId` starts on the platform defaults. A Plan outside `allowedPlans` is refused with a 400. A Distributor Service Account holding the domain’s root role is created with the domain; every management verb on the domain is recorded in its event feed as that account.<br> OperationId: `DistributorSelfServiceControllerCreateDomain`
+     * Creates a domain attributed to the calling distributor (ADR 0024 — attribution, never ownership). The response carries the domain and its `serverRegistrationToken`, so a provisioning script can inject the token into a game server without a second call. Limits come from the chosen Plan and apply at creation; a domain created without a `planId` starts on the platform defaults. A Plan outside `allowedPlans` is refused with a 400. A Distributor Service Account holding the domain’s root role is created with the domain; every management verb on the domain is recorded in its event feed as that account.<br> OperationId: `DistributorSelfServiceControllerCreateDomain`
      * @summary Create a domain
      * @param {DistributorDomainCreateInputDTO} [distributorDomainCreateInputDTO] DistributorDomainCreateInputDTO
      * @param {*} [options] Override http request option.
@@ -2321,7 +2664,7 @@ export class DistributorSelfServiceApi extends BaseAPI {
             .then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Moves the domain onto another of the Plans allowed for the calling distributor and enqueues the reconciliation that writes the Plan’s limits onto the domain, normally within seconds. Downgrading a customer who cancelled means moving the domain to the free Plan — it keeps running at free limits, and its state never changes. A Plan outside the allowed list is a 400; another distributor’s domain is a 404, never a 403. Idempotent: setting the Plan the domain is already on re-runs the reconciliation and writes nothing.<br> OperationId: `DistributorSelfServiceControllerSetDomainPlan`
+     * Moves the domain onto another of the Plans allowed for the calling distributor; the Plan’s limits apply before the response. Downgrading a customer who cancelled means moving the domain to the free Plan — it keeps running at free limits, and its state never changes. A Plan outside the allowed list is a 400; another distributor’s domain is a 404, never a 403. Idempotent: setting the Plan the domain is already on re-applies its limits and records nothing.<br> OperationId: `DistributorSelfServiceControllerSetDomainPlan`
      * @summary Change one of my domains’ Plan
      * @param {string} id
      * @param {DistributorDomainPlanInputDTO} [distributorDomainPlanInputDTO] DistributorDomainPlanInputDTO
@@ -2633,21 +2976,24 @@ export const DomainApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * The domains attributed to a distributor, with the Plan their limits come from. This is the billing reconciler’s read: it never returns a subscription-backed domain, which is what makes it a reconciler sweep rather than a domain listing.<br> OperationId: `DomainControllerSearchDistributorBacked`
-         * @summary Search distributor-backed domains
-         * @param {DistributorBackedDomainSearchInputDTO} [distributorBackedDomainSearchInputDTO] DistributorBackedDomainSearchInputDTO
+         * Applies the Plan’s limits at once, keeping any limit override. On the first assignment of a domain that predates Plans, its hand-set variable, module, function, concurrency and rate limits that differ from the Plan are kept as overrides. Refused for a distributor-backed domain.<br> OperationId: `DomainControllerSetPlan`
+         * @summary Put a subscription-backed domain on a Plan
+         * @param {string} id
+         * @param {DomainPlanInputDTO} [domainPlanInputDTO] DomainPlanInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        domainControllerSearchDistributorBacked: async (distributorBackedDomainSearchInputDTO, options = {}) => {
-            const localVarPath = `/domain/distributor-backed/search`;
+        domainControllerSetPlan: async (id, domainPlanInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('domainControllerSetPlan', 'id', id);
+            const localVarPath = `/domain/{id}/plan`.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: 'POST', ...baseOptions, ...options };
+            const localVarRequestOptions = { method: 'PUT', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication staffSession required
@@ -2657,7 +3003,7 @@ export const DomainApiAxiosParamCreator = function (configuration) {
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-            localVarRequestOptions.data = serializeDataIfNeeded(distributorBackedDomainSearchInputDTO, localVarRequestOptions, configuration);
+            localVarRequestOptions.data = serializeDataIfNeeded(domainPlanInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -2827,16 +3173,17 @@ export const DomainApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * The domains attributed to a distributor, with the Plan their limits come from. This is the billing reconciler’s read: it never returns a subscription-backed domain, which is what makes it a reconciler sweep rather than a domain listing.<br> OperationId: `DomainControllerSearchDistributorBacked`
-         * @summary Search distributor-backed domains
-         * @param {DistributorBackedDomainSearchInputDTO} [distributorBackedDomainSearchInputDTO] DistributorBackedDomainSearchInputDTO
+         * Applies the Plan’s limits at once, keeping any limit override. On the first assignment of a domain that predates Plans, its hand-set variable, module, function, concurrency and rate limits that differ from the Plan are kept as overrides. Refused for a distributor-backed domain.<br> OperationId: `DomainControllerSetPlan`
+         * @summary Put a subscription-backed domain on a Plan
+         * @param {string} id
+         * @param {DomainPlanInputDTO} [domainPlanInputDTO] DomainPlanInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options);
+        async domainControllerSetPlan(id, domainPlanInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.domainControllerSetPlan(id, domainPlanInputDTO, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['DomainApi.domainControllerSearchDistributorBacked']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['DomainApi.domainControllerSetPlan']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -2966,15 +3313,16 @@ export const DomainApiFactory = function (configuration, basePath, axios) {
                 .then((request) => request(axios, basePath));
         },
         /**
-         * The domains attributed to a distributor, with the Plan their limits come from. This is the billing reconciler’s read: it never returns a subscription-backed domain, which is what makes it a reconciler sweep rather than a domain listing.<br> OperationId: `DomainControllerSearchDistributorBacked`
-         * @summary Search distributor-backed domains
-         * @param {DistributorBackedDomainSearchInputDTO} [distributorBackedDomainSearchInputDTO] DistributorBackedDomainSearchInputDTO
+         * Applies the Plan’s limits at once, keeping any limit override. On the first assignment of a domain that predates Plans, its hand-set variable, module, function, concurrency and rate limits that differ from the Plan are kept as overrides. Refused for a distributor-backed domain.<br> OperationId: `DomainControllerSetPlan`
+         * @summary Put a subscription-backed domain on a Plan
+         * @param {string} id
+         * @param {DomainPlanInputDTO} [domainPlanInputDTO] DomainPlanInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options) {
+        domainControllerSetPlan(id, domainPlanInputDTO, options) {
             return localVarFp
-                .domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options)
+                .domainControllerSetPlan(id, domainPlanInputDTO, options)
                 .then((request) => request(axios, basePath));
         },
         /**
@@ -3120,16 +3468,17 @@ export class DomainApi extends BaseAPI {
             .then((request) => request(this.axios, this.basePath));
     }
     /**
-     * The domains attributed to a distributor, with the Plan their limits come from. This is the billing reconciler’s read: it never returns a subscription-backed domain, which is what makes it a reconciler sweep rather than a domain listing.<br> OperationId: `DomainControllerSearchDistributorBacked`
-     * @summary Search distributor-backed domains
-     * @param {DistributorBackedDomainSearchInputDTO} [distributorBackedDomainSearchInputDTO] DistributorBackedDomainSearchInputDTO
+     * Applies the Plan’s limits at once, keeping any limit override. On the first assignment of a domain that predates Plans, its hand-set variable, module, function, concurrency and rate limits that differ from the Plan are kept as overrides. Refused for a distributor-backed domain.<br> OperationId: `DomainControllerSetPlan`
+     * @summary Put a subscription-backed domain on a Plan
+     * @param {string} id
+     * @param {DomainPlanInputDTO} [domainPlanInputDTO] DomainPlanInputDTO
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof DomainApi
      */
-    domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options) {
+    domainControllerSetPlan(id, domainPlanInputDTO, options) {
         return DomainApiFp(this.configuration)
-            .domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options)
+            .domainControllerSetPlan(id, domainPlanInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
     /**
@@ -3148,69 +3497,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 +3588,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,379 +3599,1976 @@ 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;
+        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: `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: 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
+         * <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`
+         * @summary Get readiness
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async metaGetReadiness(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetReadiness(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetReadiness']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `MetaGetRoot`
+         * @summary Get root
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async metaGetRoot(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetRoot(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetRoot']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    };
+};
+/**
+ * MetaApi - factory interface
+ * @export
+ */
+export const MetaApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = MetaApiFp(configuration);
+    return {
+        /**
+         * <br> OperationId: `MetaGetHealth`
+         * @summary Get health
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetHealth(options) {
+            return localVarFp.metaGetHealth(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `MetaGetLiveness`
+         * @summary Get liveness
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetLiveness(options) {
+            return localVarFp.metaGetLiveness(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `MetaGetOpenApi`
+         * @summary Get open api
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetOpenApi(options) {
+            return localVarFp.metaGetOpenApi(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `MetaGetOpenApiHtml`
+         * @summary Get open api html
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetOpenApiHtml(options) {
+            return localVarFp.metaGetOpenApiHtml(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `MetaGetReadiness`
+         * @summary Get readiness
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetReadiness(options) {
+            return localVarFp.metaGetReadiness(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `MetaGetRoot`
+         * @summary Get root
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        metaGetRoot(options) {
+            return localVarFp.metaGetRoot(options).then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * MetaApi - object-oriented interface
+ * @export
+ * @class MetaApi
+ * @extends {BaseAPI}
+ */
+export class MetaApi extends BaseAPI {
+    /**
+     * <br> OperationId: `MetaGetHealth`
+     * @summary Get health
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MetaApi
+     */
+    metaGetHealth(options) {
+        return MetaApiFp(this.configuration)
+            .metaGetHealth(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `MetaGetLiveness`
+     * @summary Get liveness
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MetaApi
+     */
+    metaGetLiveness(options) {
+        return MetaApiFp(this.configuration)
+            .metaGetLiveness(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `MetaGetOpenApi`
+     * @summary Get open api
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MetaApi
+     */
+    metaGetOpenApi(options) {
+        return MetaApiFp(this.configuration)
+            .metaGetOpenApi(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `MetaGetOpenApiHtml`
+     * @summary Get open api html
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MetaApi
+     */
+    metaGetOpenApiHtml(options) {
+        return MetaApiFp(this.configuration)
+            .metaGetOpenApiHtml(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `MetaGetReadiness`
+     * @summary Get readiness
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MetaApi
+     */
+    metaGetReadiness(options) {
+        return MetaApiFp(this.configuration)
+            .metaGetReadiness(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `MetaGetRoot`
+     * @summary Get root
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MetaApi
+     */
+    metaGetRoot(options) {
+        return MetaApiFp(this.configuration)
+            .metaGetRoot(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+}
+/**
+ * PlatformStatsApi - axios parameter creator
+ * @export
+ */
+export const PlatformStatsApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * Domains by state, by ADR 0024 backing, per Distributor, and created per ISO week. Weekly buckets start Monday 00:00 UTC and the window ends with the current, partial week. Cheap aggregates only: there is no game-server and no player count here.<br> OperationId: `PlatformStatsControllerDomains`
+         * @summary Platform-wide Domain statistics
+         * @param {number} [weeks]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        platformStatsControllerDomains: async (weeks, options = {}) => {
+            const localVarPath = `/staff/stats/domains`;
+            // 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);
+            if (weeks !== undefined) {
+                localVarQueryParameter['weeks'] = weeks;
+            }
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * PlatformStatsApi - functional programming interface
+ * @export
+ */
+export const PlatformStatsApiFp = function (configuration) {
+    const localVarAxiosParamCreator = PlatformStatsApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * Domains by state, by ADR 0024 backing, per Distributor, and created per ISO week. Weekly buckets start Monday 00:00 UTC and the window ends with the current, partial week. Cheap aggregates only: there is no game-server and no player count here.<br> OperationId: `PlatformStatsControllerDomains`
+         * @summary Platform-wide Domain statistics
+         * @param {number} [weeks]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async platformStatsControllerDomains(weeks, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.platformStatsControllerDomains(weeks, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['PlatformStatsApi.platformStatsControllerDomains']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    };
+};
+/**
+ * PlatformStatsApi - factory interface
+ * @export
+ */
+export const PlatformStatsApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = PlatformStatsApiFp(configuration);
+    return {
+        /**
+         * Domains by state, by ADR 0024 backing, per Distributor, and created per ISO week. Weekly buckets start Monday 00:00 UTC and the window ends with the current, partial week. Cheap aggregates only: there is no game-server and no player count here.<br> OperationId: `PlatformStatsControllerDomains`
+         * @summary Platform-wide Domain statistics
+         * @param {number} [weeks]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        platformStatsControllerDomains(weeks, options) {
+            return localVarFp.platformStatsControllerDomains(weeks, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * PlatformStatsApi - object-oriented interface
+ * @export
+ * @class PlatformStatsApi
+ * @extends {BaseAPI}
+ */
+export class PlatformStatsApi extends BaseAPI {
+    /**
+     * Domains by state, by ADR 0024 backing, per Distributor, and created per ISO week. Weekly buckets start Monday 00:00 UTC and the window ends with the current, partial week. Cheap aggregates only: there is no game-server and no player count here.<br> OperationId: `PlatformStatsControllerDomains`
+     * @summary Platform-wide Domain statistics
+     * @param {number} [weeks]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PlatformStatsApi
+     */
+    platformStatsControllerDomains(weeks, options) {
+        return PlatformStatsApiFp(this.configuration)
+            .platformStatsControllerDomains(weeks, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+}
+/**
+ * StaffAuthApi - axios parameter creator
+ * @export
+ */
+export const StaffAuthApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * <br> OperationId: `StaffAuthControllerCallback`
+         * @summary Callback
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffAuthControllerCallback: async (options = {}) => {
+            const localVarPath = `/auth/callback`;
+            // 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: `StaffAuthControllerLogin`
+         * @summary Login
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffAuthControllerLogin: async (options = {}) => {
+            const localVarPath = `/auth/login`;
+            // 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: `StaffAuthControllerLogout`
+         * @summary Logout
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffAuthControllerLogout: async (options = {}) => {
+            const localVarPath = `/auth/logout`;
+            // 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,
+            };
+        },
+    };
+};
+/**
+ * StaffAuthApi - functional programming interface
+ * @export
+ */
+export const StaffAuthApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffAuthApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * <br> OperationId: `StaffAuthControllerCallback`
+         * @summary Callback
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffAuthControllerCallback(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffAuthControllerCallback(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffAuthApi.staffAuthControllerCallback']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `StaffAuthControllerLogin`
+         * @summary Login
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffAuthControllerLogin(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffAuthControllerLogin(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffAuthApi.staffAuthControllerLogin']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * <br> OperationId: `StaffAuthControllerLogout`
+         * @summary Logout
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffAuthControllerLogout(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffAuthControllerLogout(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffAuthApi.staffAuthControllerLogout']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    };
+};
+/**
+ * StaffAuthApi - factory interface
+ * @export
+ */
+export const StaffAuthApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = StaffAuthApiFp(configuration);
+    return {
+        /**
+         * <br> OperationId: `StaffAuthControllerCallback`
+         * @summary Callback
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffAuthControllerCallback(options) {
+            return localVarFp.staffAuthControllerCallback(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `StaffAuthControllerLogin`
+         * @summary Login
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffAuthControllerLogin(options) {
+            return localVarFp.staffAuthControllerLogin(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * <br> OperationId: `StaffAuthControllerLogout`
+         * @summary Logout
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffAuthControllerLogout(options) {
+            return localVarFp.staffAuthControllerLogout(options).then((request) => request(axios, basePath));
+        },
+    };
+};
+/**
+ * StaffAuthApi - object-oriented interface
+ * @export
+ * @class StaffAuthApi
+ * @extends {BaseAPI}
+ */
+export class StaffAuthApi extends BaseAPI {
+    /**
+     * <br> OperationId: `StaffAuthControllerCallback`
+     * @summary Callback
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffAuthApi
+     */
+    staffAuthControllerCallback(options) {
+        return StaffAuthApiFp(this.configuration)
+            .staffAuthControllerCallback(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `StaffAuthControllerLogin`
+     * @summary Login
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffAuthApi
+     */
+    staffAuthControllerLogin(options) {
+        return StaffAuthApiFp(this.configuration)
+            .staffAuthControllerLogin(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * <br> OperationId: `StaffAuthControllerLogout`
+     * @summary Logout
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffAuthApi
+     */
+    staffAuthControllerLogout(options) {
+        return StaffAuthApiFp(this.configuration)
+            .staffAuthControllerLogout(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+}
+/**
+ * StaffDomainLimitsApi - axios parameter creator
+ * @export
+ */
+export const StaffDomainLimitsApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * The Plan’s value applies again at once.<br> OperationId: `StaffDomainLimitsControllerClear`
+         * @summary Clear a limit override of a Domain
+         * @param {string} id
+         * @param {string} limitKey
+         * @param {DomainLimitOverrideClearInputDTO} [domainLimitOverrideClearInputDTO] DomainLimitOverrideClearInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffDomainLimitsControllerClear: async (id, limitKey, domainLimitOverrideClearInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffDomainLimitsControllerClear', 'id', id);
+            // verify required parameter 'limitKey' is not null or undefined
+            assertParamExists('staffDomainLimitsControllerClear', 'limitKey', limitKey);
+            const localVarPath = `/staff/domains/{id}/limits/{limitKey}`
+                .replace(`{${'id'}}`, encodeURIComponent(String(id)))
+                .replace(`{${'limitKey'}}`, encodeURIComponent(String(limitKey)));
+            // 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(domainLimitOverrideClearInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Every limit with its value and source: the Plan, an override, or `unmanaged` for a Domain with no Plan.<br> OperationId: `StaffDomainLimitsControllerGet`
+         * @summary Effective limits of a Domain
+         * @param {string} id
          * @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);
+        staffDomainLimitsControllerGet: async (id, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffDomainLimitsControllerGet', 'id', id);
+            const localVarPath = `/staff/domains/{id}/limits`.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,
+            };
         },
         /**
-         * <br> OperationId: `MetaGetReadiness`
-         * @summary Get readiness
+         * Newest first.<br> OperationId: `StaffDomainLimitsControllerHistory`
+         * @summary Limit override history of a Domain
+         * @param {string} id
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async metaGetReadiness(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetReadiness(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetReadiness']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        staffDomainLimitsControllerHistory: async (id, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffDomainLimitsControllerHistory', 'id', id);
+            const localVarPath = `/staff/domains/{id}/limits/history`.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,
+            };
         },
         /**
-         * <br> OperationId: `MetaGetRoot`
-         * @summary Get root
+         * Applies at once and survives Plan changes, until it expires or is cleared. Only for a Domain on a Plan. Shrinking `maxGameservers` disables the newest excess servers. An expired override reads as the Plan value at once, but the enforced limit follows at the next hourly sweep, so up to an hour later.<br> OperationId: `StaffDomainLimitsControllerSet`
+         * @summary Override one limit of a Domain
+         * @param {string} id
+         * @param {string} limitKey
+         * @param {DomainLimitOverrideInputDTO} [domainLimitOverrideInputDTO] DomainLimitOverrideInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async metaGetRoot(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.metaGetRoot(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['MetaApi.metaGetRoot']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        staffDomainLimitsControllerSet: async (id, limitKey, domainLimitOverrideInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffDomainLimitsControllerSet', 'id', id);
+            // verify required parameter 'limitKey' is not null or undefined
+            assertParamExists('staffDomainLimitsControllerSet', 'limitKey', limitKey);
+            const localVarPath = `/staff/domains/{id}/limits/{limitKey}`
+                .replace(`{${'id'}}`, encodeURIComponent(String(id)))
+                .replace(`{${'limitKey'}}`, encodeURIComponent(String(limitKey)));
+            // 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(domainLimitOverrideInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
         },
     };
 };
 /**
- * MetaApi - factory interface
+ * StaffDomainLimitsApi - functional programming interface
  * @export
  */
-export const MetaApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = MetaApiFp(configuration);
+export const StaffDomainLimitsApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffDomainLimitsApiAxiosParamCreator(configuration);
     return {
         /**
-         * <br> OperationId: `MetaGetHealth`
-         * @summary Get health
+         * The Plan’s value applies again at once.<br> OperationId: `StaffDomainLimitsControllerClear`
+         * @summary Clear a limit override of a Domain
+         * @param {string} id
+         * @param {string} limitKey
+         * @param {DomainLimitOverrideClearInputDTO} [domainLimitOverrideClearInputDTO] DomainLimitOverrideClearInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetHealth(options) {
-            return localVarFp.metaGetHealth(options).then((request) => request(axios, basePath));
+        async staffDomainLimitsControllerClear(id, limitKey, domainLimitOverrideClearInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffDomainLimitsControllerClear(id, limitKey, domainLimitOverrideClearInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffDomainLimitsApi.staffDomainLimitsControllerClear']?.[localVarOperationServerIndex]
+                ?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <br> OperationId: `MetaGetLiveness`
-         * @summary Get liveness
+         * Every limit with its value and source: the Plan, an override, or `unmanaged` for a Domain with no Plan.<br> OperationId: `StaffDomainLimitsControllerGet`
+         * @summary Effective limits of a Domain
+         * @param {string} id
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetLiveness(options) {
-            return localVarFp.metaGetLiveness(options).then((request) => request(axios, basePath));
+        async staffDomainLimitsControllerGet(id, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffDomainLimitsControllerGet(id, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffDomainLimitsApi.staffDomainLimitsControllerGet']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <br> OperationId: `MetaGetMetrics`
-         * @summary Get metrics
+         * Newest first.<br> OperationId: `StaffDomainLimitsControllerHistory`
+         * @summary Limit override history of a Domain
+         * @param {string} id
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetMetrics(options) {
-            return localVarFp.metaGetMetrics(options).then((request) => request(axios, basePath));
+        async staffDomainLimitsControllerHistory(id, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffDomainLimitsControllerHistory(id, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffDomainLimitsApi.staffDomainLimitsControllerHistory']?.[localVarOperationServerIndex]
+                ?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <br> OperationId: `MetaGetOpenApi`
-         * @summary Get open api
+         * Applies at once and survives Plan changes, until it expires or is cleared. Only for a Domain on a Plan. Shrinking `maxGameservers` disables the newest excess servers. An expired override reads as the Plan value at once, but the enforced limit follows at the next hourly sweep, so up to an hour later.<br> OperationId: `StaffDomainLimitsControllerSet`
+         * @summary Override one limit of a Domain
+         * @param {string} id
+         * @param {string} limitKey
+         * @param {DomainLimitOverrideInputDTO} [domainLimitOverrideInputDTO] DomainLimitOverrideInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetOpenApi(options) {
-            return localVarFp.metaGetOpenApi(options).then((request) => request(axios, basePath));
+        async staffDomainLimitsControllerSet(id, limitKey, domainLimitOverrideInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffDomainLimitsControllerSet(id, limitKey, domainLimitOverrideInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffDomainLimitsApi.staffDomainLimitsControllerSet']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+    };
+};
+/**
+ * StaffDomainLimitsApi - factory interface
+ * @export
+ */
+export const StaffDomainLimitsApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = StaffDomainLimitsApiFp(configuration);
+    return {
         /**
-         * <br> OperationId: `MetaGetOpenApiHtml`
-         * @summary Get open api html
+         * The Plan’s value applies again at once.<br> OperationId: `StaffDomainLimitsControllerClear`
+         * @summary Clear a limit override of a Domain
+         * @param {string} id
+         * @param {string} limitKey
+         * @param {DomainLimitOverrideClearInputDTO} [domainLimitOverrideClearInputDTO] DomainLimitOverrideClearInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetOpenApiHtml(options) {
-            return localVarFp.metaGetOpenApiHtml(options).then((request) => request(axios, basePath));
+        staffDomainLimitsControllerClear(id, limitKey, domainLimitOverrideClearInputDTO, options) {
+            return localVarFp
+                .staffDomainLimitsControllerClear(id, limitKey, domainLimitOverrideClearInputDTO, options)
+                .then((request) => request(axios, basePath));
         },
         /**
-         * <br> OperationId: `MetaGetReadiness`
-         * @summary Get readiness
+         * Every limit with its value and source: the Plan, an override, or `unmanaged` for a Domain with no Plan.<br> OperationId: `StaffDomainLimitsControllerGet`
+         * @summary Effective limits of a Domain
+         * @param {string} id
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetReadiness(options) {
-            return localVarFp.metaGetReadiness(options).then((request) => request(axios, basePath));
+        staffDomainLimitsControllerGet(id, options) {
+            return localVarFp.staffDomainLimitsControllerGet(id, options).then((request) => request(axios, basePath));
         },
         /**
-         * <br> OperationId: `MetaGetRoot`
-         * @summary Get root
+         * Newest first.<br> OperationId: `StaffDomainLimitsControllerHistory`
+         * @summary Limit override history of a Domain
+         * @param {string} id
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        metaGetRoot(options) {
-            return localVarFp.metaGetRoot(options).then((request) => request(axios, basePath));
+        staffDomainLimitsControllerHistory(id, options) {
+            return localVarFp.staffDomainLimitsControllerHistory(id, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Applies at once and survives Plan changes, until it expires or is cleared. Only for a Domain on a Plan. Shrinking `maxGameservers` disables the newest excess servers. An expired override reads as the Plan value at once, but the enforced limit follows at the next hourly sweep, so up to an hour later.<br> OperationId: `StaffDomainLimitsControllerSet`
+         * @summary Override one limit of a Domain
+         * @param {string} id
+         * @param {string} limitKey
+         * @param {DomainLimitOverrideInputDTO} [domainLimitOverrideInputDTO] DomainLimitOverrideInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffDomainLimitsControllerSet(id, limitKey, domainLimitOverrideInputDTO, options) {
+            return localVarFp
+                .staffDomainLimitsControllerSet(id, limitKey, domainLimitOverrideInputDTO, options)
+                .then((request) => request(axios, basePath));
         },
     };
 };
 /**
- * MetaApi - object-oriented interface
+ * StaffDomainLimitsApi - object-oriented interface
  * @export
- * @class MetaApi
+ * @class StaffDomainLimitsApi
  * @extends {BaseAPI}
  */
-export class MetaApi extends BaseAPI {
-    /**
-     * <br> OperationId: `MetaGetHealth`
-     * @summary Get health
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MetaApi
-     */
-    metaGetHealth(options) {
-        return MetaApiFp(this.configuration)
-            .metaGetHealth(options)
-            .then((request) => request(this.axios, this.basePath));
-    }
-    /**
-     * <br> OperationId: `MetaGetLiveness`
-     * @summary Get liveness
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof MetaApi
-     */
-    metaGetLiveness(options) {
-        return MetaApiFp(this.configuration)
-            .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));
-    }
+export class StaffDomainLimitsApi extends BaseAPI {
     /**
-     * <br> OperationId: `MetaGetOpenApi`
-     * @summary Get open api
+     * The Plan’s value applies again at once.<br> OperationId: `StaffDomainLimitsControllerClear`
+     * @summary Clear a limit override of a Domain
+     * @param {string} id
+     * @param {string} limitKey
+     * @param {DomainLimitOverrideClearInputDTO} [domainLimitOverrideClearInputDTO] DomainLimitOverrideClearInputDTO
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof MetaApi
+     * @memberof StaffDomainLimitsApi
      */
-    metaGetOpenApi(options) {
-        return MetaApiFp(this.configuration)
-            .metaGetOpenApi(options)
+    staffDomainLimitsControllerClear(id, limitKey, domainLimitOverrideClearInputDTO, options) {
+        return StaffDomainLimitsApiFp(this.configuration)
+            .staffDomainLimitsControllerClear(id, limitKey, domainLimitOverrideClearInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
     /**
-     * <br> OperationId: `MetaGetOpenApiHtml`
-     * @summary Get open api html
+     * Every limit with its value and source: the Plan, an override, or `unmanaged` for a Domain with no Plan.<br> OperationId: `StaffDomainLimitsControllerGet`
+     * @summary Effective limits of a Domain
+     * @param {string} id
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof MetaApi
+     * @memberof StaffDomainLimitsApi
      */
-    metaGetOpenApiHtml(options) {
-        return MetaApiFp(this.configuration)
-            .metaGetOpenApiHtml(options)
+    staffDomainLimitsControllerGet(id, options) {
+        return StaffDomainLimitsApiFp(this.configuration)
+            .staffDomainLimitsControllerGet(id, options)
             .then((request) => request(this.axios, this.basePath));
     }
     /**
-     * <br> OperationId: `MetaGetReadiness`
-     * @summary Get readiness
+     * Newest first.<br> OperationId: `StaffDomainLimitsControllerHistory`
+     * @summary Limit override history of a Domain
+     * @param {string} id
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof MetaApi
+     * @memberof StaffDomainLimitsApi
      */
-    metaGetReadiness(options) {
-        return MetaApiFp(this.configuration)
-            .metaGetReadiness(options)
+    staffDomainLimitsControllerHistory(id, options) {
+        return StaffDomainLimitsApiFp(this.configuration)
+            .staffDomainLimitsControllerHistory(id, options)
             .then((request) => request(this.axios, this.basePath));
     }
     /**
-     * <br> OperationId: `MetaGetRoot`
-     * @summary Get root
+     * Applies at once and survives Plan changes, until it expires or is cleared. Only for a Domain on a Plan. Shrinking `maxGameservers` disables the newest excess servers. An expired override reads as the Plan value at once, but the enforced limit follows at the next hourly sweep, so up to an hour later.<br> OperationId: `StaffDomainLimitsControllerSet`
+     * @summary Override one limit of a Domain
+     * @param {string} id
+     * @param {string} limitKey
+     * @param {DomainLimitOverrideInputDTO} [domainLimitOverrideInputDTO] DomainLimitOverrideInputDTO
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof MetaApi
+     * @memberof StaffDomainLimitsApi
      */
-    metaGetRoot(options) {
-        return MetaApiFp(this.configuration)
-            .metaGetRoot(options)
+    staffDomainLimitsControllerSet(id, limitKey, domainLimitOverrideInputDTO, options) {
+        return StaffDomainLimitsApiFp(this.configuration)
+            .staffDomainLimitsControllerSet(id, limitKey, domainLimitOverrideInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
 }
 /**
- * PlatformStatsApi - axios parameter creator
+ * StaffMeApi - axios parameter creator
  * @export
  */
-export const PlatformStatsApiAxiosParamCreator = function (configuration) {
+export const StaffMeApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * Domains by state, by ADR 0024 backing, per Distributor, and created per ISO week. Weekly buckets start Monday 00:00 UTC and the window ends with the current, partial week. Cheap aggregates only: there is no game-server and no player count here.<br> OperationId: `PlatformStatsControllerDomains`
-         * @summary Platform-wide Domain statistics
-         * @param {number} [weeks]
+         * 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}
          */
-        platformStatsControllerDomains: async (weeks, options = {}) => {
-            const localVarPath = `/staff/stats/domains`;
+        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;
@@ -3614,9 +5581,6 @@ export const PlatformStatsApiAxiosParamCreator = function (configuration) {
             // authentication staffSession required
             // authentication adminAuth required
             await setApiKeyToObject(localVarHeaderParameter, 'x-takaro-admin-token', configuration);
-            if (weeks !== undefined) {
-                localVarQueryParameter['weeks'] = weeks;
-            }
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
@@ -3628,81 +5592,146 @@ export const PlatformStatsApiAxiosParamCreator = function (configuration) {
     };
 };
 /**
- * PlatformStatsApi - functional programming interface
+ * StaffMeApi - functional programming interface
  * @export
  */
-export const PlatformStatsApiFp = function (configuration) {
-    const localVarAxiosParamCreator = PlatformStatsApiAxiosParamCreator(configuration);
+export const StaffMeApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffMeApiAxiosParamCreator(configuration);
     return {
         /**
-         * Domains by state, by ADR 0024 backing, per Distributor, and created per ISO week. Weekly buckets start Monday 00:00 UTC and the window ends with the current, partial week. Cheap aggregates only: there is no game-server and no player count here.<br> OperationId: `PlatformStatsControllerDomains`
-         * @summary Platform-wide Domain statistics
-         * @param {number} [weeks]
+         * 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 platformStatsControllerDomains(weeks, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.platformStatsControllerDomains(weeks, options);
+        async staffMeControllerMe(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffMeControllerMe(options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['PlatformStatsApi.platformStatsControllerDomains']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StaffMeApi.staffMeControllerMe']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
 /**
- * PlatformStatsApi - factory interface
+ * StaffMeApi - factory interface
  * @export
  */
-export const PlatformStatsApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = PlatformStatsApiFp(configuration);
+export const StaffMeApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = StaffMeApiFp(configuration);
     return {
         /**
-         * Domains by state, by ADR 0024 backing, per Distributor, and created per ISO week. Weekly buckets start Monday 00:00 UTC and the window ends with the current, partial week. Cheap aggregates only: there is no game-server and no player count here.<br> OperationId: `PlatformStatsControllerDomains`
-         * @summary Platform-wide Domain statistics
-         * @param {number} [weeks]
+         * 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}
          */
-        platformStatsControllerDomains(weeks, options) {
-            return localVarFp.platformStatsControllerDomains(weeks, options).then((request) => request(axios, basePath));
+        staffMeControllerMe(options) {
+            return localVarFp.staffMeControllerMe(options).then((request) => request(axios, basePath));
         },
     };
 };
 /**
- * PlatformStatsApi - object-oriented interface
+ * StaffMeApi - object-oriented interface
  * @export
- * @class PlatformStatsApi
+ * @class StaffMeApi
  * @extends {BaseAPI}
  */
-export class PlatformStatsApi extends BaseAPI {
+export class StaffMeApi extends BaseAPI {
     /**
-     * Domains by state, by ADR 0024 backing, per Distributor, and created per ISO week. Weekly buckets start Monday 00:00 UTC and the window ends with the current, partial week. Cheap aggregates only: there is no game-server and no player count here.<br> OperationId: `PlatformStatsControllerDomains`
-     * @summary Platform-wide Domain statistics
-     * @param {number} [weeks]
+     * 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 PlatformStatsApi
+     * @memberof StaffMeApi
      */
-    platformStatsControllerDomains(weeks, options) {
-        return PlatformStatsApiFp(this.configuration)
-            .platformStatsControllerDomains(weeks, options)
+    staffMeControllerMe(options) {
+        return StaffMeApiFp(this.configuration)
+            .staffMeControllerMe(options)
             .then((request) => request(this.axios, this.basePath));
     }
 }
 /**
- * StaffAuthApi - axios parameter creator
+ * StaffPlanApi - axios parameter creator
  * @export
  */
-export const StaffAuthApiAxiosParamCreator = function (configuration) {
+export const StaffPlanApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * <br> OperationId: `StaffAuthControllerCallback`
-         * @summary Callback
+         * Refused while any Domain is on the Plan or any Distributor allows it. Frees its billing-provider product for another Plan; the history keeps the old link. Idempotent.<br> OperationId: `StaffPlanControllerArchive`
+         * @summary Archive a Plan
+         * @param {string} id
+         * @param {PlanArchiveInputDTO} [planArchiveInputDTO] PlanArchiveInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffAuthControllerCallback: async (options = {}) => {
-            const localVarPath = `/auth/callback`;
+        staffPlanControllerArchive: async (id, planArchiveInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffPlanControllerArchive', 'id', id);
+            const localVarPath = `/staff/plans/{id}/archive`.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: 'POST', ...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(planArchiveInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Omitted limits take the Domain column defaults. Recorded with who, when and the reason.<br> OperationId: `StaffPlanControllerCreate`
+         * @summary Create a Plan
+         * @param {PlanCreateInputDTO} [planCreateInputDTO] PlanCreateInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerCreate: async (planCreateInputDTO, 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: 'POST', ...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(planCreateInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Newest first, each with the Plan as it was after.<br> OperationId: `StaffPlanControllerHistory`
+         * @summary Change history of a Plan
+         * @param {string} id
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerHistory: async (id, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffPlanControllerHistory', 'id', id);
+            const localVarPath = `/staff/plans/{id}/history`.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;
@@ -3712,6 +5741,9 @@ export const StaffAuthApiAxiosParamCreator = function (configuration) {
             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 };
@@ -3721,13 +5753,106 @@ export const StaffAuthApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * <br> OperationId: `StaffAuthControllerLogin`
-         * @summary Login
+         * Creates a Plan per billing-provider product in one transaction; a no-op once any import was recorded. Domains and Distributors still on a legacy product id move to its Plan, and a Domain that predates Plans keeps its hand-set limits as overrides. A product already linked to a Plan maps to that Plan instead.<br> OperationId: `StaffPlanControllerImport`
+         * @summary Import Plans from the billing provider
+         * @param {PlanImportInputDTO} [planImportInputDTO] PlanImportInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffAuthControllerLogin: async (options = {}) => {
-            const localVarPath = `/auth/login`;
+        staffPlanControllerImport: async (planImportInputDTO, options = {}) => {
+            const localVarPath = `/staff/plans/import`;
+            // 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 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(planImportInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * True once an import has created any Plan, even if those Plans were later unlinked or archived.<br> OperationId: `StaffPlanControllerImportStatus`
+         * @summary Whether the billing-provider import ran
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerImportStatus: async (options = {}) => {
+            const localVarPath = `/staff/plans/import`;
+            // 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,
+            };
+        },
+        /**
+         * Every Takaro Plan, oldest first. Archived Plans only with `includeArchived=true`. The ids here are what a Distributor’s allowedPlans and a Domain’s planId hold.<br> OperationId: `StaffPlanControllerList`
+         * @summary List Plans
+         * @param {any} [includeArchived]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerList: async (includeArchived, 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);
+            if (includeArchived !== undefined) {
+                for (const [key, value] of Object.entries(includeArchived)) {
+                    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,
+            };
+        },
+        /**
+         * Every product the billing provider knows about, with its prices, unfiltered by storefront lookup keys. A Plan’s stripeProductId is one of these ids.<br> OperationId: `StaffPlanControllerListStripeProducts`
+         * @summary The billing provider’s products
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerListStripeProducts: async (options = {}) => {
+            const localVarPath = `/staff/stripe-products`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -3737,34 +5862,80 @@ export const StaffAuthApiAxiosParamCreator = function (configuration) {
             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,
+            };
+        },
+        /**
+         * A dry run of the proposed limits: how many Domains change, how many game servers would be disabled, and how many Domains would be over their user or role limits. Overrides are taken into account.<br> OperationId: `StaffPlanControllerPreview`
+         * @summary Preview a Plan edit
+         * @param {string} id
+         * @param {PlanPreviewInputDTO} [planPreviewInputDTO] PlanPreviewInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerPreview: async (id, planPreviewInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffPlanControllerPreview', 'id', id);
+            const localVarPath = `/staff/plans/{id}/preview`.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: 'POST', ...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(planPreviewInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
             };
         },
         /**
-         * <br> OperationId: `StaffAuthControllerLogout`
-         * @summary Logout
+         * Changed limits reach every Domain on the Plan shortly after, through a queued job. A shrink of `maxGameservers` disables the newest excess servers; preview it first. Changing or removing the billing-provider product is refused with a 409 while a subscription-backed Domain is on the Plan.<br> OperationId: `StaffPlanControllerUpdate`
+         * @summary Update a Plan
+         * @param {string} id
+         * @param {PlanUpdateInputDTO} [planUpdateInputDTO] PlanUpdateInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffAuthControllerLogout: async (options = {}) => {
-            const localVarPath = `/auth/logout`;
+        staffPlanControllerUpdate: async (id, planUpdateInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('staffPlanControllerUpdate', 'id', id);
+            const localVarPath = `/staff/plans/{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 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(planUpdateInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -3773,144 +5944,447 @@ export const StaffAuthApiAxiosParamCreator = function (configuration) {
     };
 };
 /**
- * StaffAuthApi - functional programming interface
+ * StaffPlanApi - functional programming interface
  * @export
  */
-export const StaffAuthApiFp = function (configuration) {
-    const localVarAxiosParamCreator = StaffAuthApiAxiosParamCreator(configuration);
+export const StaffPlanApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffPlanApiAxiosParamCreator(configuration);
     return {
         /**
-         * <br> OperationId: `StaffAuthControllerCallback`
-         * @summary Callback
+         * Refused while any Domain is on the Plan or any Distributor allows it. Frees its billing-provider product for another Plan; the history keeps the old link. Idempotent.<br> OperationId: `StaffPlanControllerArchive`
+         * @summary Archive a Plan
+         * @param {string} id
+         * @param {PlanArchiveInputDTO} [planArchiveInputDTO] PlanArchiveInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async staffAuthControllerCallback(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.staffAuthControllerCallback(options);
+        async staffPlanControllerArchive(id, planArchiveInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerArchive(id, planArchiveInputDTO, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StaffAuthApi.staffAuthControllerCallback']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerArchive']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <br> OperationId: `StaffAuthControllerLogin`
-         * @summary Login
+         * Omitted limits take the Domain column defaults. Recorded with who, when and the reason.<br> OperationId: `StaffPlanControllerCreate`
+         * @summary Create a Plan
+         * @param {PlanCreateInputDTO} [planCreateInputDTO] PlanCreateInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async staffAuthControllerLogin(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.staffAuthControllerLogin(options);
+        async staffPlanControllerCreate(planCreateInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerCreate(planCreateInputDTO, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StaffAuthApi.staffAuthControllerLogin']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerCreate']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * <br> OperationId: `StaffAuthControllerLogout`
-         * @summary Logout
+         * Newest first, each with the Plan as it was after.<br> OperationId: `StaffPlanControllerHistory`
+         * @summary Change history of a Plan
+         * @param {string} id
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async staffAuthControllerLogout(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.staffAuthControllerLogout(options);
+        async staffPlanControllerHistory(id, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerHistory(id, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StaffAuthApi.staffAuthControllerLogout']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerHistory']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Creates a Plan per billing-provider product in one transaction; a no-op once any import was recorded. Domains and Distributors still on a legacy product id move to its Plan, and a Domain that predates Plans keeps its hand-set limits as overrides. A product already linked to a Plan maps to that Plan instead.<br> OperationId: `StaffPlanControllerImport`
+         * @summary Import Plans from the billing provider
+         * @param {PlanImportInputDTO} [planImportInputDTO] PlanImportInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffPlanControllerImport(planImportInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerImport(planImportInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerImport']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * True once an import has created any Plan, even if those Plans were later unlinked or archived.<br> OperationId: `StaffPlanControllerImportStatus`
+         * @summary Whether the billing-provider import ran
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffPlanControllerImportStatus(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerImportStatus(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerImportStatus']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Every Takaro Plan, oldest first. Archived Plans only with `includeArchived=true`. The ids here are what a Distributor’s allowedPlans and a Domain’s planId hold.<br> OperationId: `StaffPlanControllerList`
+         * @summary List Plans
+         * @param {any} [includeArchived]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffPlanControllerList(includeArchived, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerList(includeArchived, 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);
+        },
+        /**
+         * Every product the billing provider knows about, with its prices, unfiltered by storefront lookup keys. A Plan’s stripeProductId is one of these ids.<br> OperationId: `StaffPlanControllerListStripeProducts`
+         * @summary The billing provider’s products
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffPlanControllerListStripeProducts(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerListStripeProducts(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerListStripeProducts']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * A dry run of the proposed limits: how many Domains change, how many game servers would be disabled, and how many Domains would be over their user or role limits. Overrides are taken into account.<br> OperationId: `StaffPlanControllerPreview`
+         * @summary Preview a Plan edit
+         * @param {string} id
+         * @param {PlanPreviewInputDTO} [planPreviewInputDTO] PlanPreviewInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffPlanControllerPreview(id, planPreviewInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerPreview(id, planPreviewInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerPreview']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Changed limits reach every Domain on the Plan shortly after, through a queued job. A shrink of `maxGameservers` disables the newest excess servers; preview it first. Changing or removing the billing-provider product is refused with a 409 while a subscription-backed Domain is on the Plan.<br> OperationId: `StaffPlanControllerUpdate`
+         * @summary Update a Plan
+         * @param {string} id
+         * @param {PlanUpdateInputDTO} [planUpdateInputDTO] PlanUpdateInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async staffPlanControllerUpdate(id, planUpdateInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerUpdate(id, planUpdateInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerUpdate']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
 /**
- * StaffAuthApi - factory interface
+ * StaffPlanApi - factory interface
  * @export
  */
-export const StaffAuthApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = StaffAuthApiFp(configuration);
+export const StaffPlanApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = StaffPlanApiFp(configuration);
     return {
         /**
-         * <br> OperationId: `StaffAuthControllerCallback`
-         * @summary Callback
+         * Refused while any Domain is on the Plan or any Distributor allows it. Frees its billing-provider product for another Plan; the history keeps the old link. Idempotent.<br> OperationId: `StaffPlanControllerArchive`
+         * @summary Archive a Plan
+         * @param {string} id
+         * @param {PlanArchiveInputDTO} [planArchiveInputDTO] PlanArchiveInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffAuthControllerCallback(options) {
-            return localVarFp.staffAuthControllerCallback(options).then((request) => request(axios, basePath));
+        staffPlanControllerArchive(id, planArchiveInputDTO, options) {
+            return localVarFp
+                .staffPlanControllerArchive(id, planArchiveInputDTO, options)
+                .then((request) => request(axios, basePath));
         },
         /**
-         * <br> OperationId: `StaffAuthControllerLogin`
-         * @summary Login
+         * Omitted limits take the Domain column defaults. Recorded with who, when and the reason.<br> OperationId: `StaffPlanControllerCreate`
+         * @summary Create a Plan
+         * @param {PlanCreateInputDTO} [planCreateInputDTO] PlanCreateInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffAuthControllerLogin(options) {
-            return localVarFp.staffAuthControllerLogin(options).then((request) => request(axios, basePath));
+        staffPlanControllerCreate(planCreateInputDTO, options) {
+            return localVarFp
+                .staffPlanControllerCreate(planCreateInputDTO, options)
+                .then((request) => request(axios, basePath));
         },
         /**
-         * <br> OperationId: `StaffAuthControllerLogout`
-         * @summary Logout
+         * Newest first, each with the Plan as it was after.<br> OperationId: `StaffPlanControllerHistory`
+         * @summary Change history of a Plan
+         * @param {string} id
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffAuthControllerLogout(options) {
-            return localVarFp.staffAuthControllerLogout(options).then((request) => request(axios, basePath));
+        staffPlanControllerHistory(id, options) {
+            return localVarFp.staffPlanControllerHistory(id, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Creates a Plan per billing-provider product in one transaction; a no-op once any import was recorded. Domains and Distributors still on a legacy product id move to its Plan, and a Domain that predates Plans keeps its hand-set limits as overrides. A product already linked to a Plan maps to that Plan instead.<br> OperationId: `StaffPlanControllerImport`
+         * @summary Import Plans from the billing provider
+         * @param {PlanImportInputDTO} [planImportInputDTO] PlanImportInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerImport(planImportInputDTO, options) {
+            return localVarFp
+                .staffPlanControllerImport(planImportInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * True once an import has created any Plan, even if those Plans were later unlinked or archived.<br> OperationId: `StaffPlanControllerImportStatus`
+         * @summary Whether the billing-provider import ran
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerImportStatus(options) {
+            return localVarFp.staffPlanControllerImportStatus(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Every Takaro Plan, oldest first. Archived Plans only with `includeArchived=true`. The ids here are what a Distributor’s allowedPlans and a Domain’s planId hold.<br> OperationId: `StaffPlanControllerList`
+         * @summary List Plans
+         * @param {any} [includeArchived]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerList(includeArchived, options) {
+            return localVarFp.staffPlanControllerList(includeArchived, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Every product the billing provider knows about, with its prices, unfiltered by storefront lookup keys. A Plan’s stripeProductId is one of these ids.<br> OperationId: `StaffPlanControllerListStripeProducts`
+         * @summary The billing provider’s products
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerListStripeProducts(options) {
+            return localVarFp.staffPlanControllerListStripeProducts(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * A dry run of the proposed limits: how many Domains change, how many game servers would be disabled, and how many Domains would be over their user or role limits. Overrides are taken into account.<br> OperationId: `StaffPlanControllerPreview`
+         * @summary Preview a Plan edit
+         * @param {string} id
+         * @param {PlanPreviewInputDTO} [planPreviewInputDTO] PlanPreviewInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerPreview(id, planPreviewInputDTO, options) {
+            return localVarFp
+                .staffPlanControllerPreview(id, planPreviewInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * Changed limits reach every Domain on the Plan shortly after, through a queued job. A shrink of `maxGameservers` disables the newest excess servers; preview it first. Changing or removing the billing-provider product is refused with a 409 while a subscription-backed Domain is on the Plan.<br> OperationId: `StaffPlanControllerUpdate`
+         * @summary Update a Plan
+         * @param {string} id
+         * @param {PlanUpdateInputDTO} [planUpdateInputDTO] PlanUpdateInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        staffPlanControllerUpdate(id, planUpdateInputDTO, options) {
+            return localVarFp
+                .staffPlanControllerUpdate(id, planUpdateInputDTO, options)
+                .then((request) => request(axios, basePath));
         },
     };
 };
 /**
- * StaffAuthApi - object-oriented interface
+ * StaffPlanApi - object-oriented interface
  * @export
- * @class StaffAuthApi
+ * @class StaffPlanApi
  * @extends {BaseAPI}
  */
-export class StaffAuthApi extends BaseAPI {
+export class StaffPlanApi extends BaseAPI {
     /**
-     * <br> OperationId: `StaffAuthControllerCallback`
-     * @summary Callback
+     * Refused while any Domain is on the Plan or any Distributor allows it. Frees its billing-provider product for another Plan; the history keeps the old link. Idempotent.<br> OperationId: `StaffPlanControllerArchive`
+     * @summary Archive a Plan
+     * @param {string} id
+     * @param {PlanArchiveInputDTO} [planArchiveInputDTO] PlanArchiveInputDTO
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StaffAuthApi
+     * @memberof StaffPlanApi
      */
-    staffAuthControllerCallback(options) {
-        return StaffAuthApiFp(this.configuration)
-            .staffAuthControllerCallback(options)
+    staffPlanControllerArchive(id, planArchiveInputDTO, options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerArchive(id, planArchiveInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
     /**
-     * <br> OperationId: `StaffAuthControllerLogin`
-     * @summary Login
+     * Omitted limits take the Domain column defaults. Recorded with who, when and the reason.<br> OperationId: `StaffPlanControllerCreate`
+     * @summary Create a Plan
+     * @param {PlanCreateInputDTO} [planCreateInputDTO] PlanCreateInputDTO
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StaffAuthApi
+     * @memberof StaffPlanApi
      */
-    staffAuthControllerLogin(options) {
-        return StaffAuthApiFp(this.configuration)
-            .staffAuthControllerLogin(options)
+    staffPlanControllerCreate(planCreateInputDTO, options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerCreate(planCreateInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
     /**
-     * <br> OperationId: `StaffAuthControllerLogout`
-     * @summary Logout
+     * Newest first, each with the Plan as it was after.<br> OperationId: `StaffPlanControllerHistory`
+     * @summary Change history of a Plan
+     * @param {string} id
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof StaffAuthApi
+     * @memberof StaffPlanApi
      */
-    staffAuthControllerLogout(options) {
-        return StaffAuthApiFp(this.configuration)
-            .staffAuthControllerLogout(options)
+    staffPlanControllerHistory(id, options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerHistory(id, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Creates a Plan per billing-provider product in one transaction; a no-op once any import was recorded. Domains and Distributors still on a legacy product id move to its Plan, and a Domain that predates Plans keeps its hand-set limits as overrides. A product already linked to a Plan maps to that Plan instead.<br> OperationId: `StaffPlanControllerImport`
+     * @summary Import Plans from the billing provider
+     * @param {PlanImportInputDTO} [planImportInputDTO] PlanImportInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffPlanApi
+     */
+    staffPlanControllerImport(planImportInputDTO, options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerImport(planImportInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * True once an import has created any Plan, even if those Plans were later unlinked or archived.<br> OperationId: `StaffPlanControllerImportStatus`
+     * @summary Whether the billing-provider import ran
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffPlanApi
+     */
+    staffPlanControllerImportStatus(options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerImportStatus(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Every Takaro Plan, oldest first. Archived Plans only with `includeArchived=true`. The ids here are what a Distributor’s allowedPlans and a Domain’s planId hold.<br> OperationId: `StaffPlanControllerList`
+     * @summary List Plans
+     * @param {any} [includeArchived]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffPlanApi
+     */
+    staffPlanControllerList(includeArchived, options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerList(includeArchived, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Every product the billing provider knows about, with its prices, unfiltered by storefront lookup keys. A Plan’s stripeProductId is one of these ids.<br> OperationId: `StaffPlanControllerListStripeProducts`
+     * @summary The billing provider’s products
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffPlanApi
+     */
+    staffPlanControllerListStripeProducts(options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerListStripeProducts(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * A dry run of the proposed limits: how many Domains change, how many game servers would be disabled, and how many Domains would be over their user or role limits. Overrides are taken into account.<br> OperationId: `StaffPlanControllerPreview`
+     * @summary Preview a Plan edit
+     * @param {string} id
+     * @param {PlanPreviewInputDTO} [planPreviewInputDTO] PlanPreviewInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffPlanApi
+     */
+    staffPlanControllerPreview(id, planPreviewInputDTO, options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerPreview(id, planPreviewInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Changed limits reach every Domain on the Plan shortly after, through a queued job. A shrink of `maxGameservers` disables the newest excess servers; preview it first. Changing or removing the billing-provider product is refused with a 409 while a subscription-backed Domain is on the Plan.<br> OperationId: `StaffPlanControllerUpdate`
+     * @summary Update a Plan
+     * @param {string} id
+     * @param {PlanUpdateInputDTO} [planUpdateInputDTO] PlanUpdateInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffPlanApi
+     */
+    staffPlanControllerUpdate(id, planUpdateInputDTO, options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerUpdate(id, planUpdateInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
 }
 /**
- * StaffMeApi - axios parameter creator
+ * StaffTakaroAiApi - axios parameter creator
  * @export
  */
-export const StaffMeApiAxiosParamCreator = function (configuration) {
+export const StaffTakaroAiApiAxiosParamCreator = 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
+         * 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 +6405,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 +6507,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}
+         */
+        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}
          */
-        staffPlanControllerList(options) {
-            return localVarFp.staffPlanControllerList(options).then((request) => request(axios, basePath));
+        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));
     }
 }