@accelbyte/sdk-ams 0.0.0-dev-20240828032938 → 0.0.0-dev-20240828055251

package/dist/index.cjs

@@ -0,0 +1,1871 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Account$: () => Account$,
+  AccountAdmin$: () => AccountAdmin$,
+  AccountAdminApi: () => AccountAdminApi,
+  AccountApi: () => AccountApi,
+  AccountCreateRequest: () => AccountCreateRequest,
+  AccountCreateResponse: () => AccountCreateResponse,
+  AccountLimits: () => AccountLimits,
+  AccountLinkRequest: () => AccountLinkRequest,
+  AccountLinkResponse: () => AccountLinkResponse,
+  AccountLinkTokenResponse: () => AccountLinkTokenResponse,
+  AccountResponse: () => AccountResponse,
+  Ams: () => Ams,
+  AmsInfo$: () => AmsInfo$,
+  AmsInfoAdmin$: () => AmsInfoAdmin$,
+  AmsInfoAdminApi: () => AmsInfoAdminApi,
+  AmsInfoApi: () => AmsInfoApi,
+  AmsQoSAdmin$: () => AmsQoSAdmin$,
+  AmsQoSAdminApi: () => AmsQoSAdminApi,
+  AmsRegionsResponse: () => AmsRegionsResponse,
+  ArtifactListResponse: () => ArtifactListResponse,
+  ArtifactResponse: () => ArtifactResponse,
+  ArtifactSamplingRule: () => ArtifactSamplingRule,
+  ArtifactTypeSamplingRules: () => ArtifactTypeSamplingRules,
+  ArtifactUrlResponse: () => ArtifactUrlResponse,
+  ArtifactUsageResponse: () => ArtifactUsageResponse,
+  ArtifactsAdmin$: () => ArtifactsAdmin$,
+  ArtifactsAdminApi: () => ArtifactsAdminApi,
+  Auth$: () => Auth$,
+  AuthApi: () => AuthApi,
+  AvailableInstanceTypesResponse: () => AvailableInstanceTypesResponse,
+  DevelopmentAdmin$: () => DevelopmentAdmin$,
+  DevelopmentAdminApi: () => DevelopmentAdminApi,
+  DevelopmentServerConfigurationCreateRequest: () => DevelopmentServerConfigurationCreateRequest,
+  DevelopmentServerConfigurationCreateResponse: () => DevelopmentServerConfigurationCreateResponse,
+  DevelopmentServerConfigurationGetResponse: () => DevelopmentServerConfigurationGetResponse,
+  DevelopmentServerConfigurationListResponse: () => DevelopmentServerConfigurationListResponse,
+  DsHistoryEvent: () => DsHistoryEvent,
+  DsHistoryList: () => DsHistoryList,
+  DsHostConfiguration: () => DsHostConfiguration,
+  ErrorResponse: () => ErrorResponse,
+  FleetArtifactsSampleRules: () => FleetArtifactsSampleRules,
+  FleetClaimByKeysReq: () => FleetClaimByKeysReq,
+  FleetClaimReq: () => FleetClaimReq,
+  FleetClaimResponse: () => FleetClaimResponse,
+  FleetCommander$: () => FleetCommander$,
+  FleetCommanderApi: () => FleetCommanderApi,
+  FleetCreateResponse: () => FleetCreateResponse,
+  FleetGetResponse: () => FleetGetResponse,
+  FleetListItemResponse: () => FleetListItemResponse,
+  FleetListResponse: () => FleetListResponse,
+  FleetParameters: () => FleetParameters,
+  FleetRegionalServerCounts: () => FleetRegionalServerCounts,
+  FleetServerConnectionInfoResponse: () => FleetServerConnectionInfoResponse,
+  FleetServerHistoryEventResponse: () => FleetServerHistoryEventResponse,
+  FleetServerHistoryResponse: () => FleetServerHistoryResponse,
+  FleetServerInfoResponse: () => FleetServerInfoResponse,
+  FleetServersResponse: () => FleetServersResponse,
+  Fleets$: () => Fleets$,
+  FleetsAdmin$: () => FleetsAdmin$,
+  FleetsAdminApi: () => FleetsAdminApi,
+  FleetsApi: () => FleetsApi,
+  ImageDeploymentProfile: () => ImageDeploymentProfile,
+  ImageDetails: () => ImageDetails,
+  ImageList: () => ImageList,
+  ImageListItem: () => ImageListItem,
+  ImageStorage: () => ImageStorage,
+  ImageUpdate: () => ImageUpdate,
+  ImagesAdmin$: () => ImagesAdmin$,
+  ImagesAdminApi: () => ImagesAdminApi,
+  InstanceTypeDescriptionResponse: () => InstanceTypeDescriptionResponse,
+  Location: () => Location,
+  PagingInfo: () => PagingInfo,
+  PortConfiguration: () => PortConfiguration,
+  QoSEndpointResponse: () => QoSEndpointResponse,
+  QoSServer: () => QoSServer,
+  ReferencingFleet: () => ReferencingFleet,
+  RegionConfig: () => RegionConfig,
+  ServersAdmin$: () => ServersAdmin$,
+  ServersAdminApi: () => ServersAdminApi,
+  Time: () => Time,
+  Timeout: () => Timeout,
+  UpdateServerRequest: () => UpdateServerRequest,
+  Watchdogs$: () => Watchdogs$,
+  WatchdogsApi: () => WatchdogsApi,
+  Zone: () => Zone,
+  ZoneTrans: () => ZoneTrans
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/generated-admin/AccountAdminApi.ts
+var import_sdk2 = require("@accelbyte/sdk");
+
+// src/generated-admin/endpoints/AccountAdmin$.ts
+var import_sdk = require("@accelbyte/sdk");
+
+// src/generated-definitions/AccountCreateResponse.ts
+var import_zod2 = require("zod");
+
+// src/generated-definitions/AccountLimits.ts
+var import_zod = require("zod");
+var AccountLimits = import_zod.z.object({
+  allowedNodeClasses: import_zod.z.array(import_zod.z.string()).nullish(),
+  allowedRegions: import_zod.z.array(import_zod.z.string()).nullish(),
+  fleetCount: import_zod.z.number().int().nullish(),
+  fleetVmCount: import_zod.z.number().int().nullish(),
+  imageStorageQuotaBytes: import_zod.z.number().int().nullish()
+});
+
+// src/generated-definitions/AccountCreateResponse.ts
+var AccountCreateResponse = import_zod2.z.object({ Limits: AccountLimits, id: import_zod2.z.string(), name: import_zod2.z.string(), namespaces: import_zod2.z.array(import_zod2.z.string()) });
+
+// src/generated-definitions/AccountLinkResponse.ts
+var import_zod3 = require("zod");
+var AccountLinkResponse = import_zod3.z.object({ Limits: AccountLimits, id: import_zod3.z.string(), name: import_zod3.z.string(), namespaces: import_zod3.z.array(import_zod3.z.string()) });
+
+// src/generated-definitions/AccountLinkTokenResponse.ts
+var import_zod4 = require("zod");
+var AccountLinkTokenResponse = import_zod4.z.object({ token: import_zod4.z.string() });
+
+// src/generated-definitions/AccountResponse.ts
+var import_zod5 = require("zod");
+var AccountResponse = import_zod5.z.object({ Limits: AccountLimits, id: import_zod5.z.string(), name: import_zod5.z.string(), namespaces: import_zod5.z.array(import_zod5.z.string()) });
+
+// src/generated-admin/endpoints/AccountAdmin$.ts
+var AccountAdmin$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:ACCOUNT [READ] 
+   */
+  getAccount() {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/account".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, AccountResponse, "AccountResponse");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:ACCOUNT [CREATE] 
+   */
+  createAccount(data) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/account".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.post(url, data, { params });
+    return import_sdk.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, AccountCreateResponse, "AccountCreateResponse");
+  }
+  /**
+   * The link token returned can be used to connect another namespace to the account in which the provided namespace is linked. This route fails if there is no account linked to the specified namespace. Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:ACCOUNT [READ] 
+   */
+  getAccountLink() {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/account/link".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, AccountLinkTokenResponse, "AccountLinkTokenResponse");
+  }
+  /**
+   * This route will attempt to register the account to namespace linkage in AMS and requires a valid account link token. This route fails if an account is already linked AdminAccountLink Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:ACCOUNT [CREATE] 
+   */
+  createAccountLink(data) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/account/link".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.post(url, data, { params });
+    return import_sdk.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, AccountLinkResponse, "AccountLinkResponse");
+  }
+};
+
+// src/generated-admin/AccountAdminApi.ts
+function AccountAdminApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk2.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk2.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getAccount() {
+    const $ = new AccountAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getAccount();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function createAccount(data) {
+    const $ = new AccountAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.createAccount(data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getAccountLink() {
+    const $ = new AccountAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getAccountLink();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function createAccountLink(data) {
+    const $ = new AccountAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.createAccountLink(data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getAccount,
+    createAccount,
+    getAccountLink,
+    createAccountLink
+  };
+}
+
+// src/generated-admin/AmsInfoAdminApi.ts
+var import_sdk4 = require("@accelbyte/sdk");
+
+// src/generated-admin/endpoints/AmsInfoAdmin$.ts
+var import_sdk3 = require("@accelbyte/sdk");
+
+// src/generated-definitions/AmsRegionsResponse.ts
+var import_zod6 = require("zod");
+var AmsRegionsResponse = import_zod6.z.object({ regions: import_zod6.z.array(import_zod6.z.string()).nullish() });
+
+// src/generated-definitions/AvailableInstanceTypesResponse.ts
+var import_zod8 = require("zod");
+
+// src/generated-definitions/InstanceTypeDescriptionResponse.ts
+var import_zod7 = require("zod");
+var InstanceTypeDescriptionResponse = import_zod7.z.object({
+  description: import_zod7.z.string(),
+  id: import_zod7.z.string(),
+  memoryGiB: import_zod7.z.number(),
+  minSpeed: import_zod7.z.string(),
+  name: import_zod7.z.string(),
+  virtualCpu: import_zod7.z.number().int()
+});
+
+// src/generated-definitions/AvailableInstanceTypesResponse.ts
+var AvailableInstanceTypesResponse = import_zod8.z.object({ availableInstanceTypes: import_zod8.z.array(InstanceTypeDescriptionResponse) });
+
+// src/generated-admin/endpoints/AmsInfoAdmin$.ts
+var AmsInfoAdmin$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA [READ] 
+   */
+  getRegions() {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/regions".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk3.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, AmsRegionsResponse, "AmsRegionsResponse");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA [READ] 
+   */
+  getSupportedInstances() {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/supported-instances".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk3.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, AvailableInstanceTypesResponse, "AvailableInstanceTypesResponse");
+  }
+};
+
+// src/generated-admin/AmsInfoAdminApi.ts
+function AmsInfoAdminApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk4.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk4.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getRegions() {
+    const $ = new AmsInfoAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getRegions();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getSupportedInstances() {
+    const $ = new AmsInfoAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getSupportedInstances();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getRegions,
+    getSupportedInstances
+  };
+}
+
+// src/generated-admin/AmsQoSAdminApi.ts
+var import_sdk6 = require("@accelbyte/sdk");
+
+// src/generated-admin/endpoints/AmsQoSAdmin$.ts
+var import_sdk5 = require("@accelbyte/sdk");
+var import_zod12 = require("zod");
+
+// src/generated-definitions/QoSEndpointResponse.ts
+var import_zod11 = require("zod");
+
+// src/generated-definitions/QoSServer.ts
+var import_zod10 = require("zod");
+
+// src/generated-definitions/Time.ts
+var import_zod9 = require("zod");
+var Time = import_zod9.z.any();
+
+// src/generated-definitions/QoSServer.ts
+var QoSServer = import_zod10.z.object({
+  alias: import_zod10.z.string(),
+  ip: import_zod10.z.string(),
+  last_update: Time,
+  port: import_zod10.z.number().int(),
+  region: import_zod10.z.string(),
+  status: import_zod10.z.string()
+});
+
+// src/generated-definitions/QoSEndpointResponse.ts
+var QoSEndpointResponse = import_zod11.z.object({ servers: import_zod11.z.array(QoSServer) });
+
+// src/generated-admin/endpoints/AmsQoSAdmin$.ts
+var AmsQoSAdmin$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * ``` Required Permission: ADMIN:NAMESPACE:{namespace}:QOS:SERVER [READ] This endpoint lists all QoS services available in all regions. This endpoint is intended to be called by game client to find out all available regions. After getting a list of QoS on each region, game client is expected to ping each one with UDP connection as described below: 1. Make UDP connection to each QoS's IP:Port 2. Send string "PING" after connection established 3. Wait for string "PONG" response 4. Note the request-response latency for each QoS in each region The game then can use ping latency information to either: 1. Inform the player on these latencies and let player choose preferred region 2. Send the latency list to Matchmaking Service so that player can be matched with other players in nearby regions  
+   */
+  getQos(queryParams) {
+    const params = { ...queryParams };
+    const url = "/ams/v1/admin/namespaces/{namespace}/qos".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk5.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, QoSEndpointResponse, "QoSEndpointResponse");
+  }
+  /**
+   * ``` Required Permission: ADMIN:NAMESPACE:{namespace}:QOS:SERVER [UPDATE] This endpoint updates the registered QoS service's configurable configuration.  
+   */
+  patchQo_ByRegion(region, data) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/qos/{region}".replace("{namespace}", this.namespace).replace("{region}", region);
+    const resultPromise = this.axiosInstance.patch(url, data, { params });
+    return import_sdk5.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod12.z.unknown(), "z.unknown()");
+  }
+};
+
+// src/generated-admin/AmsQoSAdminApi.ts
+function AmsQoSAdminApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk6.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk6.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getQos(queryParams) {
+    const $ = new AmsQoSAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getQos(queryParams);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function patchQo_ByRegion(region, data) {
+    const $ = new AmsQoSAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.patchQo_ByRegion(region, data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getQos,
+    patchQo_ByRegion
+  };
+}
+
+// src/generated-admin/ArtifactsAdminApi.ts
+var import_sdk8 = require("@accelbyte/sdk");
+
+// src/generated-admin/endpoints/ArtifactsAdmin$.ts
+var import_sdk7 = require("@accelbyte/sdk");
+var import_zod20 = require("zod");
+
+// src/generated-definitions/ArtifactListResponse.ts
+var import_zod14 = require("zod");
+
+// src/generated-definitions/ArtifactResponse.ts
+var import_zod13 = require("zod");
+var ArtifactResponse = import_zod13.z.object({
+  artifactType: import_zod13.z.string(),
+  createdOn: Time,
+  dsId: import_zod13.z.string(),
+  expiresOn: Time,
+  filename: import_zod13.z.string(),
+  fleetId: import_zod13.z.string(),
+  id: import_zod13.z.string(),
+  imageId: import_zod13.z.string(),
+  namespace: import_zod13.z.string(),
+  region: import_zod13.z.string(),
+  sizeBytes: import_zod13.z.number().int(),
+  status: import_zod13.z.string()
+});
+
+// src/generated-definitions/ArtifactListResponse.ts
+var ArtifactListResponse = import_zod14.z.object({ data: import_zod14.z.array(ArtifactResponse), totalData: import_zod14.z.number().int() });
+
+// src/generated-definitions/ArtifactUrlResponse.ts
+var import_zod15 = require("zod");
+var ArtifactUrlResponse = import_zod15.z.object({ url: import_zod15.z.string() });
+
+// src/generated-definitions/ArtifactUsageResponse.ts
+var import_zod16 = require("zod");
+var ArtifactUsageResponse = import_zod16.z.object({
+  quotaBytes: import_zod16.z.number().int(),
+  remainingBytes: import_zod16.z.number().int(),
+  usedBytes: import_zod16.z.number().int()
+});
+
+// src/generated-definitions/FleetArtifactsSampleRules.ts
+var import_zod19 = require("zod");
+
+// src/generated-definitions/ArtifactTypeSamplingRules.ts
+var import_zod18 = require("zod");
+
+// src/generated-definitions/ArtifactSamplingRule.ts
+var import_zod17 = require("zod");
+var ArtifactSamplingRule = import_zod17.z.object({ collect: import_zod17.z.boolean(), percentage: import_zod17.z.number().int() });
+
+// src/generated-definitions/ArtifactTypeSamplingRules.ts
+var ArtifactTypeSamplingRules = import_zod18.z.object({ crashed: ArtifactSamplingRule, success: ArtifactSamplingRule });
+
+// src/generated-definitions/FleetArtifactsSampleRules.ts
+var FleetArtifactsSampleRules = import_zod19.z.object({ coredumps: ArtifactTypeSamplingRules, logs: ArtifactTypeSamplingRules });
+
+// src/generated-admin/endpoints/ArtifactsAdmin$.ts
+var ArtifactsAdmin$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA [DELETE] 
+   */
+  deleteArtifact(queryParams) {
+    const params = { ...queryParams };
+    const url = "/ams/v1/admin/namespaces/{namespace}/artifacts".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.delete(url, { params });
+    return import_sdk7.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod20.z.unknown(), "z.unknown()");
+  }
+  /**
+   * Get all artifacts matching the provided search criteria. When criteria is not specified the data returned won't have been filtered on those parameters Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:ARTIFACT [READ] 
+   */
+  getArtifacts(queryParams) {
+    const params = { count: 100, ...queryParams };
+    const url = "/ams/v1/admin/namespaces/{namespace}/artifacts".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk7.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, ArtifactListResponse, "ArtifactListResponse");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:ARTIFACT [READ] 
+   */
+  getArtifactsUsage() {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/artifacts/usage".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk7.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, ArtifactUsageResponse, "ArtifactUsageResponse");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:ARTIFACT [DELETE] 
+   */
+  deleteArtifact_ByArtifactId(artifactID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/artifacts/{artifactID}".replace("{namespace}", this.namespace).replace("{artifactID}", artifactID);
+    const resultPromise = this.axiosInstance.delete(url, { params });
+    return import_sdk7.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod20.z.unknown(), "z.unknown()");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:ARTIFACT [READ] 
+   */
+  getUrl_ByArtifactId(artifactID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/artifacts/{artifactID}/url".replace("{namespace}", this.namespace).replace("{artifactID}", artifactID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk7.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, ArtifactUrlResponse, "ArtifactUrlResponse");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:ARTIFACT [READ] 
+   */
+  getArtifactsSamplingRules_ByFleetId(fleetID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/fleets/{fleetID}/artifacts-sampling-rules".replace("{namespace}", this.namespace).replace("{fleetID}", fleetID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk7.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetArtifactsSampleRules, "FleetArtifactsSampleRules");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:ARTIFACT [UPDATE] 
+   */
+  updateArtifactsSamplingRule_ByFleetId(fleetID, data) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/fleets/{fleetID}/artifacts-sampling-rules".replace("{namespace}", this.namespace).replace("{fleetID}", fleetID);
+    const resultPromise = this.axiosInstance.put(url, data, { params });
+    return import_sdk7.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetArtifactsSampleRules, "FleetArtifactsSampleRules");
+  }
+};
+
+// src/generated-admin/ArtifactsAdminApi.ts
+function ArtifactsAdminApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk8.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk8.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function deleteArtifact(queryParams) {
+    const $ = new ArtifactsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.deleteArtifact(queryParams);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getArtifacts(queryParams) {
+    const $ = new ArtifactsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getArtifacts(queryParams);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getArtifactsUsage() {
+    const $ = new ArtifactsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getArtifactsUsage();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function deleteArtifact_ByArtifactId(artifactID) {
+    const $ = new ArtifactsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.deleteArtifact_ByArtifactId(artifactID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getUrl_ByArtifactId(artifactID) {
+    const $ = new ArtifactsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getUrl_ByArtifactId(artifactID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getArtifactsSamplingRules_ByFleetId(fleetID) {
+    const $ = new ArtifactsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getArtifactsSamplingRules_ByFleetId(fleetID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function updateArtifactsSamplingRule_ByFleetId(fleetID, data) {
+    const $ = new ArtifactsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.updateArtifactsSamplingRule_ByFleetId(fleetID, data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    deleteArtifact,
+    getArtifacts,
+    getArtifactsUsage,
+    deleteArtifact_ByArtifactId,
+    getUrl_ByArtifactId,
+    getArtifactsSamplingRules_ByFleetId,
+    updateArtifactsSamplingRule_ByFleetId
+  };
+}
+
+// src/generated-admin/DevelopmentAdminApi.ts
+var import_sdk10 = require("@accelbyte/sdk");
+
+// src/generated-admin/endpoints/DevelopmentAdmin$.ts
+var import_sdk9 = require("@accelbyte/sdk");
+var import_zod24 = require("zod");
+
+// src/generated-definitions/DevelopmentServerConfigurationCreateResponse.ts
+var import_zod21 = require("zod");
+var DevelopmentServerConfigurationCreateResponse = import_zod21.z.object({ name: import_zod21.z.string() });
+
+// src/generated-definitions/DevelopmentServerConfigurationGetResponse.ts
+var import_zod22 = require("zod");
+var DevelopmentServerConfigurationGetResponse = import_zod22.z.object({
+  commandLineArguments: import_zod22.z.string(),
+  imageId: import_zod22.z.string(),
+  name: import_zod22.z.string()
+});
+
+// src/generated-definitions/DevelopmentServerConfigurationListResponse.ts
+var import_zod23 = require("zod");
+var DevelopmentServerConfigurationListResponse = import_zod23.z.object({
+  data: import_zod23.z.array(DevelopmentServerConfigurationGetResponse),
+  totalData: import_zod23.z.number().int()
+});
+
+// src/generated-admin/endpoints/DevelopmentAdmin$.ts
+var DevelopmentAdmin$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [READ] 
+   */
+  getDevelopmentServerConfigurations(queryParams) {
+    const params = { count: 100, ...queryParams };
+    const url = "/ams/v1/admin/namespaces/{namespace}/development/server-configurations".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk9.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, DevelopmentServerConfigurationListResponse, "DevelopmentServerConfigurationListResponse");
+  }
+  /**
+   * Configuration name can be up to 128 characters and must conform to ^[.a-zA-Z0-9_-]+$ Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [CREATE] 
+   */
+  createDevelopmentServerConfiguration(data) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/development/server-configurations".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.post(url, data, { params });
+    return import_sdk9.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, DevelopmentServerConfigurationCreateResponse, "DevelopmentServerConfigurationCreateResponse");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [DELETE] 
+   */
+  deleteDevelopmentServerConfiguration_ByDevelopmentServerConfigId(developmentServerConfigID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/development/server-configurations/{developmentServerConfigID}".replace("{namespace}", this.namespace).replace("{developmentServerConfigID}", developmentServerConfigID);
+    const resultPromise = this.axiosInstance.delete(url, { params });
+    return import_sdk9.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod24.z.unknown(), "z.unknown()");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [READ] 
+   */
+  getDevelopmentServerConfiguration_ByDevelopmentServerConfigId(developmentServerConfigID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/development/server-configurations/{developmentServerConfigID}".replace("{namespace}", this.namespace).replace("{developmentServerConfigID}", developmentServerConfigID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk9.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, DevelopmentServerConfigurationGetResponse, "DevelopmentServerConfigurationGetResponse");
+  }
+};
+
+// src/generated-admin/DevelopmentAdminApi.ts
+function DevelopmentAdminApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk10.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk10.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getDevelopmentServerConfigurations(queryParams) {
+    const $ = new DevelopmentAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getDevelopmentServerConfigurations(queryParams);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function createDevelopmentServerConfiguration(data) {
+    const $ = new DevelopmentAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.createDevelopmentServerConfiguration(data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function deleteDevelopmentServerConfiguration_ByDevelopmentServerConfigId(developmentServerConfigID) {
+    const $ = new DevelopmentAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.deleteDevelopmentServerConfiguration_ByDevelopmentServerConfigId(developmentServerConfigID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getDevelopmentServerConfiguration_ByDevelopmentServerConfigId(developmentServerConfigID) {
+    const $ = new DevelopmentAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getDevelopmentServerConfiguration_ByDevelopmentServerConfigId(developmentServerConfigID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getDevelopmentServerConfigurations,
+    createDevelopmentServerConfiguration,
+    deleteDevelopmentServerConfiguration_ByDevelopmentServerConfigId,
+    getDevelopmentServerConfiguration_ByDevelopmentServerConfigId
+  };
+}
+
+// src/generated-admin/FleetsAdminApi.ts
+var import_sdk12 = require("@accelbyte/sdk");
+
+// src/generated-admin/endpoints/FleetsAdmin$.ts
+var import_sdk11 = require("@accelbyte/sdk");
+var import_zod38 = require("zod");
+
+// src/generated-definitions/FleetCreateResponse.ts
+var import_zod25 = require("zod");
+var FleetCreateResponse = import_zod25.z.object({ id: import_zod25.z.string() });
+
+// src/generated-definitions/FleetGetResponse.ts
+var import_zod31 = require("zod");
+
+// src/generated-definitions/DsHostConfiguration.ts
+var import_zod26 = require("zod");
+var DsHostConfiguration = import_zod26.z.object({ instanceId: import_zod26.z.string(), instanceType: import_zod26.z.string(), serversPerVm: import_zod26.z.number().int() });
+
+// src/generated-definitions/ImageDeploymentProfile.ts
+var import_zod29 = require("zod");
+
+// src/generated-definitions/PortConfiguration.ts
+var import_zod27 = require("zod");
+var PortConfiguration = import_zod27.z.object({ name: import_zod27.z.string(), protocol: import_zod27.z.string() });
+
+// src/generated-definitions/Timeout.ts
+var import_zod28 = require("zod");
+var Timeout = import_zod28.z.object({
+  creation: import_zod28.z.number().int(),
+  drain: import_zod28.z.number().int(),
+  session: import_zod28.z.number().int(),
+  unresponsive: import_zod28.z.number().int()
+});
+
+// src/generated-definitions/ImageDeploymentProfile.ts
+var ImageDeploymentProfile = import_zod29.z.object({
+  commandLine: import_zod29.z.string(),
+  imageId: import_zod29.z.string(),
+  portConfigurations: import_zod29.z.array(PortConfiguration),
+  timeout: Timeout
+});
+
+// src/generated-definitions/RegionConfig.ts
+var import_zod30 = require("zod");
+var RegionConfig = import_zod30.z.object({
+  bufferSize: import_zod30.z.number().int(),
+  dynamicBuffer: import_zod30.z.boolean(),
+  maxServerCount: import_zod30.z.number().int(),
+  minServerCount: import_zod30.z.number().int(),
+  region: import_zod30.z.string()
+});
+
+// src/generated-definitions/FleetGetResponse.ts
+var FleetGetResponse = import_zod31.z.object({
+  active: import_zod31.z.boolean(),
+  claimKeys: import_zod31.z.array(import_zod31.z.string()),
+  dsHostConfiguration: DsHostConfiguration,
+  id: import_zod31.z.string(),
+  imageDeploymentProfile: ImageDeploymentProfile,
+  isLocal: import_zod31.z.boolean(),
+  name: import_zod31.z.string(),
+  onDemand: import_zod31.z.boolean(),
+  regions: import_zod31.z.array(RegionConfig),
+  samplingRules: FleetArtifactsSampleRules
+});
+
+// src/generated-definitions/FleetListResponse.ts
+var import_zod34 = require("zod");
+
+// src/generated-definitions/FleetListItemResponse.ts
+var import_zod33 = require("zod");
+
+// src/generated-definitions/FleetRegionalServerCounts.ts
+var import_zod32 = require("zod");
+var FleetRegionalServerCounts = import_zod32.z.object({
+  claimedServerCount: import_zod32.z.number().int(),
+  readyServerCount: import_zod32.z.number().int(),
+  region: import_zod32.z.string(),
+  runningVmCount: import_zod32.z.number().int(),
+  targetDsCount: import_zod32.z.number().int(),
+  targetVmCount: import_zod32.z.number().int()
+});
+
+// src/generated-definitions/FleetListItemResponse.ts
+var FleetListItemResponse = import_zod33.z.object({
+  active: import_zod33.z.boolean(),
+  counts: import_zod33.z.array(FleetRegionalServerCounts),
+  id: import_zod33.z.string(),
+  image: import_zod33.z.string(),
+  isLocal: import_zod33.z.boolean(),
+  name: import_zod33.z.string(),
+  onDemand: import_zod33.z.boolean(),
+  regions: import_zod33.z.array(import_zod33.z.string())
+});
+
+// src/generated-definitions/FleetListResponse.ts
+var FleetListResponse = import_zod34.z.object({ fleets: import_zod34.z.array(FleetListItemResponse) });
+
+// src/generated-definitions/FleetServersResponse.ts
+var import_zod37 = require("zod");
+
+// src/generated-definitions/FleetServerInfoResponse.ts
+var import_zod35 = require("zod");
+var FleetServerInfoResponse = import_zod35.z.object({
+  createdAt: import_zod35.z.string(),
+  fleetId: import_zod35.z.string(),
+  fleetName: import_zod35.z.string(),
+  imageCmd: import_zod35.z.string(),
+  imageId: import_zod35.z.string(),
+  instanceType: import_zod35.z.string(),
+  ipAddress: import_zod35.z.string(),
+  portConfiguration: import_zod35.z.array(PortConfiguration),
+  ports: import_zod35.z.record(import_zod35.z.number().int()),
+  region: import_zod35.z.string(),
+  serverConfiguration: import_zod35.z.string(),
+  serverId: import_zod35.z.string(),
+  sessionId: import_zod35.z.string(),
+  status: import_zod35.z.string()
+});
+
+// src/generated-definitions/PagingInfo.ts
+var import_zod36 = require("zod");
+var PagingInfo = import_zod36.z.object({
+  currentPage: import_zod36.z.number().int(),
+  hasNext: import_zod36.z.boolean(),
+  hasPages: import_zod36.z.boolean(),
+  hasPrev: import_zod36.z.boolean(),
+  next: import_zod36.z.string(),
+  pageNums: import_zod36.z.array(import_zod36.z.number().int()),
+  previous: import_zod36.z.string(),
+  total: import_zod36.z.number().int()
+});
+
+// src/generated-definitions/FleetServersResponse.ts
+var FleetServersResponse = import_zod37.z.object({
+  paging: PagingInfo,
+  regions: import_zod37.z.array(FleetRegionalServerCounts),
+  servers: import_zod37.z.array(FleetServerInfoResponse)
+});
+
+// src/generated-admin/endpoints/FleetsAdmin$.ts
+var FleetsAdmin$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [READ] 
+   */
+  getFleets() {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/fleets".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk11.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetListResponse, "FleetListResponse");
+  }
+  /**
+   * Optionally, sampling rules for the fleet can also be specified Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [CREATE] 
+   */
+  createFleet(data) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/fleets".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.post(url, data, { params });
+    return import_sdk11.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetCreateResponse, "FleetCreateResponse");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [DELETE] 
+   */
+  deleteFleet_ByFleetId(fleetID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/fleets/{fleetID}".replace("{namespace}", this.namespace).replace("{fleetID}", fleetID);
+    const resultPromise = this.axiosInstance.delete(url, { params });
+    return import_sdk11.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod38.z.unknown(), "z.unknown()");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [READ] 
+   */
+  getFleet_ByFleetId(fleetID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/fleets/{fleetID}".replace("{namespace}", this.namespace).replace("{fleetID}", fleetID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk11.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetGetResponse, "FleetGetResponse");
+  }
+  /**
+   * Optionally, sampling rules for the fleet can also be updated Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [UPDATE] 
+   */
+  updateFleet_ByFleetId(fleetID, data) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/fleets/{fleetID}".replace("{namespace}", this.namespace).replace("{fleetID}", fleetID);
+    const resultPromise = this.axiosInstance.put(url, data, { params });
+    return import_sdk11.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod38.z.unknown(), "z.unknown()");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [READ] 
+   */
+  getServers_ByFleetId(fleetID, queryParams) {
+    const params = { ...queryParams };
+    const url = "/ams/v1/admin/namespaces/{namespace}/fleets/{fleetID}/servers".replace("{namespace}", this.namespace).replace("{fleetID}", fleetID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk11.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetServersResponse, "FleetServersResponse");
+  }
+};
+
+// src/generated-admin/FleetsAdminApi.ts
+function FleetsAdminApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk12.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk12.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getFleets() {
+    const $ = new FleetsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getFleets();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function createFleet(data) {
+    const $ = new FleetsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.createFleet(data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function deleteFleet_ByFleetId(fleetID) {
+    const $ = new FleetsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.deleteFleet_ByFleetId(fleetID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getFleet_ByFleetId(fleetID) {
+    const $ = new FleetsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getFleet_ByFleetId(fleetID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function updateFleet_ByFleetId(fleetID, data) {
+    const $ = new FleetsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.updateFleet_ByFleetId(fleetID, data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getServers_ByFleetId(fleetID, queryParams) {
+    const $ = new FleetsAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getServers_ByFleetId(fleetID, queryParams);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getFleets,
+    createFleet,
+    deleteFleet_ByFleetId,
+    getFleet_ByFleetId,
+    updateFleet_ByFleetId,
+    getServers_ByFleetId
+  };
+}
+
+// src/generated-admin/ImagesAdminApi.ts
+var import_sdk14 = require("@accelbyte/sdk");
+
+// src/generated-admin/endpoints/ImagesAdmin$.ts
+var import_sdk13 = require("@accelbyte/sdk");
+var import_zod44 = require("zod");
+
+// src/generated-definitions/ImageDetails.ts
+var import_zod40 = require("zod");
+
+// src/generated-definitions/ReferencingFleet.ts
+var import_zod39 = require("zod");
+var ReferencingFleet = import_zod39.z.object({ environment: import_zod39.z.string(), fleetId: import_zod39.z.string(), namespace: import_zod39.z.string() });
+
+// src/generated-definitions/ImageDetails.ts
+var ImageDetails = import_zod40.z.object({
+  createdAt: Time,
+  deleteAt: Time,
+  executable: import_zod40.z.string(),
+  id: import_zod40.z.string(),
+  isProtected: import_zod40.z.boolean(),
+  name: import_zod40.z.string(),
+  referencingFleets: import_zod40.z.array(ReferencingFleet),
+  sizeInByte: import_zod40.z.number().int(),
+  status: import_zod40.z.string(),
+  tags: import_zod40.z.array(import_zod40.z.string()),
+  uploadedAt: Time,
+  uploadedBy: import_zod40.z.string()
+});
+
+// src/generated-definitions/ImageList.ts
+var import_zod42 = require("zod");
+
+// src/generated-definitions/ImageListItem.ts
+var import_zod41 = require("zod");
+var ImageListItem = import_zod41.z.object({
+  createdAt: Time,
+  deleteAt: Time,
+  executable: import_zod41.z.string(),
+  id: import_zod41.z.string(),
+  isProtected: import_zod41.z.boolean(),
+  name: import_zod41.z.string(),
+  referencingFleets: import_zod41.z.number().int(),
+  sizeInByte: import_zod41.z.number().int(),
+  status: import_zod41.z.string(),
+  tags: import_zod41.z.array(import_zod41.z.string()),
+  uploadedAt: Time,
+  uploadedBy: import_zod41.z.string()
+});
+
+// src/generated-definitions/ImageList.ts
+var ImageList = import_zod42.z.object({ images: import_zod42.z.array(ImageListItem) });
+
+// src/generated-definitions/ImageStorage.ts
+var import_zod43 = require("zod");
+var ImageStorage = import_zod43.z.object({
+  currentMarkedForDeletionBytes: import_zod43.z.number().int(),
+  currentUsageBytes: import_zod43.z.number().int(),
+  quotaBytes: import_zod43.z.number().int()
+});
+
+// src/generated-admin/endpoints/ImagesAdmin$.ts
+var ImagesAdmin$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Returns images which exist (uploaded, uploading, or building) in the linked account. This route fails if no account is linked Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:IMAGE [READ] 
+   */
+  getImages() {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/images".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk13.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, ImageList, "ImageList");
+  }
+  /**
+   * Returns information regarding the account's usage for images storage including the free tier quota Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:IMAGE [READ] 
+   */
+  getImagesStorage() {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/images-storage".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk13.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, ImageStorage, "ImageStorage");
+  }
+  /**
+   * Marks an image for deletion. The image will stop being available for fleets and will eventually be deleted. Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:IMAGE [DELETE] 
+   */
+  deleteImage_ByImageId(imageID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/images/{imageID}".replace("{namespace}", this.namespace).replace("{imageID}", imageID);
+    const resultPromise = this.axiosInstance.delete(url, { params });
+    return import_sdk13.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod44.z.unknown(), "z.unknown()");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:IMAGE [READ] 
+   */
+  getImage_ByImageId(imageID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/images/{imageID}".replace("{namespace}", this.namespace).replace("{imageID}", imageID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk13.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, ImageDetails, "ImageDetails");
+  }
+  /**
+   * This allows editing of the image name, toggling `IsProtected`, or adding & removal of tags Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:IMAGE [UPDATE] 
+   */
+  patchImage_ByImageId(imageID, data) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/images/{imageID}".replace("{namespace}", this.namespace).replace("{imageID}", imageID);
+    const resultPromise = this.axiosInstance.patch(url, data, { params });
+    return import_sdk13.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, ImageDetails, "ImageDetails");
+  }
+  /**
+   * Unmarks an image for deletion. The image will be available for fleets. Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:IMAGE [DELETE] 
+   */
+  createRestore_ByImageId(imageID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/images/{imageID}/restore".replace("{namespace}", this.namespace).replace("{imageID}", imageID);
+    const resultPromise = this.axiosInstance.post(url, null, { params });
+    return import_sdk13.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod44.z.unknown(), "z.unknown()");
+  }
+};
+
+// src/generated-admin/ImagesAdminApi.ts
+function ImagesAdminApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk14.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk14.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getImages() {
+    const $ = new ImagesAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getImages();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getImagesStorage() {
+    const $ = new ImagesAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getImagesStorage();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function deleteImage_ByImageId(imageID) {
+    const $ = new ImagesAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.deleteImage_ByImageId(imageID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getImage_ByImageId(imageID) {
+    const $ = new ImagesAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getImage_ByImageId(imageID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function patchImage_ByImageId(imageID, data) {
+    const $ = new ImagesAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.patchImage_ByImageId(imageID, data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function createRestore_ByImageId(imageID) {
+    const $ = new ImagesAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.createRestore_ByImageId(imageID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getImages,
+    getImagesStorage,
+    deleteImage_ByImageId,
+    getImage_ByImageId,
+    patchImage_ByImageId,
+    createRestore_ByImageId
+  };
+}
+
+// src/generated-admin/ServersAdminApi.ts
+var import_sdk16 = require("@accelbyte/sdk");
+
+// src/generated-admin/endpoints/ServersAdmin$.ts
+var import_sdk15 = require("@accelbyte/sdk");
+
+// src/generated-definitions/DsHistoryList.ts
+var import_zod46 = require("zod");
+
+// src/generated-definitions/DsHistoryEvent.ts
+var import_zod45 = require("zod");
+var DsHistoryEvent = import_zod45.z.object({
+  createdAt: Time,
+  exitCode: import_zod45.z.number().int(),
+  ipAddress: import_zod45.z.string(),
+  reason: import_zod45.z.string(),
+  region: import_zod45.z.string(),
+  serverId: import_zod45.z.string(),
+  status: import_zod45.z.string()
+});
+
+// src/generated-definitions/DsHistoryList.ts
+var DsHistoryList = import_zod46.z.object({ events: import_zod46.z.array(DsHistoryEvent), paging: PagingInfo });
+
+// src/generated-definitions/FleetServerConnectionInfoResponse.ts
+var import_zod47 = require("zod");
+var FleetServerConnectionInfoResponse = import_zod47.z.object({
+  expiresAt: Time,
+  host: import_zod47.z.string(),
+  logstreamPort: import_zod47.z.number().int(),
+  secret: import_zod47.z.string()
+});
+
+// src/generated-definitions/FleetServerHistoryResponse.ts
+var import_zod49 = require("zod");
+
+// src/generated-definitions/FleetServerHistoryEventResponse.ts
+var import_zod48 = require("zod");
+var FleetServerHistoryEventResponse = import_zod48.z.object({
+  createdAt: Time,
+  exitCode: import_zod48.z.number().int(),
+  fleetId: import_zod48.z.string(),
+  newState: import_zod48.z.string(),
+  oldState: import_zod48.z.string(),
+  reason: import_zod48.z.string(),
+  serverId: import_zod48.z.string()
+});
+
+// src/generated-definitions/FleetServerHistoryResponse.ts
+var FleetServerHistoryResponse = import_zod49.z.object({ events: import_zod49.z.array(FleetServerHistoryEventResponse) });
+
+// src/generated-admin/endpoints/ServersAdmin$.ts
+var ServersAdmin$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [READ] 
+   */
+  getServer_ByServerId(serverID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/servers/{serverID}".replace("{namespace}", this.namespace).replace("{serverID}", serverID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk15.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetServerInfoResponse, "FleetServerInfoResponse");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [READ] 
+   */
+  getHistory_ByServerId(serverID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/servers/{serverID}/history".replace("{namespace}", this.namespace).replace("{serverID}", serverID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk15.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetServerHistoryResponse, "FleetServerHistoryResponse");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:ARMADA:FLEET [READ] 
+   */
+  getServersHistory_ByFleetId(fleetID, queryParams) {
+    const params = { ...queryParams };
+    const url = "/ams/v1/admin/namespaces/{namespace}/fleets/{fleetID}/servers/history".replace("{namespace}", this.namespace).replace("{fleetID}", fleetID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk15.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, DsHistoryList, "DsHistoryList");
+  }
+  /**
+   * Required Permission: ADMIN:NAMESPACE:{namespace}:AMS:DS:LOGS [READ] 
+   */
+  getConnectioninfo_ByServerId(serverID) {
+    const params = {};
+    const url = "/ams/v1/admin/namespaces/{namespace}/servers/{serverID}/connectioninfo".replace("{namespace}", this.namespace).replace("{serverID}", serverID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk15.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetServerConnectionInfoResponse, "FleetServerConnectionInfoResponse");
+  }
+};
+
+// src/generated-admin/ServersAdminApi.ts
+function ServersAdminApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk16.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk16.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getServer_ByServerId(serverID) {
+    const $ = new ServersAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getServer_ByServerId(serverID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getHistory_ByServerId(serverID) {
+    const $ = new ServersAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getHistory_ByServerId(serverID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getServersHistory_ByFleetId(fleetID, queryParams) {
+    const $ = new ServersAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getServersHistory_ByFleetId(fleetID, queryParams);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getConnectioninfo_ByServerId(serverID) {
+    const $ = new ServersAdmin$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getConnectioninfo_ByServerId(serverID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getServer_ByServerId,
+    getHistory_ByServerId,
+    getServersHistory_ByFleetId,
+    getConnectioninfo_ByServerId
+  };
+}
+
+// src/generated-public/AccountApi.ts
+var import_sdk18 = require("@accelbyte/sdk");
+
+// src/generated-public/endpoints/Account$.ts
+var import_sdk17 = require("@accelbyte/sdk");
+var Account$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Required Permission: NAMESPACE:{namespace}:AMS:ACCOUNT [READ] 
+   */
+  getAccount() {
+    const params = {};
+    const url = "/ams/v1/namespaces/{namespace}/account".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk17.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, AccountResponse, "AccountResponse");
+  }
+};
+
+// src/generated-public/AccountApi.ts
+function AccountApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk18.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk18.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getAccount() {
+    const $ = new Account$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getAccount();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getAccount
+  };
+}
+
+// src/generated-public/AmsInfoApi.ts
+var import_sdk20 = require("@accelbyte/sdk");
+
+// src/generated-public/endpoints/AmsInfo$.ts
+var import_sdk19 = require("@accelbyte/sdk");
+var import_zod50 = require("zod");
+var AmsInfo$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  getUploadUrl() {
+    const params = {};
+    const url = "/ams/v1/upload-url";
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk19.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod50.z.unknown(), "z.unknown()");
+  }
+};
+
+// src/generated-public/AmsInfoApi.ts
+function AmsInfoApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk20.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk20.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getUploadUrl() {
+    const $ = new AmsInfo$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getUploadUrl();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getUploadUrl
+  };
+}
+
+// src/generated-public/AuthApi.ts
+var import_sdk22 = require("@accelbyte/sdk");
+
+// src/generated-public/endpoints/Auth$.ts
+var import_sdk21 = require("@accelbyte/sdk");
+var import_zod51 = require("zod");
+var Auth$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Check if fleet commander is authorized to talk to AMS with this IAM 
+   */
+  getAuth() {
+    const params = {};
+    const url = "/ams/auth";
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk21.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod51.z.unknown(), "z.unknown()");
+  }
+};
+
+// src/generated-public/AuthApi.ts
+function AuthApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk22.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk22.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getAuth() {
+    const $ = new Auth$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getAuth();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getAuth
+  };
+}
+
+// src/generated-public/FleetCommanderApi.ts
+var import_sdk24 = require("@accelbyte/sdk");
+
+// src/generated-public/endpoints/FleetCommander$.ts
+var import_sdk23 = require("@accelbyte/sdk");
+var import_zod52 = require("zod");
+var FleetCommander$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  getVersion() {
+    const params = {};
+    const url = "/ams/version";
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk23.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod52.z.unknown(), "z.unknown()");
+  }
+};
+
+// src/generated-public/FleetCommanderApi.ts
+function FleetCommanderApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk24.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk24.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getVersion() {
+    const $ = new FleetCommander$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getVersion();
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getVersion
+  };
+}
+
+// src/generated-public/FleetsApi.ts
+var import_sdk26 = require("@accelbyte/sdk");
+
+// src/generated-public/endpoints/Fleets$.ts
+var import_sdk25 = require("@accelbyte/sdk");
+
+// src/generated-definitions/FleetClaimResponse.ts
+var import_zod53 = require("zod");
+var FleetClaimResponse = import_zod53.z.object({ ip: import_zod53.z.string(), ports: import_zod53.z.record(import_zod53.z.number().int()), region: import_zod53.z.string(), serverId: import_zod53.z.string() });
+
+// src/generated-public/endpoints/Fleets$.ts
+var Fleets$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * Claim a dedicated server from fleets with matching claim keys Required Permission: NAMESPACE:{namespace}:AMS:SERVER:CLAIM [UPDATE] 
+   */
+  updateServerClaim(data) {
+    const params = {};
+    const url = "/ams/v1/namespaces/{namespace}/servers/claim".replace("{namespace}", this.namespace);
+    const resultPromise = this.axiosInstance.put(url, data, { params });
+    return import_sdk25.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetClaimResponse, "FleetClaimResponse");
+  }
+  /**
+   * Required Permission: NAMESPACE:{namespace}:AMS:SERVER:CLAIM [UPDATE] 
+   */
+  updateClaim_ByFleetId(fleetID, data) {
+    const params = {};
+    const url = "/ams/v1/namespaces/{namespace}/fleets/{fleetID}/claim".replace("{namespace}", this.namespace).replace("{fleetID}", fleetID);
+    const resultPromise = this.axiosInstance.put(url, data, { params });
+    return import_sdk25.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, FleetClaimResponse, "FleetClaimResponse");
+  }
+};
+
+// src/generated-public/FleetsApi.ts
+function FleetsApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk26.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk26.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function updateServerClaim(data) {
+    const $ = new Fleets$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.updateServerClaim(data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function updateClaim_ByFleetId(fleetID, data) {
+    const $ = new Fleets$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.updateClaim_ByFleetId(fleetID, data);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    updateServerClaim,
+    updateClaim_ByFleetId
+  };
+}
+
+// src/generated-public/WatchdogsApi.ts
+var import_sdk28 = require("@accelbyte/sdk");
+
+// src/generated-public/endpoints/Watchdogs$.ts
+var import_sdk27 = require("@accelbyte/sdk");
+var import_zod54 = require("zod");
+var Watchdogs$ = class {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(axiosInstance, namespace, useSchemaValidation = true) {
+    this.axiosInstance = axiosInstance;
+    this.namespace = namespace;
+    this.useSchemaValidation = useSchemaValidation;
+  }
+  /**
+   * This is to support local ds development scenarios Required Permission: NAMESPACE:{namespace}:AMS:LOCALDS [CREATE] 
+   */
+  getConnect_ByWatchdogId(watchdogID) {
+    const params = {};
+    const url = "/ams/v1/namespaces/{namespace}/local/{watchdogID}/connect".replace("{namespace}", this.namespace).replace("{watchdogID}", watchdogID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk27.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod54.z.unknown(), "z.unknown()");
+  }
+  /**
+   * Required Permission: NAMESPACE:{namespace}:ARMADA:WATCHDOG [CREATE] 
+   */
+  getConnect_ByWatchdogId_ByNS(watchdogID) {
+    const params = {};
+    const url = "/ams/v1/namespaces/{namespace}/watchdogs/{watchdogID}/connect".replace("{namespace}", this.namespace).replace("{watchdogID}", watchdogID);
+    const resultPromise = this.axiosInstance.get(url, { params });
+    return import_sdk27.Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, import_zod54.z.unknown(), "z.unknown()");
+  }
+};
+
+// src/generated-public/WatchdogsApi.ts
+function WatchdogsApi(sdk, args) {
+  const sdkAssembly = sdk.assembly();
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace;
+  const requestConfig = import_sdk28.ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request);
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? [];
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation;
+  const axiosInstance = import_sdk28.Network.create(requestConfig);
+  for (const interceptor of interceptors) {
+    if (interceptor.type === "request") {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError);
+    }
+    if (interceptor.type === "response") {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError);
+    }
+  }
+  async function getConnect_ByWatchdogId(watchdogID) {
+    const $ = new Watchdogs$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getConnect_ByWatchdogId(watchdogID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  async function getConnect_ByWatchdogId_ByNS(watchdogID) {
+    const $ = new Watchdogs$(axiosInstance, namespace, useSchemaValidation);
+    const resp = await $.getConnect_ByWatchdogId_ByNS(watchdogID);
+    if (resp.error) throw resp.error;
+    return resp.response;
+  }
+  return {
+    getConnect_ByWatchdogId,
+    getConnect_ByWatchdogId_ByNS
+  };
+}
+
+// src/Ams.ts
+var apis = {
+  AmsQoSAdminApi,
+  FleetsAdminApi,
+  ImagesAdminApi,
+  AccountAdminApi,
+  AmsInfoAdminApi,
+  ArtifactsAdminApi,
+  ServersAdminApi,
+  DevelopmentAdminApi,
+  AuthApi,
+  FleetCommanderApi,
+  AmsInfoApi,
+  AccountApi,
+  FleetsApi,
+  WatchdogsApi
+};
+var Ams = apis;
+
+// src/generated-definitions/AccountCreateRequest.ts
+var import_zod55 = require("zod");
+var AccountCreateRequest = import_zod55.z.object({ name: import_zod55.z.string() });
+
+// src/generated-definitions/AccountLinkRequest.ts
+var import_zod56 = require("zod");
+var AccountLinkRequest = import_zod56.z.object({ token: import_zod56.z.string() });
+
+// src/generated-definitions/DevelopmentServerConfigurationCreateRequest.ts
+var import_zod57 = require("zod");
+var DevelopmentServerConfigurationCreateRequest = import_zod57.z.object({
+  commandLineArguments: import_zod57.z.string(),
+  imageId: import_zod57.z.string(),
+  name: import_zod57.z.string()
+});
+
+// src/generated-definitions/ErrorResponse.ts
+var import_zod58 = require("zod");
+var ErrorResponse = import_zod58.z.object({ errorMessage: import_zod58.z.string(), errorType: import_zod58.z.string(), traceId: import_zod58.z.string() });
+
+// src/generated-definitions/FleetClaimByKeysReq.ts
+var import_zod59 = require("zod");
+var FleetClaimByKeysReq = import_zod59.z.object({ claimKeys: import_zod59.z.array(import_zod59.z.string()), regions: import_zod59.z.array(import_zod59.z.string()), sessionId: import_zod59.z.string() });
+
+// src/generated-definitions/FleetClaimReq.ts
+var import_zod60 = require("zod");
+var FleetClaimReq = import_zod60.z.object({ region: import_zod60.z.string(), sessionId: import_zod60.z.string() });
+
+// src/generated-definitions/FleetParameters.ts
+var import_zod61 = require("zod");
+var FleetParameters = import_zod61.z.object({
+  active: import_zod61.z.boolean(),
+  claimKeys: import_zod61.z.array(import_zod61.z.string()).nullish(),
+  dsHostConfiguration: DsHostConfiguration,
+  imageDeploymentProfile: ImageDeploymentProfile,
+  name: import_zod61.z.string(),
+  onDemand: import_zod61.z.boolean(),
+  regions: import_zod61.z.array(RegionConfig),
+  samplingRules: FleetArtifactsSampleRules.nullish()
+});
+
+// src/generated-definitions/ImageUpdate.ts
+var import_zod62 = require("zod");
+var ImageUpdate = import_zod62.z.object({
+  addedTags: import_zod62.z.array(import_zod62.z.string()),
+  isProtected: import_zod62.z.boolean(),
+  name: import_zod62.z.string(),
+  removedTags: import_zod62.z.array(import_zod62.z.string())
+});
+
+// src/generated-definitions/Location.ts
+var import_zod65 = require("zod");
+
+// src/generated-definitions/Zone.ts
+var import_zod63 = require("zod");
+var Zone = import_zod63.z.object({ isDST: import_zod63.z.boolean(), name: import_zod63.z.string(), offset: import_zod63.z.number().int() });
+
+// src/generated-definitions/ZoneTrans.ts
+var import_zod64 = require("zod");
+var ZoneTrans = import_zod64.z.object({ index: import_zod64.z.number().int(), isstd: import_zod64.z.boolean(), isutc: import_zod64.z.boolean(), when: import_zod64.z.number().int() });
+
+// src/generated-definitions/Location.ts
+var Location = import_zod65.z.object({
+  cacheEnd: import_zod65.z.number().int(),
+  cacheStart: import_zod65.z.number().int(),
+  cacheZone: Zone,
+  extend: import_zod65.z.string(),
+  name: import_zod65.z.string(),
+  tx: import_zod65.z.array(ZoneTrans),
+  zone: import_zod65.z.array(Zone)
+});
+
+// src/generated-definitions/UpdateServerRequest.ts
+var import_zod66 = require("zod");
+var UpdateServerRequest = import_zod66.z.object({ status: import_zod66.z.string() });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Account$,
+  AccountAdmin$,
+  AccountAdminApi,
+  AccountApi,
+  AccountCreateRequest,
+  AccountCreateResponse,
+  AccountLimits,
+  AccountLinkRequest,
+  AccountLinkResponse,
+  AccountLinkTokenResponse,
+  AccountResponse,
+  Ams,
+  AmsInfo$,
+  AmsInfoAdmin$,
+  AmsInfoAdminApi,
+  AmsInfoApi,
+  AmsQoSAdmin$,
+  AmsQoSAdminApi,
+  AmsRegionsResponse,
+  ArtifactListResponse,
+  ArtifactResponse,
+  ArtifactSamplingRule,
+  ArtifactTypeSamplingRules,
+  ArtifactUrlResponse,
+  ArtifactUsageResponse,
+  ArtifactsAdmin$,
+  ArtifactsAdminApi,
+  Auth$,
+  AuthApi,
+  AvailableInstanceTypesResponse,
+  DevelopmentAdmin$,
+  DevelopmentAdminApi,
+  DevelopmentServerConfigurationCreateRequest,
+  DevelopmentServerConfigurationCreateResponse,
+  DevelopmentServerConfigurationGetResponse,
+  DevelopmentServerConfigurationListResponse,
+  DsHistoryEvent,
+  DsHistoryList,
+  DsHostConfiguration,
+  ErrorResponse,
+  FleetArtifactsSampleRules,
+  FleetClaimByKeysReq,
+  FleetClaimReq,
+  FleetClaimResponse,
+  FleetCommander$,
+  FleetCommanderApi,
+  FleetCreateResponse,
+  FleetGetResponse,
+  FleetListItemResponse,
+  FleetListResponse,
+  FleetParameters,
+  FleetRegionalServerCounts,
+  FleetServerConnectionInfoResponse,
+  FleetServerHistoryEventResponse,
+  FleetServerHistoryResponse,
+  FleetServerInfoResponse,
+  FleetServersResponse,
+  Fleets$,
+  FleetsAdmin$,
+  FleetsAdminApi,
+  FleetsApi,
+  ImageDeploymentProfile,
+  ImageDetails,
+  ImageList,
+  ImageListItem,
+  ImageStorage,
+  ImageUpdate,
+  ImagesAdmin$,
+  ImagesAdminApi,
+  InstanceTypeDescriptionResponse,
+  Location,
+  PagingInfo,
+  PortConfiguration,
+  QoSEndpointResponse,
+  QoSServer,
+  ReferencingFleet,
+  RegionConfig,
+  ServersAdmin$,
+  ServersAdminApi,
+  Time,
+  Timeout,
+  UpdateServerRequest,
+  Watchdogs$,
+  WatchdogsApi,
+  Zone,
+  ZoneTrans
+});