@takaro/apiclient 0.0.0-dev.65bc64c → 0.0.0-dev.65f42f9

package/dist/generated-management/api.js

@@ -59,15 +59,6 @@ export const ConnectorMigrationOutputDTOLegacyTypeEnum = {
     Generic: 'GENERIC',
     Mock: 'MOCK',
 };
-export const DistributorBackedDomainOutputDTOStateEnum = {
-    Active: 'ACTIVE',
-    Disabled: 'DISABLED',
-    Maintenance: 'MAINTENANCE',
-};
-export const DistributorBackedDomainSearchInputDTOSortDirectionEnum = {
-    Asc: 'asc',
-    Desc: 'desc',
-};
 export const DistributorDomainSearchInputAllowedFiltersStateEnum = {
     Active: 'ACTIVE',
     Disabled: 'DISABLED',
@@ -98,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',
@@ -164,6 +170,7 @@ export const EventCreateDTOEventNameEnum = {
     SettingsSet: 'settings-set',
     PlayerNewIpDetected: 'player-new-ip-detected',
     PlayerNewNameDetected: 'player-new-name-detected',
+    PlayerIdentityConflict: 'player-identity-conflict',
     ServerStatusChanged: 'server-status-changed',
     ModuleCreated: 'module-created',
     ModuleUpdated: 'module-updated',
@@ -178,8 +185,11 @@ export const EventCreateDTOEventNameEnum = {
     ShopOrderStatusChanged: 'shop-order-status-changed',
     ShopOrderDeliveryFailed: 'shop-order-delivery-failed',
     PlayerLinked: 'player-linked',
+    PlayerUnlinked: 'player-unlinked',
+    PlayerMerged: 'player-merged',
     GameserverCreated: 'gameserver-created',
     GameserverUpdated: 'gameserver-updated',
+    GameserverVersionChanged: 'gameserver-version-changed',
     GameserverDeleted: 'gameserver-deleted',
     PlayerBanned: 'player-banned',
     PlayerUnbanned: 'player-unbanned',
@@ -207,6 +217,15 @@ export const EventCreateDTOEventNameEnum = {
     PlayerDeath: 'player-death',
     EntityKilled: 'entity-killed',
 };
+export const EventInventoryChangedCauseEnum = {
+    Pickup: 'pickup',
+    Drop: 'drop',
+    Craft: 'craft',
+    Loot: 'loot',
+    Trade: 'trade',
+    Death: 'death',
+    Other: 'other',
+};
 export const EventOutputDTOEventNameEnum = {
     RoleAssigned: 'role-assigned',
     RoleRemoved: 'role-removed',
@@ -223,6 +242,7 @@ export const EventOutputDTOEventNameEnum = {
     SettingsSet: 'settings-set',
     PlayerNewIpDetected: 'player-new-ip-detected',
     PlayerNewNameDetected: 'player-new-name-detected',
+    PlayerIdentityConflict: 'player-identity-conflict',
     ServerStatusChanged: 'server-status-changed',
     ModuleCreated: 'module-created',
     ModuleUpdated: 'module-updated',
@@ -237,8 +257,11 @@ export const EventOutputDTOEventNameEnum = {
     ShopOrderStatusChanged: 'shop-order-status-changed',
     ShopOrderDeliveryFailed: 'shop-order-delivery-failed',
     PlayerLinked: 'player-linked',
+    PlayerUnlinked: 'player-unlinked',
+    PlayerMerged: 'player-merged',
     GameserverCreated: 'gameserver-created',
     GameserverUpdated: 'gameserver-updated',
+    GameserverVersionChanged: 'gameserver-version-changed',
     GameserverDeleted: 'gameserver-deleted',
     PlayerBanned: 'player-banned',
     PlayerUnbanned: 'player-unbanned',
@@ -273,6 +296,7 @@ export const FixtureHistoryConflictDTOKindEnum = {
 export const FixtureHistoryDeleteInputDTOStoreEnum = {
     Analytics: 'analytics',
     Postgres: 'postgres',
+    Tracking: 'tracking',
 };
 export const FixtureHistoryEventDTOEventNameEnum = {
     PlayerConnected: 'player-connected',
@@ -291,18 +315,44 @@ export const FixtureHistoryOrderDTOStatusEnum = {
     Completed: 'COMPLETED',
     Canceled: 'CANCELED',
 };
+export const FixtureHistoryTrackingChangeDTOChangeTypeEnum = {
+    Added: 'added',
+    Removed: 'removed',
+    Changed: 'changed',
+};
+export const FixtureHistoryTrackingChangeDTOCauseEnum = {
+    Pickup: 'pickup',
+    Drop: 'drop',
+    Craft: 'craft',
+    Loot: 'loot',
+    Trade: 'trade',
+    Death: 'death',
+    Other: 'other',
+};
 export const GameServerCreateDTOTypeEnum = {
     Sevendaystodie: 'SEVENDAYSTODIE',
     Rust: 'RUST',
     Generic: 'GENERIC',
     Mock: 'MOCK',
 };
+export const GameServerCreateDTONameSourceEnum = {
+    Connector: 'connector',
+    Operator: 'operator',
+};
+export const GameServerIdentifyInputDTOProtocolVersionEnum = {
+    NUMBER_0: 0,
+    NUMBER_1: 1,
+};
 export const GameServerOutputDTOTypeEnum = {
     Sevendaystodie: 'SEVENDAYSTODIE',
     Rust: 'RUST',
     Generic: 'GENERIC',
     Mock: 'MOCK',
 };
+export const GameServerOutputDTONameSourceEnum = {
+    Connector: 'connector',
+    Operator: 'operator',
+};
 export const GameServerTypesOutputDTOTypeEnum = {
     Sevendaystodie: 'SEVENDAYSTODIE',
     Rust: 'RUST',
@@ -325,14 +375,17 @@ export const GetJobInputDTOTypeEnum = {
     SyncItems: 'syncItems',
     SyncEntities: 'syncEntities',
     SyncBans: 'syncBans',
+    SyncLocations: 'syncLocations',
     SyncMapImages: 'syncMapImages',
     SyncMapUploads: 'syncMapUploads',
+    SyncGameIcons: 'syncGameIcons',
     SyncSteam: 'syncSteam',
     SyncDiscordRoles: 'syncDiscordRoles',
     EmitRateLimitSummary: 'emitRateLimitSummary',
     CleanRevokedApiKeys: 'cleanRevokedApiKeys',
     CleanExecutionClaims: 'cleanExecutionClaims',
     DeleteClickHouseEvents: 'deleteClickHouseEvents',
+    RepointClickHouseEvents: 'repointClickHouseEvents',
     CleanConnectorMigrations: 'cleanConnectorMigrations',
 };
 export const HookCreateDTOEventTypeEnum = {
@@ -358,6 +411,7 @@ export const HookCreateDTOEventTypeEnum = {
     SettingsSet: 'settings-set',
     PlayerNewIpDetected: 'player-new-ip-detected',
     PlayerNewNameDetected: 'player-new-name-detected',
+    PlayerIdentityConflict: 'player-identity-conflict',
     ServerStatusChanged: 'server-status-changed',
     ModuleCreated: 'module-created',
     ModuleUpdated: 'module-updated',
@@ -372,8 +426,11 @@ export const HookCreateDTOEventTypeEnum = {
     ShopOrderStatusChanged: 'shop-order-status-changed',
     ShopOrderDeliveryFailed: 'shop-order-delivery-failed',
     PlayerLinked: 'player-linked',
+    PlayerUnlinked: 'player-unlinked',
+    PlayerMerged: 'player-merged',
     GameserverCreated: 'gameserver-created',
     GameserverUpdated: 'gameserver-updated',
+    GameserverVersionChanged: 'gameserver-version-changed',
     GameserverDeleted: 'gameserver-deleted',
     PlayerBanned: 'player-banned',
     PlayerUnbanned: 'player-unbanned',
@@ -419,6 +476,7 @@ export const HookOutputDTOEventTypeEnum = {
     SettingsSet: 'settings-set',
     PlayerNewIpDetected: 'player-new-ip-detected',
     PlayerNewNameDetected: 'player-new-name-detected',
+    PlayerIdentityConflict: 'player-identity-conflict',
     ServerStatusChanged: 'server-status-changed',
     ModuleCreated: 'module-created',
     ModuleUpdated: 'module-updated',
@@ -433,8 +491,11 @@ export const HookOutputDTOEventTypeEnum = {
     ShopOrderStatusChanged: 'shop-order-status-changed',
     ShopOrderDeliveryFailed: 'shop-order-delivery-failed',
     PlayerLinked: 'player-linked',
+    PlayerUnlinked: 'player-unlinked',
+    PlayerMerged: 'player-merged',
     GameserverCreated: 'gameserver-created',
     GameserverUpdated: 'gameserver-updated',
+    GameserverVersionChanged: 'gameserver-version-changed',
     GameserverDeleted: 'gameserver-deleted',
     PlayerBanned: 'player-banned',
     PlayerUnbanned: 'player-unbanned',
@@ -480,6 +541,7 @@ export const HookTriggerDTOEventTypeEnum = {
     SettingsSet: 'settings-set',
     PlayerNewIpDetected: 'player-new-ip-detected',
     PlayerNewNameDetected: 'player-new-name-detected',
+    PlayerIdentityConflict: 'player-identity-conflict',
     ServerStatusChanged: 'server-status-changed',
     ModuleCreated: 'module-created',
     ModuleUpdated: 'module-updated',
@@ -494,8 +556,11 @@ export const HookTriggerDTOEventTypeEnum = {
     ShopOrderStatusChanged: 'shop-order-status-changed',
     ShopOrderDeliveryFailed: 'shop-order-delivery-failed',
     PlayerLinked: 'player-linked',
+    PlayerUnlinked: 'player-unlinked',
+    PlayerMerged: 'player-merged',
     GameserverCreated: 'gameserver-created',
     GameserverUpdated: 'gameserver-updated',
+    GameserverVersionChanged: 'gameserver-version-changed',
     GameserverDeleted: 'gameserver-deleted',
     PlayerBanned: 'player-banned',
     PlayerUnbanned: 'player-unbanned',
@@ -541,6 +606,7 @@ export const HookUpdateDTOEventTypeEnum = {
     SettingsSet: 'settings-set',
     PlayerNewIpDetected: 'player-new-ip-detected',
     PlayerNewNameDetected: 'player-new-name-detected',
+    PlayerIdentityConflict: 'player-identity-conflict',
     ServerStatusChanged: 'server-status-changed',
     ModuleCreated: 'module-created',
     ModuleUpdated: 'module-updated',
@@ -555,8 +621,11 @@ export const HookUpdateDTOEventTypeEnum = {
     ShopOrderStatusChanged: 'shop-order-status-changed',
     ShopOrderDeliveryFailed: 'shop-order-delivery-failed',
     PlayerLinked: 'player-linked',
+    PlayerUnlinked: 'player-unlinked',
+    PlayerMerged: 'player-merged',
     GameserverCreated: 'gameserver-created',
     GameserverUpdated: 'gameserver-updated',
+    GameserverVersionChanged: 'gameserver-version-changed',
     GameserverDeleted: 'gameserver-deleted',
     PlayerBanned: 'player-banned',
     PlayerUnbanned: 'player-unbanned',
@@ -607,6 +676,7 @@ export const IHookEventTypeEnum = {
     SettingsSet: 'settings-set',
     PlayerNewIpDetected: 'player-new-ip-detected',
     PlayerNewNameDetected: 'player-new-name-detected',
+    PlayerIdentityConflict: 'player-identity-conflict',
     ServerStatusChanged: 'server-status-changed',
     ModuleCreated: 'module-created',
     ModuleUpdated: 'module-updated',
@@ -621,8 +691,11 @@ export const IHookEventTypeEnum = {
     ShopOrderStatusChanged: 'shop-order-status-changed',
     ShopOrderDeliveryFailed: 'shop-order-delivery-failed',
     PlayerLinked: 'player-linked',
+    PlayerUnlinked: 'player-unlinked',
+    PlayerMerged: 'player-merged',
     GameserverCreated: 'gameserver-created',
     GameserverUpdated: 'gameserver-updated',
+    GameserverVersionChanged: 'gameserver-version-changed',
     GameserverDeleted: 'gameserver-deleted',
     PlayerBanned: 'player-banned',
     PlayerUnbanned: 'player-unbanned',
@@ -649,6 +722,29 @@ export const ITakaroQuerySortDirectionEnum = {
     Asc: 'asc',
     Desc: 'desc',
 };
+export const InventoryChangeCounterpartDTOKindEnum = {
+    Container: 'container',
+    Player: 'player',
+};
+export const InventoryChangeDTOChangeTypeEnum = {
+    Added: 'added',
+    Removed: 'removed',
+    Changed: 'changed',
+};
+export const InventoryChangeDTOCauseEnum = {
+    Pickup: 'pickup',
+    Drop: 'drop',
+    Craft: 'craft',
+    Loot: 'loot',
+    Trade: 'trade',
+    Death: 'death',
+    Other: 'other',
+    Unknown: 'unknown',
+};
+export const InventoryCounterpartDTOKindEnum = {
+    Container: 'container',
+    Player: 'player',
+};
 export const InviteLinkCreateResultDTOStatusEnum = {
     Active: 'ACTIVE',
     Revoked: 'REVOKED',
@@ -754,12 +850,18 @@ export const PERMISSIONS = {
     ViewDiscordInfo: 'VIEW_DISCORD_INFO',
     SendDiscordMessage: 'SEND_DISCORD_MESSAGE',
     ManageApiKeys: 'MANAGE_API_KEYS',
+    ReadMap: 'READ_MAP',
+    ReadTracking: 'READ_TRACKING',
 };
-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',
@@ -783,6 +885,11 @@ export const PlayerSearchInputDTOSortDirectionEnum = {
     Asc: 'asc',
     Desc: 'desc',
 };
+export const PositionAreaShapeDTOTypeEnum = {
+    Circle: 'circle',
+    Rectangle: 'rectangle',
+    Polygon: 'polygon',
+};
 export const RecentOrderDTOStatusEnum = {
     Completed: 'COMPLETED',
     Paid: 'PAID',
@@ -911,6 +1018,12 @@ 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',
@@ -949,16 +1062,68 @@ export const TakaroEventDomainCreatedOriginEnum = {
     Subscription: 'subscription',
     AdminSecret: 'admin_secret',
 };
+export const TakaroEventInventoryCounterpartKindEnum = {
+    Container: 'container',
+    Player: 'player',
+};
 export const TakaroEventItemsGivenLineResultEnum = {
     Delivered: 'DELIVERED',
     Failed: 'FAILED',
     Unknown: 'UNKNOWN',
 };
+export const TakaroEventPlayerIdentityConflictUnwrittenIdentifiersEnum = {
+    SteamId: 'steamId',
+    EpicOnlineServicesId: 'epicOnlineServicesId',
+    XboxLiveId: 'xboxLiveId',
+    PlatformId: 'platformId',
+};
+export const TakaroEventPlayerIdentityConflictMatchMatchedOnEnum = {
+    SteamId: 'steamId',
+    EpicOnlineServicesId: 'epicOnlineServicesId',
+    XboxLiveId: 'xboxLiveId',
+    PlatformId: 'platformId',
+};
 export const TakaroEventPlayerInventoryChangedChangeTypeEnum = {
     Added: 'added',
     Removed: 'removed',
     Changed: 'changed',
 };
+export const TakaroEventPlayerInventoryChangedCauseEnum = {
+    Pickup: 'pickup',
+    Drop: 'drop',
+    Craft: 'craft',
+    Loot: 'loot',
+    Trade: 'trade',
+    Death: 'death',
+    Other: 'other',
+};
+export const TakaroEventPlayerLinkedSourceEnum = {
+    GameCode: 'game-code',
+    WebCode: 'web-code',
+    SteamAuto: 'steam-auto',
+    Admin: 'admin',
+    Unknown: 'unknown',
+};
+export const TakaroEventPlayerMergedMovedIdentifiersEnum = {
+    SteamId: 'steamId',
+    EpicOnlineServicesId: 'epicOnlineServicesId',
+    XboxLiveId: 'xboxLiveId',
+    PlatformId: 'platformId',
+};
+export const TakaroEventPlayerMergedServerOutcomeEnum = {
+    Moved: 'moved',
+    Combined: 'combined',
+};
+export const TakaroEventPlayerMergedServerKeptPogFromEnum = {
+    Survivor: 'survivor',
+    Absorbed: 'absorbed',
+};
+export const TakaroEventPlayerUnlinkedReasonEnum = {
+    Self: 'self',
+    Admin: 'admin',
+    Displaced: 'displaced',
+    Merged: 'merged',
+};
 export const TakaroEventRateLimitedScopeEnum = {
     Server: 'server',
     Domain: 'domain',
@@ -1103,11 +1268,27 @@ export const TriggerJobInputDTOTypeEnum = {
     SyncItems: 'syncItems',
     SyncEntities: 'syncEntities',
     SyncBans: 'syncBans',
+    SyncLocations: 'syncLocations',
     SyncMapImages: 'syncMapImages',
     SyncMapUploads: 'syncMapUploads',
+    SyncGameIcons: 'syncGameIcons',
     SyncSteam: 'syncSteam',
     SyncDiscordRoles: 'syncDiscordRoles',
 };
+export const UserOutputDTOPlayerLinkSourceEnum = {
+    GameCode: 'game-code',
+    WebCode: 'web-code',
+    SteamAuto: 'steam-auto',
+    Admin: 'admin',
+    Unknown: 'unknown',
+};
+export const UserOutputWithRolesDTOPlayerLinkSourceEnum = {
+    GameCode: 'game-code',
+    WebCode: 'web-code',
+    SteamAuto: 'steam-auto',
+    Admin: 'admin',
+    Unknown: 'unknown',
+};
 export const UserSearchInputDTOExtendEnum = {
     Roles: 'roles',
 };
@@ -1872,7 +2053,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.
@@ -2182,7 +2363,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
@@ -2225,7 +2406,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.
@@ -2355,7 +2536,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
@@ -2378,7 +2559,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.
@@ -2496,7 +2677,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
@@ -2518,7 +2699,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.
@@ -2648,7 +2829,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
@@ -2960,21 +3141,58 @@ 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
+            // 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(domainPlanInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * For a domain with neither a Subscription nor a Distributor; refused for either, since Stripe or the Distributor chooses those Plans. Applies the Plan’s limits at once, keeping any limit override. On the first assignment of a domain that predates Plans, its hand-set limits that differ from the Plan are kept as overrides.<br> OperationId: `DomainControllerSetPlanByStaff`
+         * @summary Put an Unbacked domain on a Plan
+         * @param {string} id
+         * @param {StaffDomainPlanInputDTO} [staffDomainPlanInputDTO] StaffDomainPlanInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        domainControllerSetPlanByStaff: async (id, staffDomainPlanInputDTO, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('domainControllerSetPlanByStaff', 'id', id);
+            const localVarPath = `/staff/domains/{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: 'PUT', ...baseOptions, ...options };
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication staffSession required
@@ -2984,7 +3202,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(staffDomainPlanInputDTO, localVarRequestOptions, configuration);
             return {
                 url: toPathString(localVarUrlObj),
                 options: localVarRequestOptions,
@@ -3154,16 +3372,31 @@ 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 domainControllerSetPlan(id, domainPlanInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.domainControllerSetPlan(id, domainPlanInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['DomainApi.domainControllerSetPlan']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * For a domain with neither a Subscription nor a Distributor; refused for either, since Stripe or the Distributor chooses those Plans. Applies the Plan’s limits at once, keeping any limit override. On the first assignment of a domain that predates Plans, its hand-set limits that differ from the Plan are kept as overrides.<br> OperationId: `DomainControllerSetPlanByStaff`
+         * @summary Put an Unbacked domain on a Plan
+         * @param {string} id
+         * @param {StaffDomainPlanInputDTO} [staffDomainPlanInputDTO] StaffDomainPlanInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options);
+        async domainControllerSetPlanByStaff(id, staffDomainPlanInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.domainControllerSetPlanByStaff(id, staffDomainPlanInputDTO, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['DomainApi.domainControllerSearchDistributorBacked']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['DomainApi.domainControllerSetPlanByStaff']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -3293,15 +3526,29 @@ 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}
+         */
+        domainControllerSetPlan(id, domainPlanInputDTO, options) {
+            return localVarFp
+                .domainControllerSetPlan(id, domainPlanInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * For a domain with neither a Subscription nor a Distributor; refused for either, since Stripe or the Distributor chooses those Plans. Applies the Plan’s limits at once, keeping any limit override. On the first assignment of a domain that predates Plans, its hand-set limits that differ from the Plan are kept as overrides.<br> OperationId: `DomainControllerSetPlanByStaff`
+         * @summary Put an Unbacked domain on a Plan
+         * @param {string} id
+         * @param {StaffDomainPlanInputDTO} [staffDomainPlanInputDTO] StaffDomainPlanInputDTO
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options) {
+        domainControllerSetPlanByStaff(id, staffDomainPlanInputDTO, options) {
             return localVarFp
-                .domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options)
+                .domainControllerSetPlanByStaff(id, staffDomainPlanInputDTO, options)
                 .then((request) => request(axios, basePath));
         },
         /**
@@ -3447,16 +3694,31 @@ 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
+     */
+    domainControllerSetPlan(id, domainPlanInputDTO, options) {
+        return DomainApiFp(this.configuration)
+            .domainControllerSetPlan(id, domainPlanInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * For a domain with neither a Subscription nor a Distributor; refused for either, since Stripe or the Distributor chooses those Plans. Applies the Plan’s limits at once, keeping any limit override. On the first assignment of a domain that predates Plans, its hand-set limits that differ from the Plan are kept as overrides.<br> OperationId: `DomainControllerSetPlanByStaff`
+     * @summary Put an Unbacked domain on a Plan
+     * @param {string} id
+     * @param {StaffDomainPlanInputDTO} [staffDomainPlanInputDTO] StaffDomainPlanInputDTO
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof DomainApi
      */
-    domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options) {
+    domainControllerSetPlanByStaff(id, staffDomainPlanInputDTO, options) {
         return DomainApiFp(this.configuration)
-            .domainControllerSearchDistributorBacked(distributorBackedDomainSearchInputDTO, options)
+            .domainControllerSetPlanByStaff(id, staffDomainPlanInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
     /**
@@ -3931,6 +4193,72 @@ export const FixtureHistoryApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerTrackingInventory`
+         * @summary Write owned, back-dated inventory snapshots and changes into the Tracking store (idempotent on id)
+         * @param {string} domainId
+         * @param {FixtureHistoryTrackingInventoryInputDTO} [fixtureHistoryTrackingInventoryInputDTO] FixtureHistoryTrackingInventoryInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerTrackingInventory: async (domainId, fixtureHistoryTrackingInventoryInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerTrackingInventory', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/tracking/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: '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(fixtureHistoryTrackingInventoryInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Columnar: each track is one player-on-gameserver with flattened x, y, z triples sampled every intervalMs from `from`.<br> OperationId: `FixtureHistoryControllerTrackingPositions`
+         * @summary Write owned, back-dated walked paths into the Tracking store (inserts only missing samples)
+         * @param {string} domainId
+         * @param {FixtureHistoryTrackingPositionsInputDTO} [fixtureHistoryTrackingPositionsInputDTO] FixtureHistoryTrackingPositionsInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerTrackingPositions: async (domainId, fixtureHistoryTrackingPositionsInputDTO, options = {}) => {
+            // verify required parameter 'domainId' is not null or undefined
+            assertParamExists('fixtureHistoryControllerTrackingPositions', 'domainId', domainId);
+            const localVarPath = `/fixture-history/domains/{domainId}/tracking/positions`.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(fixtureHistoryTrackingPositionsInputDTO, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
     };
 };
 /**
@@ -4129,6 +4457,34 @@ export const FixtureHistoryApiFp = function (configuration) {
                 ?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerTrackingInventory`
+         * @summary Write owned, back-dated inventory snapshots and changes into the Tracking store (idempotent on id)
+         * @param {string} domainId
+         * @param {FixtureHistoryTrackingInventoryInputDTO} [fixtureHistoryTrackingInventoryInputDTO] FixtureHistoryTrackingInventoryInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerTrackingInventory(domainId, fixtureHistoryTrackingInventoryInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerTrackingInventory(domainId, fixtureHistoryTrackingInventoryInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerTrackingInventory']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Columnar: each track is one player-on-gameserver with flattened x, y, z triples sampled every intervalMs from `from`.<br> OperationId: `FixtureHistoryControllerTrackingPositions`
+         * @summary Write owned, back-dated walked paths into the Tracking store (inserts only missing samples)
+         * @param {string} domainId
+         * @param {FixtureHistoryTrackingPositionsInputDTO} [fixtureHistoryTrackingPositionsInputDTO] FixtureHistoryTrackingPositionsInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async fixtureHistoryControllerTrackingPositions(domainId, fixtureHistoryTrackingPositionsInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.fixtureHistoryControllerTrackingPositions(domainId, fixtureHistoryTrackingPositionsInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FixtureHistoryApi.fixtureHistoryControllerTrackingPositions']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
     };
 };
 /**
@@ -4310,6 +4666,32 @@ export const FixtureHistoryApiFactory = function (configuration, basePath, axios
                 .fixtureHistoryControllerTerminalState(domainId, fixtureDatasetId, cursor, options)
                 .then((request) => request(axios, basePath));
         },
+        /**
+         * <br> OperationId: `FixtureHistoryControllerTrackingInventory`
+         * @summary Write owned, back-dated inventory snapshots and changes into the Tracking store (idempotent on id)
+         * @param {string} domainId
+         * @param {FixtureHistoryTrackingInventoryInputDTO} [fixtureHistoryTrackingInventoryInputDTO] FixtureHistoryTrackingInventoryInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerTrackingInventory(domainId, fixtureHistoryTrackingInventoryInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerTrackingInventory(domainId, fixtureHistoryTrackingInventoryInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * Columnar: each track is one player-on-gameserver with flattened x, y, z triples sampled every intervalMs from `from`.<br> OperationId: `FixtureHistoryControllerTrackingPositions`
+         * @summary Write owned, back-dated walked paths into the Tracking store (inserts only missing samples)
+         * @param {string} domainId
+         * @param {FixtureHistoryTrackingPositionsInputDTO} [fixtureHistoryTrackingPositionsInputDTO] FixtureHistoryTrackingPositionsInputDTO
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        fixtureHistoryControllerTrackingPositions(domainId, fixtureHistoryTrackingPositionsInputDTO, options) {
+            return localVarFp
+                .fixtureHistoryControllerTrackingPositions(domainId, fixtureHistoryTrackingPositionsInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
     };
 };
 /**
@@ -4504,6 +4886,34 @@ export class FixtureHistoryApi extends BaseAPI {
             .fixtureHistoryControllerTerminalState(domainId, fixtureDatasetId, cursor, options)
             .then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * <br> OperationId: `FixtureHistoryControllerTrackingInventory`
+     * @summary Write owned, back-dated inventory snapshots and changes into the Tracking store (idempotent on id)
+     * @param {string} domainId
+     * @param {FixtureHistoryTrackingInventoryInputDTO} [fixtureHistoryTrackingInventoryInputDTO] FixtureHistoryTrackingInventoryInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerTrackingInventory(domainId, fixtureHistoryTrackingInventoryInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerTrackingInventory(domainId, fixtureHistoryTrackingInventoryInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Columnar: each track is one player-on-gameserver with flattened x, y, z triples sampled every intervalMs from `from`.<br> OperationId: `FixtureHistoryControllerTrackingPositions`
+     * @summary Write owned, back-dated walked paths into the Tracking store (inserts only missing samples)
+     * @param {string} domainId
+     * @param {FixtureHistoryTrackingPositionsInputDTO} [fixtureHistoryTrackingPositionsInputDTO] FixtureHistoryTrackingPositionsInputDTO
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FixtureHistoryApi
+     */
+    fixtureHistoryControllerTrackingPositions(domainId, fixtureHistoryTrackingPositionsInputDTO, options) {
+        return FixtureHistoryApiFp(this.configuration)
+            .fixtureHistoryControllerTrackingPositions(domainId, fixtureHistoryTrackingPositionsInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
 }
 /**
  * MetaApi - axios parameter creator
@@ -5198,114 +5608,355 @@ export class StaffAuthApi extends BaseAPI {
     }
 }
 /**
- * StaffMeApi - axios parameter creator
+ * StaffDomainLimitsApi - axios parameter creator
  * @export
  */
-export const StaffMeApiAxiosParamCreator = function (configuration) {
+export const StaffDomainLimitsApiAxiosParamCreator = function (configuration) {
     return {
         /**
-         * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
-         * @summary Who this Staff session belongs to
+         * The 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}
          */
-        staffMeControllerMe: async (options = {}) => {
-            const localVarPath = `/staff/me`;
+        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: 'GET', ...baseOptions, ...options };
+            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,
             };
         },
-    };
-};
-/**
- * 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
+         * 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 staffMeControllerMe(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.staffMeControllerMe(options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StaffMeApi.staffMeControllerMe']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
-    };
-};
-/**
- * StaffMeApi - factory interface
- * @export
- */
-export const StaffMeApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = StaffMeApiFp(configuration);
-    return {
-        /**
-         * The signed-in Takaro Staff member and their tier (ADR 0026). Deliberately nothing else: no domains, no permissions, and never a token.<br> OperationId: `StaffMeControllerMe`
-         * @summary Who this Staff session belongs to
-         * @param {*} [options] Override http request option.
+        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,
+            };
+        },
+        /**
+         * Newest first.<br> OperationId: `StaffDomainLimitsControllerHistory`
+         * @summary Limit override history of a Domain
+         * @param {string} id
+         * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        staffMeControllerMe(options) {
-            return localVarFp.staffMeControllerMe(options).then((request) => request(axios, 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,
+            };
+        },
+        /**
+         * 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: 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,
+            };
         },
     };
 };
 /**
- * StaffMeApi - object-oriented interface
+ * StaffDomainLimitsApi - functional programming interface
  * @export
- * @class StaffMeApi
+ */
+export const StaffDomainLimitsApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffDomainLimitsApiAxiosParamCreator(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}
+         */
+        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);
+        },
+        /**
+         * 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 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);
+        },
+        /**
+         * Newest first.<br> OperationId: `StaffDomainLimitsControllerHistory`
+         * @summary Limit override history of a Domain
+         * @param {string} id
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        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);
+        },
+        /**
+         * 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 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 {
+        /**
+         * 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(id, limitKey, domainLimitOverrideClearInputDTO, options) {
+            return localVarFp
+                .staffDomainLimitsControllerClear(id, limitKey, domainLimitOverrideClearInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * 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}
+         */
+        staffDomainLimitsControllerGet(id, options) {
+            return localVarFp.staffDomainLimitsControllerGet(id, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Newest first.<br> OperationId: `StaffDomainLimitsControllerHistory`
+         * @summary Limit override history of a Domain
+         * @param {string} id
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        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));
+        },
+    };
+};
+/**
+ * StaffDomainLimitsApi - object-oriented interface
+ * @export
+ * @class StaffDomainLimitsApi
  * @extends {BaseAPI}
  */
-export class StaffMeApi extends BaseAPI {
+export class StaffDomainLimitsApi 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
+     * 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 StaffMeApi
+     * @memberof StaffDomainLimitsApi
      */
-    staffMeControllerMe(options) {
-        return StaffMeApiFp(this.configuration)
-            .staffMeControllerMe(options)
+    staffDomainLimitsControllerClear(id, limitKey, domainLimitOverrideClearInputDTO, options) {
+        return StaffDomainLimitsApiFp(this.configuration)
+            .staffDomainLimitsControllerClear(id, limitKey, domainLimitOverrideClearInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * 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 StaffDomainLimitsApi
+     */
+    staffDomainLimitsControllerGet(id, options) {
+        return StaffDomainLimitsApiFp(this.configuration)
+            .staffDomainLimitsControllerGet(id, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Newest first.<br> OperationId: `StaffDomainLimitsControllerHistory`
+     * @summary Limit override history of a Domain
+     * @param {string} id
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof StaffDomainLimitsApi
+     */
+    staffDomainLimitsControllerHistory(id, options) {
+        return StaffDomainLimitsApiFp(this.configuration)
+            .staffDomainLimitsControllerHistory(id, options)
+            .then((request) => request(this.axios, this.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}
+     * @memberof StaffDomainLimitsApi
+     */
+    staffDomainLimitsControllerSet(id, limitKey, domainLimitOverrideInputDTO, options) {
+        return StaffDomainLimitsApiFp(this.configuration)
+            .staffDomainLimitsControllerSet(id, limitKey, domainLimitOverrideInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
 }
 /**
- * StaffPlanApi - axios parameter creator
+ * StaffMeApi - axios parameter creator
  * @export
  */
-export const StaffPlanApiAxiosParamCreator = function (configuration) {
+export const StaffMeApiAxiosParamCreator = 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
+         * 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}
          */
-        staffPlanControllerList: async (options = {}) => {
-            const localVarPath = `/staff/plans`;
+        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;
@@ -5329,61 +5980,717 @@ export const StaffPlanApiAxiosParamCreator = function (configuration) {
     };
 };
 /**
- * StaffPlanApi - functional programming interface
+ * StaffMeApi - functional programming interface
  * @export
  */
-export const StaffPlanApiFp = function (configuration) {
-    const localVarAxiosParamCreator = StaffPlanApiAxiosParamCreator(configuration);
+export const StaffMeApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffMeApiAxiosParamCreator(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
+         * 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 staffPlanControllerList(options) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerList(options);
+        async staffMeControllerMe(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffMeControllerMe(options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerList']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['StaffMeApi.staffMeControllerMe']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
 /**
- * StaffPlanApi - factory interface
+ * StaffMeApi - factory interface
  * @export
  */
-export const StaffPlanApiFactory = function (configuration, basePath, axios) {
-    const localVarFp = StaffPlanApiFp(configuration);
+export const StaffMeApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = StaffMeApiFp(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
+         * 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}
          */
-        staffPlanControllerList(options) {
-            return localVarFp.staffPlanControllerList(options).then((request) => request(axios, basePath));
+        staffMeControllerMe(options) {
+            return localVarFp.staffMeControllerMe(options).then((request) => request(axios, basePath));
         },
     };
 };
 /**
- * StaffPlanApi - object-oriented interface
+ * StaffMeApi - object-oriented interface
  * @export
- * @class StaffPlanApi
+ * @class StaffMeApi
  * @extends {BaseAPI}
  */
-export class StaffPlanApi extends BaseAPI {
+export class StaffMeApi 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
+     * 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 {
+        /**
+         * 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}
+         */
+        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;
+            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,
+            };
+        },
+        /**
+         * 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: 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;
+            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,
+            };
+        },
+        /**
+         * 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,
+            };
+        },
+        /**
+         * 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: 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: '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,
+            };
+        },
+    };
+};
+/**
+ * StaffPlanApi - functional programming interface
+ * @export
+ */
+export const StaffPlanApiFp = function (configuration) {
+    const localVarAxiosParamCreator = StaffPlanApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * 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 staffPlanControllerArchive(id, planArchiveInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerArchive(id, planArchiveInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerArchive']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 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 staffPlanControllerCreate(planCreateInputDTO, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerCreate(planCreateInputDTO, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['StaffPlanApi.staffPlanControllerCreate']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * 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 staffPlanControllerHistory(id, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.staffPlanControllerHistory(id, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            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);
+        },
+    };
+};
+/**
+ * StaffPlanApi - factory interface
+ * @export
+ */
+export const StaffPlanApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = StaffPlanApiFp(configuration);
+    return {
+        /**
+         * 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}
+         */
+        staffPlanControllerArchive(id, planArchiveInputDTO, options) {
+            return localVarFp
+                .staffPlanControllerArchive(id, planArchiveInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * 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(planCreateInputDTO, options) {
+            return localVarFp
+                .staffPlanControllerCreate(planCreateInputDTO, options)
+                .then((request) => request(axios, basePath));
+        },
+        /**
+         * 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(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));
+        },
+    };
+};
+/**
+ * StaffPlanApi - object-oriented interface
+ * @export
+ * @class StaffPlanApi
+ * @extends {BaseAPI}
+ */
+export class StaffPlanApi extends BaseAPI {
+    /**
+     * 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 StaffPlanApi
+     */
+    staffPlanControllerArchive(id, planArchiveInputDTO, options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerArchive(id, planArchiveInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * 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 StaffPlanApi
+     */
+    staffPlanControllerCreate(planCreateInputDTO, options) {
+        return StaffPlanApiFp(this.configuration)
+            .staffPlanControllerCreate(planCreateInputDTO, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * 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 StaffPlanApi
+     */
+    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
      */
-    staffPlanControllerList(options) {
+    staffPlanControllerUpdate(id, planUpdateInputDTO, options) {
         return StaffPlanApiFp(this.configuration)
-            .staffPlanControllerList(options)
+            .staffPlanControllerUpdate(id, planUpdateInputDTO, options)
             .then((request) => request(this.axios, this.basePath));
     }
 }