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

package/dist/all-query-imports.cjs

@@ -0,0 +1,2382 @@
+"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/all-query-imports.ts
+var all_query_imports_exports = {};
+__export(all_query_imports_exports, {
+  Key_Account: () => Key_Account,
+  Key_AccountAdmin: () => Key_AccountAdmin,
+  Key_AmsInfo: () => Key_AmsInfo,
+  Key_AmsInfoAdmin: () => Key_AmsInfoAdmin,
+  Key_AmsQoSAdmin: () => Key_AmsQoSAdmin,
+  Key_ArtifactsAdmin: () => Key_ArtifactsAdmin,
+  Key_Auth: () => Key_Auth,
+  Key_DevelopmentAdmin: () => Key_DevelopmentAdmin,
+  Key_FleetCommander: () => Key_FleetCommander,
+  Key_Fleets: () => Key_Fleets,
+  Key_FleetsAdmin: () => Key_FleetsAdmin,
+  Key_ImagesAdmin: () => Key_ImagesAdmin,
+  Key_ServersAdmin: () => Key_ServersAdmin,
+  Key_Watchdogs: () => Key_Watchdogs,
+  useAccountAdminApi_CreateAccount: () => useAccountAdminApi_CreateAccount,
+  useAccountAdminApi_CreateAccountLink: () => useAccountAdminApi_CreateAccountLink,
+  useAccountAdminApi_GetAccount: () => useAccountAdminApi_GetAccount,
+  useAccountAdminApi_GetAccountLink: () => useAccountAdminApi_GetAccountLink,
+  useAccountApi_GetAccount: () => useAccountApi_GetAccount,
+  useAmsInfoAdminApi_GetRegions: () => useAmsInfoAdminApi_GetRegions,
+  useAmsInfoAdminApi_GetSupportedInstances: () => useAmsInfoAdminApi_GetSupportedInstances,
+  useAmsInfoApi_GetUploadUrl: () => useAmsInfoApi_GetUploadUrl,
+  useAmsQoSAdminApi_GetQos: () => useAmsQoSAdminApi_GetQos,
+  useAmsQoSAdminApi_PatchQo_ByRegion: () => useAmsQoSAdminApi_PatchQo_ByRegion,
+  useArtifactsAdminApi_DeleteArtifact: () => useArtifactsAdminApi_DeleteArtifact,
+  useArtifactsAdminApi_DeleteArtifact_ByArtifactId: () => useArtifactsAdminApi_DeleteArtifact_ByArtifactId,
+  useArtifactsAdminApi_GetArtifacts: () => useArtifactsAdminApi_GetArtifacts,
+  useArtifactsAdminApi_GetArtifactsSamplingRules_ByFleetId: () => useArtifactsAdminApi_GetArtifactsSamplingRules_ByFleetId,
+  useArtifactsAdminApi_GetArtifactsUsage: () => useArtifactsAdminApi_GetArtifactsUsage,
+  useArtifactsAdminApi_GetUrl_ByArtifactId: () => useArtifactsAdminApi_GetUrl_ByArtifactId,
+  useArtifactsAdminApi_UpdateArtifactsSamplingRule_ByFleetId: () => useArtifactsAdminApi_UpdateArtifactsSamplingRule_ByFleetId,
+  useAuthApi_GetAuth: () => useAuthApi_GetAuth,
+  useDevelopmentAdminApi_CreateDevelopmentServerConfiguration: () => useDevelopmentAdminApi_CreateDevelopmentServerConfiguration,
+  useDevelopmentAdminApi_DeleteDevelopmentServerConfiguration_ByDevelopmentServerConfigId: () => useDevelopmentAdminApi_DeleteDevelopmentServerConfiguration_ByDevelopmentServerConfigId,
+  useDevelopmentAdminApi_GetDevelopmentServerConfiguration_ByDevelopmentServerConfigId: () => useDevelopmentAdminApi_GetDevelopmentServerConfiguration_ByDevelopmentServerConfigId,
+  useDevelopmentAdminApi_GetDevelopmentServerConfigurations: () => useDevelopmentAdminApi_GetDevelopmentServerConfigurations,
+  useFleetCommanderApi_GetVersion: () => useFleetCommanderApi_GetVersion,
+  useFleetsAdminApi_CreateFleet: () => useFleetsAdminApi_CreateFleet,
+  useFleetsAdminApi_DeleteFleet_ByFleetId: () => useFleetsAdminApi_DeleteFleet_ByFleetId,
+  useFleetsAdminApi_GetFleet_ByFleetId: () => useFleetsAdminApi_GetFleet_ByFleetId,
+  useFleetsAdminApi_GetFleets: () => useFleetsAdminApi_GetFleets,
+  useFleetsAdminApi_GetServers_ByFleetId: () => useFleetsAdminApi_GetServers_ByFleetId,
+  useFleetsAdminApi_UpdateFleet_ByFleetId: () => useFleetsAdminApi_UpdateFleet_ByFleetId,
+  useFleetsApi_UpdateClaim_ByFleetId: () => useFleetsApi_UpdateClaim_ByFleetId,
+  useFleetsApi_UpdateServerClaim: () => useFleetsApi_UpdateServerClaim,
+  useImagesAdminApi_CreateRestore_ByImageId: () => useImagesAdminApi_CreateRestore_ByImageId,
+  useImagesAdminApi_DeleteImage_ByImageId: () => useImagesAdminApi_DeleteImage_ByImageId,
+  useImagesAdminApi_GetImage_ByImageId: () => useImagesAdminApi_GetImage_ByImageId,
+  useImagesAdminApi_GetImages: () => useImagesAdminApi_GetImages,
+  useImagesAdminApi_GetImagesStorage: () => useImagesAdminApi_GetImagesStorage,
+  useImagesAdminApi_PatchImage_ByImageId: () => useImagesAdminApi_PatchImage_ByImageId,
+  useServersAdminApi_GetConnectioninfo_ByServerId: () => useServersAdminApi_GetConnectioninfo_ByServerId,
+  useServersAdminApi_GetHistory_ByServerId: () => useServersAdminApi_GetHistory_ByServerId,
+  useServersAdminApi_GetServer_ByServerId: () => useServersAdminApi_GetServer_ByServerId,
+  useServersAdminApi_GetServersHistory_ByFleetId: () => useServersAdminApi_GetServersHistory_ByFleetId,
+  useWatchdogsApi_GetConnect_ByWatchdogId: () => useWatchdogsApi_GetConnect_ByWatchdogId,
+  useWatchdogsApi_GetConnect_ByWatchdogId_ByNS: () => useWatchdogsApi_GetConnect_ByWatchdogId_ByNS
+});
+module.exports = __toCommonJS(all_query_imports_exports);
+
+// src/generated-admin/queries/AccountAdmin.query.ts
+var import_react_query = require("@tanstack/react-query");
+
+// 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/queries/AccountAdmin.query.ts
+var Key_AccountAdmin = /* @__PURE__ */ ((Key_AccountAdmin2) => {
+  Key_AccountAdmin2["Account"] = "Ams.AccountAdmin.Account";
+  Key_AccountAdmin2["AccountLink"] = "Ams.AccountAdmin.AccountLink";
+  return Key_AccountAdmin2;
+})(Key_AccountAdmin || {});
+var useAccountAdminApi_GetAccount = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await AccountAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getAccount();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query.useQuery)({
+    queryKey: ["Ams.AccountAdmin.Account" /* Account */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useAccountAdminApi_CreateAccount = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await AccountAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).createAccount(input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query.useMutation)({
+    mutationKey: ["Ams.AccountAdmin.Account" /* Account */],
+    mutationFn,
+    ...options
+  });
+};
+var useAccountAdminApi_GetAccountLink = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await AccountAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getAccountLink();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query.useQuery)({
+    queryKey: ["Ams.AccountAdmin.AccountLink" /* AccountLink */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useAccountAdminApi_CreateAccountLink = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await AccountAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).createAccountLink(input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query.useMutation)({
+    mutationKey: ["Ams.AccountAdmin.AccountLink" /* AccountLink */],
+    mutationFn,
+    ...options
+  });
+};
+
+// src/generated-admin/queries/AmsInfoAdmin.query.ts
+var import_react_query2 = require("@tanstack/react-query");
+
+// 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/queries/AmsInfoAdmin.query.ts
+var Key_AmsInfoAdmin = /* @__PURE__ */ ((Key_AmsInfoAdmin2) => {
+  Key_AmsInfoAdmin2["Regions"] = "Ams.AmsInfoAdmin.Regions";
+  Key_AmsInfoAdmin2["SupportedInstances"] = "Ams.AmsInfoAdmin.SupportedInstances";
+  return Key_AmsInfoAdmin2;
+})(Key_AmsInfoAdmin || {});
+var useAmsInfoAdminApi_GetRegions = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await AmsInfoAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getRegions();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query2.useQuery)({
+    queryKey: ["Ams.AmsInfoAdmin.Regions" /* Regions */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useAmsInfoAdminApi_GetSupportedInstances = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await AmsInfoAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getSupportedInstances();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query2.useQuery)({
+    queryKey: ["Ams.AmsInfoAdmin.SupportedInstances" /* SupportedInstances */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+
+// src/generated-admin/queries/AmsQoSAdmin.query.ts
+var import_react_query3 = require("@tanstack/react-query");
+
+// 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/queries/AmsQoSAdmin.query.ts
+var Key_AmsQoSAdmin = /* @__PURE__ */ ((Key_AmsQoSAdmin2) => {
+  Key_AmsQoSAdmin2["Qos"] = "Ams.AmsQoSAdmin.Qos";
+  Key_AmsQoSAdmin2["Qo_ByRegion"] = "Ams.AmsQoSAdmin.Qo_ByRegion";
+  return Key_AmsQoSAdmin2;
+})(Key_AmsQoSAdmin || {});
+var useAmsQoSAdminApi_GetQos = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await AmsQoSAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getQos(input2.queryParams);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query3.useQuery)({
+    queryKey: ["Ams.AmsQoSAdmin.Qos" /* Qos */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useAmsQoSAdminApi_PatchQo_ByRegion = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await AmsQoSAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).patchQo_ByRegion(input.region, input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query3.useMutation)({
+    mutationKey: ["Ams.AmsQoSAdmin.Qo_ByRegion" /* Qo_ByRegion */],
+    mutationFn,
+    ...options
+  });
+};
+
+// src/generated-admin/queries/ArtifactsAdmin.query.ts
+var import_react_query4 = require("@tanstack/react-query");
+
+// 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/queries/ArtifactsAdmin.query.ts
+var Key_ArtifactsAdmin = /* @__PURE__ */ ((Key_ArtifactsAdmin2) => {
+  Key_ArtifactsAdmin2["Artifact"] = "Ams.ArtifactsAdmin.Artifact";
+  Key_ArtifactsAdmin2["Artifacts"] = "Ams.ArtifactsAdmin.Artifacts";
+  Key_ArtifactsAdmin2["ArtifactsUsage"] = "Ams.ArtifactsAdmin.ArtifactsUsage";
+  Key_ArtifactsAdmin2["Artifact_ByArtifactId"] = "Ams.ArtifactsAdmin.Artifact_ByArtifactId";
+  Key_ArtifactsAdmin2["Url_ByArtifactId"] = "Ams.ArtifactsAdmin.Url_ByArtifactId";
+  Key_ArtifactsAdmin2["ArtifactsSamplingRules_ByFleetId"] = "Ams.ArtifactsAdmin.ArtifactsSamplingRules_ByFleetId";
+  Key_ArtifactsAdmin2["ArtifactsSamplingRule_ByFleetId"] = "Ams.ArtifactsAdmin.ArtifactsSamplingRule_ByFleetId";
+  return Key_ArtifactsAdmin2;
+})(Key_ArtifactsAdmin || {});
+var useArtifactsAdminApi_DeleteArtifact = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await ArtifactsAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).deleteArtifact(input.queryParams);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query4.useMutation)({
+    mutationKey: ["Ams.ArtifactsAdmin.Artifact" /* Artifact */],
+    mutationFn,
+    ...options
+  });
+};
+var useArtifactsAdminApi_GetArtifacts = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ArtifactsAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getArtifacts(input2.queryParams);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["Ams.ArtifactsAdmin.Artifacts" /* Artifacts */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useArtifactsAdminApi_GetArtifactsUsage = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ArtifactsAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getArtifactsUsage();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["Ams.ArtifactsAdmin.ArtifactsUsage" /* ArtifactsUsage */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useArtifactsAdminApi_DeleteArtifact_ByArtifactId = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await ArtifactsAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).deleteArtifact_ByArtifactId(input.artifactID);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query4.useMutation)({
+    mutationKey: ["Ams.ArtifactsAdmin.Artifact_ByArtifactId" /* Artifact_ByArtifactId */],
+    mutationFn,
+    ...options
+  });
+};
+var useArtifactsAdminApi_GetUrl_ByArtifactId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ArtifactsAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getUrl_ByArtifactId(input2.artifactID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["Ams.ArtifactsAdmin.Url_ByArtifactId" /* Url_ByArtifactId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useArtifactsAdminApi_GetArtifactsSamplingRules_ByFleetId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ArtifactsAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getArtifactsSamplingRules_ByFleetId(input2.fleetID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["Ams.ArtifactsAdmin.ArtifactsSamplingRules_ByFleetId" /* ArtifactsSamplingRules_ByFleetId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useArtifactsAdminApi_UpdateArtifactsSamplingRule_ByFleetId = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await ArtifactsAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).updateArtifactsSamplingRule_ByFleetId(input.fleetID, input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query4.useMutation)({
+    mutationKey: ["Ams.ArtifactsAdmin.ArtifactsSamplingRule_ByFleetId" /* ArtifactsSamplingRule_ByFleetId */],
+    mutationFn,
+    ...options
+  });
+};
+
+// src/generated-admin/queries/DevelopmentAdmin.query.ts
+var import_react_query5 = require("@tanstack/react-query");
+
+// 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/queries/DevelopmentAdmin.query.ts
+var Key_DevelopmentAdmin = /* @__PURE__ */ ((Key_DevelopmentAdmin2) => {
+  Key_DevelopmentAdmin2["DevelopmentServerConfigurations"] = "Ams.DevelopmentAdmin.DevelopmentServerConfigurations";
+  Key_DevelopmentAdmin2["DevelopmentServerConfiguration"] = "Ams.DevelopmentAdmin.DevelopmentServerConfiguration";
+  Key_DevelopmentAdmin2["DevelopmentServerConfiguration_ByDevelopmentServerConfigId"] = "Ams.DevelopmentAdmin.DevelopmentServerConfiguration_ByDevelopmentServerConfigId";
+  return Key_DevelopmentAdmin2;
+})(Key_DevelopmentAdmin || {});
+var useDevelopmentAdminApi_GetDevelopmentServerConfigurations = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await DevelopmentAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getDevelopmentServerConfigurations(input2.queryParams);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query5.useQuery)({
+    queryKey: ["Ams.DevelopmentAdmin.DevelopmentServerConfigurations" /* DevelopmentServerConfigurations */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useDevelopmentAdminApi_CreateDevelopmentServerConfiguration = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await DevelopmentAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).createDevelopmentServerConfiguration(input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query5.useMutation)({
+    mutationKey: ["Ams.DevelopmentAdmin.DevelopmentServerConfiguration" /* DevelopmentServerConfiguration */],
+    mutationFn,
+    ...options
+  });
+};
+var useDevelopmentAdminApi_DeleteDevelopmentServerConfiguration_ByDevelopmentServerConfigId = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await DevelopmentAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).deleteDevelopmentServerConfiguration_ByDevelopmentServerConfigId(input.developmentServerConfigID);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query5.useMutation)({
+    mutationKey: ["Ams.DevelopmentAdmin.DevelopmentServerConfiguration_ByDevelopmentServerConfigId" /* DevelopmentServerConfiguration_ByDevelopmentServerConfigId */],
+    mutationFn,
+    ...options
+  });
+};
+var useDevelopmentAdminApi_GetDevelopmentServerConfiguration_ByDevelopmentServerConfigId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await DevelopmentAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getDevelopmentServerConfiguration_ByDevelopmentServerConfigId(input2.developmentServerConfigID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query5.useQuery)({
+    queryKey: ["Ams.DevelopmentAdmin.DevelopmentServerConfiguration_ByDevelopmentServerConfigId" /* DevelopmentServerConfiguration_ByDevelopmentServerConfigId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+
+// src/generated-admin/queries/FleetsAdmin.query.ts
+var import_react_query6 = require("@tanstack/react-query");
+
+// 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/queries/FleetsAdmin.query.ts
+var Key_FleetsAdmin = /* @__PURE__ */ ((Key_FleetsAdmin2) => {
+  Key_FleetsAdmin2["Fleets"] = "Ams.FleetsAdmin.Fleets";
+  Key_FleetsAdmin2["Fleet"] = "Ams.FleetsAdmin.Fleet";
+  Key_FleetsAdmin2["Fleet_ByFleetId"] = "Ams.FleetsAdmin.Fleet_ByFleetId";
+  Key_FleetsAdmin2["Servers_ByFleetId"] = "Ams.FleetsAdmin.Servers_ByFleetId";
+  return Key_FleetsAdmin2;
+})(Key_FleetsAdmin || {});
+var useFleetsAdminApi_GetFleets = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await FleetsAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getFleets();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query6.useQuery)({
+    queryKey: ["Ams.FleetsAdmin.Fleets" /* Fleets */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useFleetsAdminApi_CreateFleet = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await FleetsAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).createFleet(input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query6.useMutation)({
+    mutationKey: ["Ams.FleetsAdmin.Fleet" /* Fleet */],
+    mutationFn,
+    ...options
+  });
+};
+var useFleetsAdminApi_DeleteFleet_ByFleetId = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await FleetsAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).deleteFleet_ByFleetId(input.fleetID);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query6.useMutation)({
+    mutationKey: ["Ams.FleetsAdmin.Fleet_ByFleetId" /* Fleet_ByFleetId */],
+    mutationFn,
+    ...options
+  });
+};
+var useFleetsAdminApi_GetFleet_ByFleetId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await FleetsAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getFleet_ByFleetId(input2.fleetID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query6.useQuery)({
+    queryKey: ["Ams.FleetsAdmin.Fleet_ByFleetId" /* Fleet_ByFleetId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useFleetsAdminApi_UpdateFleet_ByFleetId = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await FleetsAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).updateFleet_ByFleetId(input.fleetID, input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query6.useMutation)({
+    mutationKey: ["Ams.FleetsAdmin.Fleet_ByFleetId" /* Fleet_ByFleetId */],
+    mutationFn,
+    ...options
+  });
+};
+var useFleetsAdminApi_GetServers_ByFleetId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await FleetsAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getServers_ByFleetId(input2.fleetID, input2.queryParams);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query6.useQuery)({
+    queryKey: ["Ams.FleetsAdmin.Servers_ByFleetId" /* Servers_ByFleetId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+
+// src/generated-admin/queries/ImagesAdmin.query.ts
+var import_react_query7 = require("@tanstack/react-query");
+
+// 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/queries/ImagesAdmin.query.ts
+var Key_ImagesAdmin = /* @__PURE__ */ ((Key_ImagesAdmin2) => {
+  Key_ImagesAdmin2["Images"] = "Ams.ImagesAdmin.Images";
+  Key_ImagesAdmin2["ImagesStorage"] = "Ams.ImagesAdmin.ImagesStorage";
+  Key_ImagesAdmin2["Image_ByImageId"] = "Ams.ImagesAdmin.Image_ByImageId";
+  Key_ImagesAdmin2["Restore_ByImageId"] = "Ams.ImagesAdmin.Restore_ByImageId";
+  return Key_ImagesAdmin2;
+})(Key_ImagesAdmin || {});
+var useImagesAdminApi_GetImages = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ImagesAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getImages();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query7.useQuery)({
+    queryKey: ["Ams.ImagesAdmin.Images" /* Images */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useImagesAdminApi_GetImagesStorage = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ImagesAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getImagesStorage();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query7.useQuery)({
+    queryKey: ["Ams.ImagesAdmin.ImagesStorage" /* ImagesStorage */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useImagesAdminApi_DeleteImage_ByImageId = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await ImagesAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).deleteImage_ByImageId(input.imageID);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query7.useMutation)({
+    mutationKey: ["Ams.ImagesAdmin.Image_ByImageId" /* Image_ByImageId */],
+    mutationFn,
+    ...options
+  });
+};
+var useImagesAdminApi_GetImage_ByImageId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ImagesAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getImage_ByImageId(input2.imageID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query7.useQuery)({
+    queryKey: ["Ams.ImagesAdmin.Image_ByImageId" /* Image_ByImageId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useImagesAdminApi_PatchImage_ByImageId = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await ImagesAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).patchImage_ByImageId(input.imageID, input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query7.useMutation)({
+    mutationKey: ["Ams.ImagesAdmin.Image_ByImageId" /* Image_ByImageId */],
+    mutationFn,
+    ...options
+  });
+};
+var useImagesAdminApi_CreateRestore_ByImageId = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await ImagesAdminApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).createRestore_ByImageId(input.imageID);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query7.useMutation)({
+    mutationKey: ["Ams.ImagesAdmin.Restore_ByImageId" /* Restore_ByImageId */],
+    mutationFn,
+    ...options
+  });
+};
+
+// src/generated-admin/queries/ServersAdmin.query.ts
+var import_react_query8 = require("@tanstack/react-query");
+
+// 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-admin/queries/ServersAdmin.query.ts
+var Key_ServersAdmin = /* @__PURE__ */ ((Key_ServersAdmin2) => {
+  Key_ServersAdmin2["Server_ByServerId"] = "Ams.ServersAdmin.Server_ByServerId";
+  Key_ServersAdmin2["History_ByServerId"] = "Ams.ServersAdmin.History_ByServerId";
+  Key_ServersAdmin2["ServersHistory_ByFleetId"] = "Ams.ServersAdmin.ServersHistory_ByFleetId";
+  Key_ServersAdmin2["Connectioninfo_ByServerId"] = "Ams.ServersAdmin.Connectioninfo_ByServerId";
+  return Key_ServersAdmin2;
+})(Key_ServersAdmin || {});
+var useServersAdminApi_GetServer_ByServerId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ServersAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getServer_ByServerId(input2.serverID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query8.useQuery)({
+    queryKey: ["Ams.ServersAdmin.Server_ByServerId" /* Server_ByServerId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useServersAdminApi_GetHistory_ByServerId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ServersAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getHistory_ByServerId(input2.serverID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query8.useQuery)({
+    queryKey: ["Ams.ServersAdmin.History_ByServerId" /* History_ByServerId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useServersAdminApi_GetServersHistory_ByFleetId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ServersAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getServersHistory_ByFleetId(input2.fleetID, input2.queryParams);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query8.useQuery)({
+    queryKey: ["Ams.ServersAdmin.ServersHistory_ByFleetId" /* ServersHistory_ByFleetId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useServersAdminApi_GetConnectioninfo_ByServerId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await ServersAdminApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getConnectioninfo_ByServerId(input2.serverID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query8.useQuery)({
+    queryKey: ["Ams.ServersAdmin.Connectioninfo_ByServerId" /* Connectioninfo_ByServerId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+
+// src/generated-public/queries/Account.query.ts
+var import_react_query9 = require("@tanstack/react-query");
+
+// 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/queries/Account.query.ts
+var Key_Account = /* @__PURE__ */ ((Key_Account2) => {
+  Key_Account2["Account"] = "Ams.Account.Account";
+  return Key_Account2;
+})(Key_Account || {});
+var useAccountApi_GetAccount = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await AccountApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getAccount();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query9.useQuery)({
+    queryKey: ["Ams.Account.Account" /* Account */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+
+// src/generated-public/queries/AmsInfo.query.ts
+var import_react_query10 = require("@tanstack/react-query");
+
+// 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/queries/AmsInfo.query.ts
+var Key_AmsInfo = /* @__PURE__ */ ((Key_AmsInfo2) => {
+  Key_AmsInfo2["UploadUrl"] = "Ams.AmsInfo.UploadUrl";
+  return Key_AmsInfo2;
+})(Key_AmsInfo || {});
+var useAmsInfoApi_GetUploadUrl = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await AmsInfoApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getUploadUrl();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query10.useQuery)({
+    queryKey: ["Ams.AmsInfo.UploadUrl" /* UploadUrl */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+
+// src/generated-public/queries/Auth.query.ts
+var import_react_query11 = require("@tanstack/react-query");
+
+// 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/queries/Auth.query.ts
+var Key_Auth = /* @__PURE__ */ ((Key_Auth2) => {
+  Key_Auth2["Auth"] = "Ams.Auth.Auth";
+  return Key_Auth2;
+})(Key_Auth || {});
+var useAuthApi_GetAuth = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await AuthApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getAuth();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query11.useQuery)({
+    queryKey: ["Ams.Auth.Auth" /* Auth */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+
+// src/generated-public/queries/FleetCommander.query.ts
+var import_react_query12 = require("@tanstack/react-query");
+
+// 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/queries/FleetCommander.query.ts
+var Key_FleetCommander = /* @__PURE__ */ ((Key_FleetCommander2) => {
+  Key_FleetCommander2["Version"] = "Ams.FleetCommander.Version";
+  return Key_FleetCommander2;
+})(Key_FleetCommander || {});
+var useFleetCommanderApi_GetVersion = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await FleetCommanderApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getVersion();
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query12.useQuery)({
+    queryKey: ["Ams.FleetCommander.Version" /* Version */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+
+// src/generated-public/queries/Fleets.query.ts
+var import_react_query13 = require("@tanstack/react-query");
+
+// 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/queries/Fleets.query.ts
+var Key_Fleets = /* @__PURE__ */ ((Key_Fleets2) => {
+  Key_Fleets2["ServerClaim"] = "Ams.Fleets.ServerClaim";
+  Key_Fleets2["Claim_ByFleetId"] = "Ams.Fleets.Claim_ByFleetId";
+  return Key_Fleets2;
+})(Key_Fleets || {});
+var useFleetsApi_UpdateServerClaim = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await FleetsApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).updateServerClaim(input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query13.useMutation)({
+    mutationKey: ["Ams.Fleets.ServerClaim" /* ServerClaim */],
+    mutationFn,
+    ...options
+  });
+};
+var useFleetsApi_UpdateClaim_ByFleetId = (sdk, options, callback) => {
+  const mutationFn = async (input) => {
+    const response = await FleetsApi(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).updateClaim_ByFleetId(input.fleetID, input.data);
+    callback && callback(response.data);
+    return response.data;
+  };
+  return (0, import_react_query13.useMutation)({
+    mutationKey: ["Ams.Fleets.Claim_ByFleetId" /* Claim_ByFleetId */],
+    mutationFn,
+    ...options
+  });
+};
+
+// src/generated-public/queries/Watchdogs.query.ts
+var import_react_query14 = require("@tanstack/react-query");
+
+// 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/generated-public/queries/Watchdogs.query.ts
+var Key_Watchdogs = /* @__PURE__ */ ((Key_Watchdogs2) => {
+  Key_Watchdogs2["Connect_ByWatchdogId"] = "Ams.Watchdogs.Connect_ByWatchdogId";
+  Key_Watchdogs2["Connect_ByWatchdogId_ByNS"] = "Ams.Watchdogs.Connect_ByWatchdogId_ByNS";
+  return Key_Watchdogs2;
+})(Key_Watchdogs || {});
+var useWatchdogsApi_GetConnect_ByWatchdogId = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await WatchdogsApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getConnect_ByWatchdogId(input2.watchdogID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query14.useQuery)({
+    queryKey: ["Ams.Watchdogs.Connect_ByWatchdogId" /* Connect_ByWatchdogId */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+var useWatchdogsApi_GetConnect_ByWatchdogId_ByNS = (sdk, input, options, callback) => {
+  const queryFn = (sdk2, input2) => async () => {
+    const response = await WatchdogsApi(sdk2, { coreConfig: input2.coreConfig, axiosConfig: input2.axiosConfig }).getConnect_ByWatchdogId_ByNS(input2.watchdogID);
+    callback && callback(response);
+    return response.data;
+  };
+  return (0, import_react_query14.useQuery)({
+    queryKey: ["Ams.Watchdogs.Connect_ByWatchdogId_ByNS" /* Connect_ByWatchdogId_ByNS */, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Key_Account,
+  Key_AccountAdmin,
+  Key_AmsInfo,
+  Key_AmsInfoAdmin,
+  Key_AmsQoSAdmin,
+  Key_ArtifactsAdmin,
+  Key_Auth,
+  Key_DevelopmentAdmin,
+  Key_FleetCommander,
+  Key_Fleets,
+  Key_FleetsAdmin,
+  Key_ImagesAdmin,
+  Key_ServersAdmin,
+  Key_Watchdogs,
+  useAccountAdminApi_CreateAccount,
+  useAccountAdminApi_CreateAccountLink,
+  useAccountAdminApi_GetAccount,
+  useAccountAdminApi_GetAccountLink,
+  useAccountApi_GetAccount,
+  useAmsInfoAdminApi_GetRegions,
+  useAmsInfoAdminApi_GetSupportedInstances,
+  useAmsInfoApi_GetUploadUrl,
+  useAmsQoSAdminApi_GetQos,
+  useAmsQoSAdminApi_PatchQo_ByRegion,
+  useArtifactsAdminApi_DeleteArtifact,
+  useArtifactsAdminApi_DeleteArtifact_ByArtifactId,
+  useArtifactsAdminApi_GetArtifacts,
+  useArtifactsAdminApi_GetArtifactsSamplingRules_ByFleetId,
+  useArtifactsAdminApi_GetArtifactsUsage,
+  useArtifactsAdminApi_GetUrl_ByArtifactId,
+  useArtifactsAdminApi_UpdateArtifactsSamplingRule_ByFleetId,
+  useAuthApi_GetAuth,
+  useDevelopmentAdminApi_CreateDevelopmentServerConfiguration,
+  useDevelopmentAdminApi_DeleteDevelopmentServerConfiguration_ByDevelopmentServerConfigId,
+  useDevelopmentAdminApi_GetDevelopmentServerConfiguration_ByDevelopmentServerConfigId,
+  useDevelopmentAdminApi_GetDevelopmentServerConfigurations,
+  useFleetCommanderApi_GetVersion,
+  useFleetsAdminApi_CreateFleet,
+  useFleetsAdminApi_DeleteFleet_ByFleetId,
+  useFleetsAdminApi_GetFleet_ByFleetId,
+  useFleetsAdminApi_GetFleets,
+  useFleetsAdminApi_GetServers_ByFleetId,
+  useFleetsAdminApi_UpdateFleet_ByFleetId,
+  useFleetsApi_UpdateClaim_ByFleetId,
+  useFleetsApi_UpdateServerClaim,
+  useImagesAdminApi_CreateRestore_ByImageId,
+  useImagesAdminApi_DeleteImage_ByImageId,
+  useImagesAdminApi_GetImage_ByImageId,
+  useImagesAdminApi_GetImages,
+  useImagesAdminApi_GetImagesStorage,
+  useImagesAdminApi_PatchImage_ByImageId,
+  useServersAdminApi_GetConnectioninfo_ByServerId,
+  useServersAdminApi_GetHistory_ByServerId,
+  useServersAdminApi_GetServer_ByServerId,
+  useServersAdminApi_GetServersHistory_ByFleetId,
+  useWatchdogsApi_GetConnect_ByWatchdogId,
+  useWatchdogsApi_GetConnect_ByWatchdogId_ByNS
+});