@nixopus/api-client 0.0.3 → 0.0.4

package/dist/index.js

@@ -21,113 +21,269 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   deleteApiV1ContainerContainerId: () => deleteApiV1ContainerContainerId,
+  deleteApiV1ContainerContainerIdMutation: () => deleteApiV1ContainerContainerIdMutation,
   deleteApiV1DeployApplication: () => deleteApiV1DeployApplication,
   deleteApiV1DeployApplicationDomains: () => deleteApiV1DeployApplicationDomains,
+  deleteApiV1DeployApplicationDomainsMutation: () => deleteApiV1DeployApplicationDomainsMutation,
+  deleteApiV1DeployApplicationMutation: () => deleteApiV1DeployApplicationMutation,
   deleteApiV1Domain: () => deleteApiV1Domain,
+  deleteApiV1DomainMutation: () => deleteApiV1DomainMutation,
   deleteApiV1ExtensionsId: () => deleteApiV1ExtensionsId,
+  deleteApiV1ExtensionsIdMutation: () => deleteApiV1ExtensionsIdMutation,
   deleteApiV1FileManagerDeleteDirectory: () => deleteApiV1FileManagerDeleteDirectory,
+  deleteApiV1FileManagerDeleteDirectoryMutation: () => deleteApiV1FileManagerDeleteDirectoryMutation,
   deleteApiV1GithubConnector: () => deleteApiV1GithubConnector,
+  deleteApiV1GithubConnectorMutation: () => deleteApiV1GithubConnectorMutation,
   deleteApiV1Healthcheck: () => deleteApiV1Healthcheck,
+  deleteApiV1HealthcheckMutation: () => deleteApiV1HealthcheckMutation,
   deleteApiV1NotificationSmtp: () => deleteApiV1NotificationSmtp,
+  deleteApiV1NotificationSmtpMutation: () => deleteApiV1NotificationSmtpMutation,
   deleteApiV1NotificationWebhook: () => deleteApiV1NotificationWebhook,
+  deleteApiV1NotificationWebhookMutation: () => deleteApiV1NotificationWebhookMutation,
   getApiV1AuditLogs: () => getApiV1AuditLogs,
+  getApiV1AuditLogsOptions: () => getApiV1AuditLogsOptions,
+  getApiV1AuditLogsQueryKey: () => getApiV1AuditLogsQueryKey,
   getApiV1AuthBootstrap: () => getApiV1AuthBootstrap,
+  getApiV1AuthBootstrapOptions: () => getApiV1AuthBootstrapOptions,
+  getApiV1AuthBootstrapQueryKey: () => getApiV1AuthBootstrapQueryKey,
   getApiV1AuthIsAdminRegistered: () => getApiV1AuthIsAdminRegistered,
+  getApiV1AuthIsAdminRegisteredOptions: () => getApiV1AuthIsAdminRegisteredOptions,
+  getApiV1AuthIsAdminRegisteredQueryKey: () => getApiV1AuthIsAdminRegisteredQueryKey,
   getApiV1Container: () => getApiV1Container,
   getApiV1ContainerContainerId: () => getApiV1ContainerContainerId,
+  getApiV1ContainerContainerIdOptions: () => getApiV1ContainerContainerIdOptions,
+  getApiV1ContainerContainerIdQueryKey: () => getApiV1ContainerContainerIdQueryKey,
+  getApiV1ContainerOptions: () => getApiV1ContainerOptions,
+  getApiV1ContainerQueryKey: () => getApiV1ContainerQueryKey,
   getApiV1DeployApplication: () => getApiV1DeployApplication,
   getApiV1DeployApplicationDeployments: () => getApiV1DeployApplicationDeployments,
   getApiV1DeployApplicationDeploymentsDeploymentId: () => getApiV1DeployApplicationDeploymentsDeploymentId,
   getApiV1DeployApplicationDeploymentsDeploymentIdLogs: () => getApiV1DeployApplicationDeploymentsDeploymentIdLogs,
+  getApiV1DeployApplicationDeploymentsDeploymentIdLogsOptions: () => getApiV1DeployApplicationDeploymentsDeploymentIdLogsOptions,
+  getApiV1DeployApplicationDeploymentsDeploymentIdLogsQueryKey: () => getApiV1DeployApplicationDeploymentsDeploymentIdLogsQueryKey,
+  getApiV1DeployApplicationDeploymentsDeploymentIdOptions: () => getApiV1DeployApplicationDeploymentsDeploymentIdOptions,
+  getApiV1DeployApplicationDeploymentsDeploymentIdQueryKey: () => getApiV1DeployApplicationDeploymentsDeploymentIdQueryKey,
+  getApiV1DeployApplicationDeploymentsInfiniteOptions: () => getApiV1DeployApplicationDeploymentsInfiniteOptions,
+  getApiV1DeployApplicationDeploymentsInfiniteQueryKey: () => getApiV1DeployApplicationDeploymentsInfiniteQueryKey,
+  getApiV1DeployApplicationDeploymentsOptions: () => getApiV1DeployApplicationDeploymentsOptions,
+  getApiV1DeployApplicationDeploymentsQueryKey: () => getApiV1DeployApplicationDeploymentsQueryKey,
   getApiV1DeployApplicationLogsApplicationId: () => getApiV1DeployApplicationLogsApplicationId,
+  getApiV1DeployApplicationLogsApplicationIdOptions: () => getApiV1DeployApplicationLogsApplicationIdOptions,
+  getApiV1DeployApplicationLogsApplicationIdQueryKey: () => getApiV1DeployApplicationLogsApplicationIdQueryKey,
+  getApiV1DeployApplicationOptions: () => getApiV1DeployApplicationOptions,
   getApiV1DeployApplicationProjectFamily: () => getApiV1DeployApplicationProjectFamily,
   getApiV1DeployApplicationProjectFamilyEnvironments: () => getApiV1DeployApplicationProjectFamilyEnvironments,
+  getApiV1DeployApplicationProjectFamilyEnvironmentsOptions: () => getApiV1DeployApplicationProjectFamilyEnvironmentsOptions,
+  getApiV1DeployApplicationProjectFamilyEnvironmentsQueryKey: () => getApiV1DeployApplicationProjectFamilyEnvironmentsQueryKey,
+  getApiV1DeployApplicationProjectFamilyOptions: () => getApiV1DeployApplicationProjectFamilyOptions,
+  getApiV1DeployApplicationProjectFamilyQueryKey: () => getApiV1DeployApplicationProjectFamilyQueryKey,
+  getApiV1DeployApplicationQueryKey: () => getApiV1DeployApplicationQueryKey,
   getApiV1DeployApplications: () => getApiV1DeployApplications,
+  getApiV1DeployApplicationsInfiniteOptions: () => getApiV1DeployApplicationsInfiniteOptions,
+  getApiV1DeployApplicationsInfiniteQueryKey: () => getApiV1DeployApplicationsInfiniteQueryKey,
+  getApiV1DeployApplicationsOptions: () => getApiV1DeployApplicationsOptions,
+  getApiV1DeployApplicationsQueryKey: () => getApiV1DeployApplicationsQueryKey,
   getApiV1DomainGenerate: () => getApiV1DomainGenerate,
+  getApiV1DomainGenerateOptions: () => getApiV1DomainGenerateOptions,
+  getApiV1DomainGenerateQueryKey: () => getApiV1DomainGenerateQueryKey,
   getApiV1Domains: () => getApiV1Domains,
+  getApiV1DomainsOptions: () => getApiV1DomainsOptions,
+  getApiV1DomainsQueryKey: () => getApiV1DomainsQueryKey,
   getApiV1Extensions: () => getApiV1Extensions,
   getApiV1ExtensionsByExtensionIdExtensionId: () => getApiV1ExtensionsByExtensionIdExtensionId,
   getApiV1ExtensionsByExtensionIdExtensionIdExecutions: () => getApiV1ExtensionsByExtensionIdExtensionIdExecutions,
+  getApiV1ExtensionsByExtensionIdExtensionIdExecutionsOptions: () => getApiV1ExtensionsByExtensionIdExtensionIdExecutionsOptions,
+  getApiV1ExtensionsByExtensionIdExtensionIdExecutionsQueryKey: () => getApiV1ExtensionsByExtensionIdExtensionIdExecutionsQueryKey,
+  getApiV1ExtensionsByExtensionIdExtensionIdOptions: () => getApiV1ExtensionsByExtensionIdExtensionIdOptions,
+  getApiV1ExtensionsByExtensionIdExtensionIdQueryKey: () => getApiV1ExtensionsByExtensionIdExtensionIdQueryKey,
   getApiV1ExtensionsCategories: () => getApiV1ExtensionsCategories,
+  getApiV1ExtensionsCategoriesOptions: () => getApiV1ExtensionsCategoriesOptions,
+  getApiV1ExtensionsCategoriesQueryKey: () => getApiV1ExtensionsCategoriesQueryKey,
   getApiV1ExtensionsExecutionExecutionId: () => getApiV1ExtensionsExecutionExecutionId,
   getApiV1ExtensionsExecutionExecutionIdLogs: () => getApiV1ExtensionsExecutionExecutionIdLogs,
+  getApiV1ExtensionsExecutionExecutionIdLogsOptions: () => getApiV1ExtensionsExecutionExecutionIdLogsOptions,
+  getApiV1ExtensionsExecutionExecutionIdLogsQueryKey: () => getApiV1ExtensionsExecutionExecutionIdLogsQueryKey,
+  getApiV1ExtensionsExecutionExecutionIdOptions: () => getApiV1ExtensionsExecutionExecutionIdOptions,
+  getApiV1ExtensionsExecutionExecutionIdQueryKey: () => getApiV1ExtensionsExecutionExecutionIdQueryKey,
   getApiV1ExtensionsId: () => getApiV1ExtensionsId,
+  getApiV1ExtensionsIdOptions: () => getApiV1ExtensionsIdOptions,
+  getApiV1ExtensionsIdQueryKey: () => getApiV1ExtensionsIdQueryKey,
+  getApiV1ExtensionsOptions: () => getApiV1ExtensionsOptions,
+  getApiV1ExtensionsQueryKey: () => getApiV1ExtensionsQueryKey,
   getApiV1FeatureFlags: () => getApiV1FeatureFlags,
   getApiV1FeatureFlagsCheck: () => getApiV1FeatureFlagsCheck,
+  getApiV1FeatureFlagsCheckOptions: () => getApiV1FeatureFlagsCheckOptions,
+  getApiV1FeatureFlagsCheckQueryKey: () => getApiV1FeatureFlagsCheckQueryKey,
+  getApiV1FeatureFlagsOptions: () => getApiV1FeatureFlagsOptions,
+  getApiV1FeatureFlagsQueryKey: () => getApiV1FeatureFlagsQueryKey,
   getApiV1FileManager: () => getApiV1FileManager,
+  getApiV1FileManagerOptions: () => getApiV1FileManagerOptions,
+  getApiV1FileManagerQueryKey: () => getApiV1FileManagerQueryKey,
   getApiV1GithubConnectorAll: () => getApiV1GithubConnectorAll,
+  getApiV1GithubConnectorAllOptions: () => getApiV1GithubConnectorAllOptions,
+  getApiV1GithubConnectorAllQueryKey: () => getApiV1GithubConnectorAllQueryKey,
   getApiV1GithubConnectorRepositories: () => getApiV1GithubConnectorRepositories,
+  getApiV1GithubConnectorRepositoriesOptions: () => getApiV1GithubConnectorRepositoriesOptions,
+  getApiV1GithubConnectorRepositoriesQueryKey: () => getApiV1GithubConnectorRepositoriesQueryKey,
   getApiV1Health: () => getApiV1Health,
+  getApiV1HealthOptions: () => getApiV1HealthOptions,
+  getApiV1HealthQueryKey: () => getApiV1HealthQueryKey,
   getApiV1Healthcheck: () => getApiV1Healthcheck,
+  getApiV1HealthcheckOptions: () => getApiV1HealthcheckOptions,
+  getApiV1HealthcheckQueryKey: () => getApiV1HealthcheckQueryKey,
   getApiV1HealthcheckResults: () => getApiV1HealthcheckResults,
+  getApiV1HealthcheckResultsOptions: () => getApiV1HealthcheckResultsOptions,
+  getApiV1HealthcheckResultsQueryKey: () => getApiV1HealthcheckResultsQueryKey,
   getApiV1HealthcheckStats: () => getApiV1HealthcheckStats,
+  getApiV1HealthcheckStatsOptions: () => getApiV1HealthcheckStatsOptions,
+  getApiV1HealthcheckStatsQueryKey: () => getApiV1HealthcheckStatsQueryKey,
   getApiV1NotificationPreferences: () => getApiV1NotificationPreferences,
+  getApiV1NotificationPreferencesOptions: () => getApiV1NotificationPreferencesOptions,
+  getApiV1NotificationPreferencesQueryKey: () => getApiV1NotificationPreferencesQueryKey,
   getApiV1NotificationSmtp: () => getApiV1NotificationSmtp,
+  getApiV1NotificationSmtpOptions: () => getApiV1NotificationSmtpOptions,
+  getApiV1NotificationSmtpQueryKey: () => getApiV1NotificationSmtpQueryKey,
   getApiV1NotificationWebhookType: () => getApiV1NotificationWebhookType,
+  getApiV1NotificationWebhookTypeOptions: () => getApiV1NotificationWebhookTypeOptions,
+  getApiV1NotificationWebhookTypeQueryKey: () => getApiV1NotificationWebhookTypeQueryKey,
   getApiV1Servers: () => getApiV1Servers,
+  getApiV1ServersOptions: () => getApiV1ServersOptions,
+  getApiV1ServersQueryKey: () => getApiV1ServersQueryKey,
   getApiV1ServersSshStatus: () => getApiV1ServersSshStatus,
+  getApiV1ServersSshStatusOptions: () => getApiV1ServersSshStatusOptions,
+  getApiV1ServersSshStatusQueryKey: () => getApiV1ServersSshStatusQueryKey,
   getApiV1TrailStatusSessionId: () => getApiV1TrailStatusSessionId,
+  getApiV1TrailStatusSessionIdOptions: () => getApiV1TrailStatusSessionIdOptions,
+  getApiV1TrailStatusSessionIdQueryKey: () => getApiV1TrailStatusSessionIdQueryKey,
   getApiV1UpdateCheck: () => getApiV1UpdateCheck,
+  getApiV1UpdateCheckOptions: () => getApiV1UpdateCheckOptions,
+  getApiV1UpdateCheckQueryKey: () => getApiV1UpdateCheckQueryKey,
   getApiV1User: () => getApiV1User,
   getApiV1UserOnboarded: () => getApiV1UserOnboarded,
+  getApiV1UserOnboardedOptions: () => getApiV1UserOnboardedOptions,
+  getApiV1UserOnboardedQueryKey: () => getApiV1UserOnboardedQueryKey,
+  getApiV1UserOptions: () => getApiV1UserOptions,
   getApiV1UserPreferences: () => getApiV1UserPreferences,
+  getApiV1UserPreferencesOptions: () => getApiV1UserPreferencesOptions,
+  getApiV1UserPreferencesQueryKey: () => getApiV1UserPreferencesQueryKey,
+  getApiV1UserQueryKey: () => getApiV1UserQueryKey,
   getApiV1UserSettings: () => getApiV1UserSettings,
+  getApiV1UserSettingsOptions: () => getApiV1UserSettingsOptions,
+  getApiV1UserSettingsQueryKey: () => getApiV1UserSettingsQueryKey,
   getWs: () => getWs,
   getWsLiveApplicationId: () => getWsLiveApplicationId,
+  getWsLiveApplicationIdOptions: () => getWsLiveApplicationIdOptions,
+  getWsLiveApplicationIdQueryKey: () => getWsLiveApplicationIdQueryKey,
+  getWsOptions: () => getWsOptions,
+  getWsQueryKey: () => getWsQueryKey,
   patchApiV1HealthcheckToggle: () => patchApiV1HealthcheckToggle,
+  patchApiV1HealthcheckToggleMutation: () => patchApiV1HealthcheckToggleMutation,
   patchApiV1UserAvatar: () => patchApiV1UserAvatar,
+  patchApiV1UserAvatarMutation: () => patchApiV1UserAvatarMutation,
   patchApiV1UserName: () => patchApiV1UserName,
+  patchApiV1UserNameMutation: () => patchApiV1UserNameMutation,
   patchApiV1UserSettingsAutoUpdate: () => patchApiV1UserSettingsAutoUpdate,
+  patchApiV1UserSettingsAutoUpdateMutation: () => patchApiV1UserSettingsAutoUpdateMutation,
   patchApiV1UserSettingsFont: () => patchApiV1UserSettingsFont,
+  patchApiV1UserSettingsFontMutation: () => patchApiV1UserSettingsFontMutation,
   patchApiV1UserSettingsLanguage: () => patchApiV1UserSettingsLanguage,
+  patchApiV1UserSettingsLanguageMutation: () => patchApiV1UserSettingsLanguageMutation,
   patchApiV1UserSettingsTheme: () => patchApiV1UserSettingsTheme,
+  patchApiV1UserSettingsThemeMutation: () => patchApiV1UserSettingsThemeMutation,
   postApiV1AuthCliInit: () => postApiV1AuthCliInit,
+  postApiV1AuthCliInitMutation: () => postApiV1AuthCliInitMutation,
   postApiV1ContainerContainerIdLogs: () => postApiV1ContainerContainerIdLogs,
+  postApiV1ContainerContainerIdLogsMutation: () => postApiV1ContainerContainerIdLogsMutation,
   postApiV1ContainerContainerIdRestart: () => postApiV1ContainerContainerIdRestart,
+  postApiV1ContainerContainerIdRestartMutation: () => postApiV1ContainerContainerIdRestartMutation,
   postApiV1ContainerContainerIdStart: () => postApiV1ContainerContainerIdStart,
+  postApiV1ContainerContainerIdStartMutation: () => postApiV1ContainerContainerIdStartMutation,
   postApiV1ContainerContainerIdStop: () => postApiV1ContainerContainerIdStop,
+  postApiV1ContainerContainerIdStopMutation: () => postApiV1ContainerContainerIdStopMutation,
   postApiV1ContainerImages: () => postApiV1ContainerImages,
+  postApiV1ContainerImagesMutation: () => postApiV1ContainerImagesMutation,
   postApiV1ContainerPruneBuildCache: () => postApiV1ContainerPruneBuildCache,
+  postApiV1ContainerPruneBuildCacheMutation: () => postApiV1ContainerPruneBuildCacheMutation,
   postApiV1ContainerPruneImages: () => postApiV1ContainerPruneImages,
+  postApiV1ContainerPruneImagesMutation: () => postApiV1ContainerPruneImagesMutation,
   postApiV1DeployApplication: () => postApiV1DeployApplication,
   postApiV1DeployApplicationDomains: () => postApiV1DeployApplicationDomains,
+  postApiV1DeployApplicationDomainsMutation: () => postApiV1DeployApplicationDomainsMutation,
+  postApiV1DeployApplicationMutation: () => postApiV1DeployApplicationMutation,
   postApiV1DeployApplicationProject: () => postApiV1DeployApplicationProject,
   postApiV1DeployApplicationProjectAddToFamily: () => postApiV1DeployApplicationProjectAddToFamily,
+  postApiV1DeployApplicationProjectAddToFamilyMutation: () => postApiV1DeployApplicationProjectAddToFamilyMutation,
   postApiV1DeployApplicationProjectDeploy: () => postApiV1DeployApplicationProjectDeploy,
+  postApiV1DeployApplicationProjectDeployMutation: () => postApiV1DeployApplicationProjectDeployMutation,
   postApiV1DeployApplicationProjectDuplicate: () => postApiV1DeployApplicationProjectDuplicate,
+  postApiV1DeployApplicationProjectDuplicateMutation: () => postApiV1DeployApplicationProjectDuplicateMutation,
+  postApiV1DeployApplicationProjectMutation: () => postApiV1DeployApplicationProjectMutation,
   postApiV1DeployApplicationRecover: () => postApiV1DeployApplicationRecover,
+  postApiV1DeployApplicationRecoverMutation: () => postApiV1DeployApplicationRecoverMutation,
   postApiV1DeployApplicationRedeploy: () => postApiV1DeployApplicationRedeploy,
+  postApiV1DeployApplicationRedeployMutation: () => postApiV1DeployApplicationRedeployMutation,
   postApiV1DeployApplicationRestart: () => postApiV1DeployApplicationRestart,
+  postApiV1DeployApplicationRestartMutation: () => postApiV1DeployApplicationRestartMutation,
   postApiV1DeployApplicationRollback: () => postApiV1DeployApplicationRollback,
+  postApiV1DeployApplicationRollbackMutation: () => postApiV1DeployApplicationRollbackMutation,
   postApiV1Domain: () => postApiV1Domain,
+  postApiV1DomainMutation: () => postApiV1DomainMutation,
   postApiV1ExtensionsExecutionExecutionIdCancel: () => postApiV1ExtensionsExecutionExecutionIdCancel,
+  postApiV1ExtensionsExecutionExecutionIdCancelMutation: () => postApiV1ExtensionsExecutionExecutionIdCancelMutation,
   postApiV1ExtensionsExtensionIdFork: () => postApiV1ExtensionsExtensionIdFork,
+  postApiV1ExtensionsExtensionIdForkMutation: () => postApiV1ExtensionsExtensionIdForkMutation,
   postApiV1ExtensionsExtensionIdRun: () => postApiV1ExtensionsExtensionIdRun,
+  postApiV1ExtensionsExtensionIdRunMutation: () => postApiV1ExtensionsExtensionIdRunMutation,
   postApiV1FileManagerCopyDirectory: () => postApiV1FileManagerCopyDirectory,
+  postApiV1FileManagerCopyDirectoryMutation: () => postApiV1FileManagerCopyDirectoryMutation,
   postApiV1FileManagerCreateDirectory: () => postApiV1FileManagerCreateDirectory,
+  postApiV1FileManagerCreateDirectoryMutation: () => postApiV1FileManagerCreateDirectoryMutation,
   postApiV1FileManagerMoveDirectory: () => postApiV1FileManagerMoveDirectory,
+  postApiV1FileManagerMoveDirectoryMutation: () => postApiV1FileManagerMoveDirectoryMutation,
   postApiV1FileManagerUpload: () => postApiV1FileManagerUpload,
+  postApiV1FileManagerUploadMutation: () => postApiV1FileManagerUploadMutation,
   postApiV1GithubConnector: () => postApiV1GithubConnector,
+  postApiV1GithubConnectorMutation: () => postApiV1GithubConnectorMutation,
   postApiV1GithubConnectorRepositoryBranches: () => postApiV1GithubConnectorRepositoryBranches,
+  postApiV1GithubConnectorRepositoryBranchesMutation: () => postApiV1GithubConnectorRepositoryBranchesMutation,
   postApiV1Healthcheck: () => postApiV1Healthcheck,
+  postApiV1HealthcheckMutation: () => postApiV1HealthcheckMutation,
   postApiV1LivePause: () => postApiV1LivePause,
+  postApiV1LivePauseMutation: () => postApiV1LivePauseMutation,
   postApiV1NotificationPreferences: () => postApiV1NotificationPreferences,
+  postApiV1NotificationPreferencesMutation: () => postApiV1NotificationPreferencesMutation,
   postApiV1NotificationSmtp: () => postApiV1NotificationSmtp,
+  postApiV1NotificationSmtpMutation: () => postApiV1NotificationSmtpMutation,
   postApiV1NotificationWebhook: () => postApiV1NotificationWebhook,
+  postApiV1NotificationWebhookMutation: () => postApiV1NotificationWebhookMutation,
   postApiV1TrailProvision: () => postApiV1TrailProvision,
+  postApiV1TrailProvisionMutation: () => postApiV1TrailProvisionMutation,
   postApiV1Update: () => postApiV1Update,
+  postApiV1UpdateMutation: () => postApiV1UpdateMutation,
   postApiV1UserOnboarded: () => postApiV1UserOnboarded,
+  postApiV1UserOnboardedMutation: () => postApiV1UserOnboardedMutation,
   postApiV1Webhook: () => postApiV1Webhook,
+  postApiV1WebhookMutation: () => postApiV1WebhookMutation,
   putApiV1ContainerContainerIdResources: () => putApiV1ContainerContainerIdResources,
+  putApiV1ContainerContainerIdResourcesMutation: () => putApiV1ContainerContainerIdResourcesMutation,
   putApiV1DeployApplication: () => putApiV1DeployApplication,
   putApiV1DeployApplicationLabels: () => putApiV1DeployApplicationLabels,
+  putApiV1DeployApplicationLabelsMutation: () => putApiV1DeployApplicationLabelsMutation,
+  putApiV1DeployApplicationMutation: () => putApiV1DeployApplicationMutation,
   putApiV1Domain: () => putApiV1Domain,
+  putApiV1DomainMutation: () => putApiV1DomainMutation,
   putApiV1FeatureFlags: () => putApiV1FeatureFlags,
+  putApiV1FeatureFlagsMutation: () => putApiV1FeatureFlagsMutation,
   putApiV1GithubConnector: () => putApiV1GithubConnector,
+  putApiV1GithubConnectorMutation: () => putApiV1GithubConnectorMutation,
   putApiV1Healthcheck: () => putApiV1Healthcheck,
+  putApiV1HealthcheckMutation: () => putApiV1HealthcheckMutation,
   putApiV1NotificationSmtp: () => putApiV1NotificationSmtp,
+  putApiV1NotificationSmtpMutation: () => putApiV1NotificationSmtpMutation,
   putApiV1NotificationWebhook: () => putApiV1NotificationWebhook,
+  putApiV1NotificationWebhookMutation: () => putApiV1NotificationWebhookMutation,
   putApiV1UserPreferences: () => putApiV1UserPreferences,
+  putApiV1UserPreferencesMutation: () => putApiV1UserPreferencesMutation,
   zAddApplicationDomainRequest: () => zAddApplicationDomainRequest,
   zAddApplicationToFamilyRequest: () => zAddApplicationToFamilyRequest,
   zAdminRegisteredResponse: () => zAdminRegisteredResponse,
@@ -463,6 +619,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/@tanstack/react-query.gen.ts
+var import_react_query = require("@tanstack/react-query");
+
 // src/core/bodySerializer.gen.ts
 var jsonBodySerializer = {
   bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
@@ -1778,6 +1937,1506 @@ var postApiV1Webhook = (options) => (options?.client ?? client).post({ url: "/ap
 var getWs = (options) => (options?.client ?? client).get({ url: "/ws", ...options });
 var getWsLiveApplicationId = (options) => (options.client ?? client).get({ url: "/ws/live/{application_id}", ...options });
 
+// src/@tanstack/react-query.gen.ts
+var createQueryKey = (id, options, infinite, tags) => {
+  const params = { _id: id, baseUrl: options?.baseUrl || (options?.client ?? client).getConfig().baseUrl };
+  if (infinite) {
+    params._infinite = infinite;
+  }
+  if (tags) {
+    params.tags = tags;
+  }
+  if (options?.body) {
+    params.body = options.body;
+  }
+  if (options?.headers) {
+    params.headers = options.headers;
+  }
+  if (options?.path) {
+    params.path = options.path;
+  }
+  if (options?.query) {
+    params.query = options.query;
+  }
+  return [params];
+};
+var getApiV1AuditLogsQueryKey = (options) => createQueryKey("getApiV1AuditLogs", options);
+var getApiV1AuditLogsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1AuditLogs({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1AuditLogsQueryKey(options)
+});
+var getApiV1AuthBootstrapQueryKey = (options) => createQueryKey("getApiV1AuthBootstrap", options);
+var getApiV1AuthBootstrapOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1AuthBootstrap({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1AuthBootstrapQueryKey(options)
+});
+var postApiV1AuthCliInitMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1AuthCliInit({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1AuthIsAdminRegisteredQueryKey = (options) => createQueryKey("getApiV1AuthIsAdminRegistered", options);
+var getApiV1AuthIsAdminRegisteredOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1AuthIsAdminRegistered({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1AuthIsAdminRegisteredQueryKey(options)
+});
+var getApiV1ContainerQueryKey = (options) => createQueryKey("getApiV1Container", options);
+var getApiV1ContainerOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1Container({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ContainerQueryKey(options)
+});
+var postApiV1ContainerImagesMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ContainerImages({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1ContainerPruneBuildCacheMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ContainerPruneBuildCache({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1ContainerPruneImagesMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ContainerPruneImages({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var deleteApiV1ContainerContainerIdMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1ContainerContainerId({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1ContainerContainerIdQueryKey = (options) => createQueryKey("getApiV1ContainerContainerId", options);
+var getApiV1ContainerContainerIdOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1ContainerContainerId({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ContainerContainerIdQueryKey(options)
+});
+var postApiV1ContainerContainerIdLogsMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ContainerContainerIdLogs({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var putApiV1ContainerContainerIdResourcesMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1ContainerContainerIdResources({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1ContainerContainerIdRestartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ContainerContainerIdRestart({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1ContainerContainerIdStartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ContainerContainerIdStart({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1ContainerContainerIdStopMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ContainerContainerIdStop({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var deleteApiV1DeployApplicationMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1DeployApplication({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1DeployApplicationQueryKey = (options) => createQueryKey("getApiV1DeployApplication", options);
+var getApiV1DeployApplicationOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1DeployApplication({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DeployApplicationQueryKey(options)
+});
+var postApiV1DeployApplicationMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplication({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var putApiV1DeployApplicationMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1DeployApplication({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1DeployApplicationDeploymentsQueryKey = (options) => createQueryKey("getApiV1DeployApplicationDeployments", options);
+var getApiV1DeployApplicationDeploymentsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1DeployApplicationDeployments({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DeployApplicationDeploymentsQueryKey(options)
+});
+var createInfiniteParams = (queryKey, page) => {
+  const params = { ...queryKey[0] };
+  if (page.body) {
+    params.body = {
+      ...queryKey[0].body,
+      ...page.body
+    };
+  }
+  if (page.headers) {
+    params.headers = {
+      ...queryKey[0].headers,
+      ...page.headers
+    };
+  }
+  if (page.path) {
+    params.path = {
+      ...queryKey[0].path,
+      ...page.path
+    };
+  }
+  if (page.query) {
+    params.query = {
+      ...queryKey[0].query,
+      ...page.query
+    };
+  }
+  return params;
+};
+var getApiV1DeployApplicationDeploymentsInfiniteQueryKey = (options) => createQueryKey("getApiV1DeployApplicationDeployments", options, true);
+var getApiV1DeployApplicationDeploymentsInfiniteOptions = (options) => (0, import_react_query.infiniteQueryOptions)(
+  // @ts-ignore
+  {
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+      const page = typeof pageParam === "object" ? pageParam : {
+        body: {
+          page: pageParam
+        }
+      };
+      const params = createInfiniteParams(queryKey, page);
+      const { data } = await getApiV1DeployApplicationDeployments({
+        ...options,
+        ...params,
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getApiV1DeployApplicationDeploymentsInfiniteQueryKey(options)
+  }
+);
+var getApiV1DeployApplicationDeploymentsDeploymentIdQueryKey = (options) => createQueryKey("getApiV1DeployApplicationDeploymentsDeploymentId", options);
+var getApiV1DeployApplicationDeploymentsDeploymentIdOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1DeployApplicationDeploymentsDeploymentId({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DeployApplicationDeploymentsDeploymentIdQueryKey(options)
+});
+var getApiV1DeployApplicationDeploymentsDeploymentIdLogsQueryKey = (options) => createQueryKey("getApiV1DeployApplicationDeploymentsDeploymentIdLogs", options);
+var getApiV1DeployApplicationDeploymentsDeploymentIdLogsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1DeployApplicationDeploymentsDeploymentIdLogs({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DeployApplicationDeploymentsDeploymentIdLogsQueryKey(options)
+});
+var deleteApiV1DeployApplicationDomainsMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1DeployApplicationDomains({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1DeployApplicationDomainsMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplicationDomains({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var putApiV1DeployApplicationLabelsMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1DeployApplicationLabels({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1DeployApplicationLogsApplicationIdQueryKey = (options) => createQueryKey("getApiV1DeployApplicationLogsApplicationId", options);
+var getApiV1DeployApplicationLogsApplicationIdOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1DeployApplicationLogsApplicationId({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DeployApplicationLogsApplicationIdQueryKey(options)
+});
+var postApiV1DeployApplicationProjectMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplicationProject({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1DeployApplicationProjectAddToFamilyMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplicationProjectAddToFamily({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1DeployApplicationProjectDeployMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplicationProjectDeploy({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1DeployApplicationProjectDuplicateMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplicationProjectDuplicate({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1DeployApplicationProjectFamilyQueryKey = (options) => createQueryKey("getApiV1DeployApplicationProjectFamily", options);
+var getApiV1DeployApplicationProjectFamilyOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1DeployApplicationProjectFamily({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DeployApplicationProjectFamilyQueryKey(options)
+});
+var getApiV1DeployApplicationProjectFamilyEnvironmentsQueryKey = (options) => createQueryKey("getApiV1DeployApplicationProjectFamilyEnvironments", options);
+var getApiV1DeployApplicationProjectFamilyEnvironmentsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1DeployApplicationProjectFamilyEnvironments({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DeployApplicationProjectFamilyEnvironmentsQueryKey(options)
+});
+var postApiV1DeployApplicationRecoverMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplicationRecover({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1DeployApplicationRedeployMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplicationRedeploy({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1DeployApplicationRestartMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplicationRestart({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1DeployApplicationRollbackMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1DeployApplicationRollback({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1DeployApplicationsQueryKey = (options) => createQueryKey("getApiV1DeployApplications", options);
+var getApiV1DeployApplicationsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1DeployApplications({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DeployApplicationsQueryKey(options)
+});
+var getApiV1DeployApplicationsInfiniteQueryKey = (options) => createQueryKey("getApiV1DeployApplications", options, true);
+var getApiV1DeployApplicationsInfiniteOptions = (options) => (0, import_react_query.infiniteQueryOptions)(
+  // @ts-ignore
+  {
+    queryFn: async ({ pageParam, queryKey, signal }) => {
+      const page = typeof pageParam === "object" ? pageParam : {
+        body: {
+          page: pageParam
+        }
+      };
+      const params = createInfiniteParams(queryKey, page);
+      const { data } = await getApiV1DeployApplications({
+        ...options,
+        ...params,
+        signal,
+        throwOnError: true
+      });
+      return data;
+    },
+    queryKey: getApiV1DeployApplicationsInfiniteQueryKey(options)
+  }
+);
+var deleteApiV1DomainMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1Domain({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1DomainMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1Domain({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var putApiV1DomainMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1Domain({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1DomainGenerateQueryKey = (options) => createQueryKey("getApiV1DomainGenerate", options);
+var getApiV1DomainGenerateOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1DomainGenerate({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DomainGenerateQueryKey(options)
+});
+var getApiV1DomainsQueryKey = (options) => createQueryKey("getApiV1Domains", options);
+var getApiV1DomainsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1Domains({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1DomainsQueryKey(options)
+});
+var getApiV1ExtensionsQueryKey = (options) => createQueryKey("getApiV1Extensions", options);
+var getApiV1ExtensionsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1Extensions({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ExtensionsQueryKey(options)
+});
+var getApiV1ExtensionsByExtensionIdExtensionIdQueryKey = (options) => createQueryKey("getApiV1ExtensionsByExtensionIdExtensionId", options);
+var getApiV1ExtensionsByExtensionIdExtensionIdOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1ExtensionsByExtensionIdExtensionId({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ExtensionsByExtensionIdExtensionIdQueryKey(options)
+});
+var getApiV1ExtensionsByExtensionIdExtensionIdExecutionsQueryKey = (options) => createQueryKey("getApiV1ExtensionsByExtensionIdExtensionIdExecutions", options);
+var getApiV1ExtensionsByExtensionIdExtensionIdExecutionsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1ExtensionsByExtensionIdExtensionIdExecutions({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ExtensionsByExtensionIdExtensionIdExecutionsQueryKey(options)
+});
+var getApiV1ExtensionsCategoriesQueryKey = (options) => createQueryKey("getApiV1ExtensionsCategories", options);
+var getApiV1ExtensionsCategoriesOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1ExtensionsCategories({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ExtensionsCategoriesQueryKey(options)
+});
+var getApiV1ExtensionsExecutionExecutionIdQueryKey = (options) => createQueryKey("getApiV1ExtensionsExecutionExecutionId", options);
+var getApiV1ExtensionsExecutionExecutionIdOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1ExtensionsExecutionExecutionId({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ExtensionsExecutionExecutionIdQueryKey(options)
+});
+var postApiV1ExtensionsExecutionExecutionIdCancelMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ExtensionsExecutionExecutionIdCancel({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1ExtensionsExecutionExecutionIdLogsQueryKey = (options) => createQueryKey("getApiV1ExtensionsExecutionExecutionIdLogs", options);
+var getApiV1ExtensionsExecutionExecutionIdLogsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1ExtensionsExecutionExecutionIdLogs({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ExtensionsExecutionExecutionIdLogsQueryKey(options)
+});
+var postApiV1ExtensionsExtensionIdForkMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ExtensionsExtensionIdFork({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1ExtensionsExtensionIdRunMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1ExtensionsExtensionIdRun({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var deleteApiV1ExtensionsIdMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1ExtensionsId({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1ExtensionsIdQueryKey = (options) => createQueryKey("getApiV1ExtensionsId", options);
+var getApiV1ExtensionsIdOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1ExtensionsId({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ExtensionsIdQueryKey(options)
+});
+var getApiV1FeatureFlagsQueryKey = (options) => createQueryKey("getApiV1FeatureFlags", options);
+var getApiV1FeatureFlagsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1FeatureFlags({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1FeatureFlagsQueryKey(options)
+});
+var putApiV1FeatureFlagsMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1FeatureFlags({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1FeatureFlagsCheckQueryKey = (options) => createQueryKey("getApiV1FeatureFlagsCheck", options);
+var getApiV1FeatureFlagsCheckOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1FeatureFlagsCheck({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1FeatureFlagsCheckQueryKey(options)
+});
+var getApiV1FileManagerQueryKey = (options) => createQueryKey("getApiV1FileManager", options);
+var getApiV1FileManagerOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1FileManager({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1FileManagerQueryKey(options)
+});
+var postApiV1FileManagerCopyDirectoryMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1FileManagerCopyDirectory({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1FileManagerCreateDirectoryMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1FileManagerCreateDirectory({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var deleteApiV1FileManagerDeleteDirectoryMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1FileManagerDeleteDirectory({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1FileManagerMoveDirectoryMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1FileManagerMoveDirectory({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1FileManagerUploadMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1FileManagerUpload({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var deleteApiV1GithubConnectorMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1GithubConnector({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1GithubConnectorMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1GithubConnector({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var putApiV1GithubConnectorMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1GithubConnector({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1GithubConnectorAllQueryKey = (options) => createQueryKey("getApiV1GithubConnectorAll", options);
+var getApiV1GithubConnectorAllOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1GithubConnectorAll({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1GithubConnectorAllQueryKey(options)
+});
+var getApiV1GithubConnectorRepositoriesQueryKey = (options) => createQueryKey("getApiV1GithubConnectorRepositories", options);
+var getApiV1GithubConnectorRepositoriesOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1GithubConnectorRepositories({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1GithubConnectorRepositoriesQueryKey(options)
+});
+var postApiV1GithubConnectorRepositoryBranchesMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1GithubConnectorRepositoryBranches({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1HealthQueryKey = (options) => createQueryKey("getApiV1Health", options);
+var getApiV1HealthOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1Health({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1HealthQueryKey(options)
+});
+var deleteApiV1HealthcheckMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1Healthcheck({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1HealthcheckQueryKey = (options) => createQueryKey("getApiV1Healthcheck", options);
+var getApiV1HealthcheckOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1Healthcheck({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1HealthcheckQueryKey(options)
+});
+var postApiV1HealthcheckMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1Healthcheck({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var putApiV1HealthcheckMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1Healthcheck({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1HealthcheckResultsQueryKey = (options) => createQueryKey("getApiV1HealthcheckResults", options);
+var getApiV1HealthcheckResultsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1HealthcheckResults({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1HealthcheckResultsQueryKey(options)
+});
+var getApiV1HealthcheckStatsQueryKey = (options) => createQueryKey("getApiV1HealthcheckStats", options);
+var getApiV1HealthcheckStatsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1HealthcheckStats({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1HealthcheckStatsQueryKey(options)
+});
+var patchApiV1HealthcheckToggleMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await patchApiV1HealthcheckToggle({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1LivePauseMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1LivePause({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1NotificationPreferencesQueryKey = (options) => createQueryKey("getApiV1NotificationPreferences", options);
+var getApiV1NotificationPreferencesOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1NotificationPreferences({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1NotificationPreferencesQueryKey(options)
+});
+var postApiV1NotificationPreferencesMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1NotificationPreferences({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var deleteApiV1NotificationSmtpMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1NotificationSmtp({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1NotificationSmtpQueryKey = (options) => createQueryKey("getApiV1NotificationSmtp", options);
+var getApiV1NotificationSmtpOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1NotificationSmtp({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1NotificationSmtpQueryKey(options)
+});
+var postApiV1NotificationSmtpMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1NotificationSmtp({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var putApiV1NotificationSmtpMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1NotificationSmtp({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var deleteApiV1NotificationWebhookMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await deleteApiV1NotificationWebhook({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1NotificationWebhookMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1NotificationWebhook({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var putApiV1NotificationWebhookMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1NotificationWebhook({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1NotificationWebhookTypeQueryKey = (options) => createQueryKey("getApiV1NotificationWebhookType", options);
+var getApiV1NotificationWebhookTypeOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1NotificationWebhookType({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1NotificationWebhookTypeQueryKey(options)
+});
+var getApiV1ServersQueryKey = (options) => createQueryKey("getApiV1Servers", options);
+var getApiV1ServersOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1Servers({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ServersQueryKey(options)
+});
+var getApiV1ServersSshStatusQueryKey = (options) => createQueryKey("getApiV1ServersSshStatus", options);
+var getApiV1ServersSshStatusOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1ServersSshStatus({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1ServersSshStatusQueryKey(options)
+});
+var postApiV1TrailProvisionMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1TrailProvision({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1TrailStatusSessionIdQueryKey = (options) => createQueryKey("getApiV1TrailStatusSessionId", options);
+var getApiV1TrailStatusSessionIdOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1TrailStatusSessionId({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1TrailStatusSessionIdQueryKey(options)
+});
+var postApiV1UpdateMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1Update({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1UpdateCheckQueryKey = (options) => createQueryKey("getApiV1UpdateCheck", options);
+var getApiV1UpdateCheckOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1UpdateCheck({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1UpdateCheckQueryKey(options)
+});
+var getApiV1UserQueryKey = (options) => createQueryKey("getApiV1User", options);
+var getApiV1UserOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1User({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1UserQueryKey(options)
+});
+var patchApiV1UserAvatarMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await patchApiV1UserAvatar({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var patchApiV1UserNameMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await patchApiV1UserName({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1UserOnboardedQueryKey = (options) => createQueryKey("getApiV1UserOnboarded", options);
+var getApiV1UserOnboardedOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1UserOnboarded({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1UserOnboardedQueryKey(options)
+});
+var postApiV1UserOnboardedMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1UserOnboarded({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1UserPreferencesQueryKey = (options) => createQueryKey("getApiV1UserPreferences", options);
+var getApiV1UserPreferencesOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1UserPreferences({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1UserPreferencesQueryKey(options)
+});
+var putApiV1UserPreferencesMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await putApiV1UserPreferences({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getApiV1UserSettingsQueryKey = (options) => createQueryKey("getApiV1UserSettings", options);
+var getApiV1UserSettingsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getApiV1UserSettings({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getApiV1UserSettingsQueryKey(options)
+});
+var patchApiV1UserSettingsAutoUpdateMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await patchApiV1UserSettingsAutoUpdate({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var patchApiV1UserSettingsFontMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await patchApiV1UserSettingsFont({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var patchApiV1UserSettingsLanguageMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await patchApiV1UserSettingsLanguage({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var patchApiV1UserSettingsThemeMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await patchApiV1UserSettingsTheme({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var postApiV1WebhookMutation = (options) => {
+  const mutationOptions = {
+    mutationFn: async (fnOptions) => {
+      const { data } = await postApiV1Webhook({
+        ...options,
+        ...fnOptions,
+        throwOnError: true
+      });
+      return data;
+    }
+  };
+  return mutationOptions;
+};
+var getWsQueryKey = (options) => createQueryKey("getWs", options);
+var getWsOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getWs({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getWsQueryKey(options)
+});
+var getWsLiveApplicationIdQueryKey = (options) => createQueryKey("getWsLiveApplicationId", options);
+var getWsLiveApplicationIdOptions = (options) => (0, import_react_query.queryOptions)({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getWsLiveApplicationId({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getWsLiveApplicationIdQueryKey(options)
+});
+
 // src/zod.gen.ts
 var import_zod = require("zod");
 var zAddApplicationDomainRequest = import_zod.z.object({
@@ -5625,113 +7284,269 @@ var zGetApiV1DeployApplicationsResponse = zListApplicationsResponse;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   deleteApiV1ContainerContainerId,
+  deleteApiV1ContainerContainerIdMutation,
   deleteApiV1DeployApplication,
   deleteApiV1DeployApplicationDomains,
+  deleteApiV1DeployApplicationDomainsMutation,
+  deleteApiV1DeployApplicationMutation,
   deleteApiV1Domain,
+  deleteApiV1DomainMutation,
   deleteApiV1ExtensionsId,
+  deleteApiV1ExtensionsIdMutation,
   deleteApiV1FileManagerDeleteDirectory,
+  deleteApiV1FileManagerDeleteDirectoryMutation,
   deleteApiV1GithubConnector,
+  deleteApiV1GithubConnectorMutation,
   deleteApiV1Healthcheck,
+  deleteApiV1HealthcheckMutation,
   deleteApiV1NotificationSmtp,
+  deleteApiV1NotificationSmtpMutation,
   deleteApiV1NotificationWebhook,
+  deleteApiV1NotificationWebhookMutation,
   getApiV1AuditLogs,
+  getApiV1AuditLogsOptions,
+  getApiV1AuditLogsQueryKey,
   getApiV1AuthBootstrap,
+  getApiV1AuthBootstrapOptions,
+  getApiV1AuthBootstrapQueryKey,
   getApiV1AuthIsAdminRegistered,
+  getApiV1AuthIsAdminRegisteredOptions,
+  getApiV1AuthIsAdminRegisteredQueryKey,
   getApiV1Container,
   getApiV1ContainerContainerId,
+  getApiV1ContainerContainerIdOptions,
+  getApiV1ContainerContainerIdQueryKey,
+  getApiV1ContainerOptions,
+  getApiV1ContainerQueryKey,
   getApiV1DeployApplication,
   getApiV1DeployApplicationDeployments,
   getApiV1DeployApplicationDeploymentsDeploymentId,
   getApiV1DeployApplicationDeploymentsDeploymentIdLogs,
+  getApiV1DeployApplicationDeploymentsDeploymentIdLogsOptions,
+  getApiV1DeployApplicationDeploymentsDeploymentIdLogsQueryKey,
+  getApiV1DeployApplicationDeploymentsDeploymentIdOptions,
+  getApiV1DeployApplicationDeploymentsDeploymentIdQueryKey,
+  getApiV1DeployApplicationDeploymentsInfiniteOptions,
+  getApiV1DeployApplicationDeploymentsInfiniteQueryKey,
+  getApiV1DeployApplicationDeploymentsOptions,
+  getApiV1DeployApplicationDeploymentsQueryKey,
   getApiV1DeployApplicationLogsApplicationId,
+  getApiV1DeployApplicationLogsApplicationIdOptions,
+  getApiV1DeployApplicationLogsApplicationIdQueryKey,
+  getApiV1DeployApplicationOptions,
   getApiV1DeployApplicationProjectFamily,
   getApiV1DeployApplicationProjectFamilyEnvironments,
+  getApiV1DeployApplicationProjectFamilyEnvironmentsOptions,
+  getApiV1DeployApplicationProjectFamilyEnvironmentsQueryKey,
+  getApiV1DeployApplicationProjectFamilyOptions,
+  getApiV1DeployApplicationProjectFamilyQueryKey,
+  getApiV1DeployApplicationQueryKey,
   getApiV1DeployApplications,
+  getApiV1DeployApplicationsInfiniteOptions,
+  getApiV1DeployApplicationsInfiniteQueryKey,
+  getApiV1DeployApplicationsOptions,
+  getApiV1DeployApplicationsQueryKey,
   getApiV1DomainGenerate,
+  getApiV1DomainGenerateOptions,
+  getApiV1DomainGenerateQueryKey,
   getApiV1Domains,
+  getApiV1DomainsOptions,
+  getApiV1DomainsQueryKey,
   getApiV1Extensions,
   getApiV1ExtensionsByExtensionIdExtensionId,
   getApiV1ExtensionsByExtensionIdExtensionIdExecutions,
+  getApiV1ExtensionsByExtensionIdExtensionIdExecutionsOptions,
+  getApiV1ExtensionsByExtensionIdExtensionIdExecutionsQueryKey,
+  getApiV1ExtensionsByExtensionIdExtensionIdOptions,
+  getApiV1ExtensionsByExtensionIdExtensionIdQueryKey,
   getApiV1ExtensionsCategories,
+  getApiV1ExtensionsCategoriesOptions,
+  getApiV1ExtensionsCategoriesQueryKey,
   getApiV1ExtensionsExecutionExecutionId,
   getApiV1ExtensionsExecutionExecutionIdLogs,
+  getApiV1ExtensionsExecutionExecutionIdLogsOptions,
+  getApiV1ExtensionsExecutionExecutionIdLogsQueryKey,
+  getApiV1ExtensionsExecutionExecutionIdOptions,
+  getApiV1ExtensionsExecutionExecutionIdQueryKey,
   getApiV1ExtensionsId,
+  getApiV1ExtensionsIdOptions,
+  getApiV1ExtensionsIdQueryKey,
+  getApiV1ExtensionsOptions,
+  getApiV1ExtensionsQueryKey,
   getApiV1FeatureFlags,
   getApiV1FeatureFlagsCheck,
+  getApiV1FeatureFlagsCheckOptions,
+  getApiV1FeatureFlagsCheckQueryKey,
+  getApiV1FeatureFlagsOptions,
+  getApiV1FeatureFlagsQueryKey,
   getApiV1FileManager,
+  getApiV1FileManagerOptions,
+  getApiV1FileManagerQueryKey,
   getApiV1GithubConnectorAll,
+  getApiV1GithubConnectorAllOptions,
+  getApiV1GithubConnectorAllQueryKey,
   getApiV1GithubConnectorRepositories,
+  getApiV1GithubConnectorRepositoriesOptions,
+  getApiV1GithubConnectorRepositoriesQueryKey,
   getApiV1Health,
+  getApiV1HealthOptions,
+  getApiV1HealthQueryKey,
   getApiV1Healthcheck,
+  getApiV1HealthcheckOptions,
+  getApiV1HealthcheckQueryKey,
   getApiV1HealthcheckResults,
+  getApiV1HealthcheckResultsOptions,
+  getApiV1HealthcheckResultsQueryKey,
   getApiV1HealthcheckStats,
+  getApiV1HealthcheckStatsOptions,
+  getApiV1HealthcheckStatsQueryKey,
   getApiV1NotificationPreferences,
+  getApiV1NotificationPreferencesOptions,
+  getApiV1NotificationPreferencesQueryKey,
   getApiV1NotificationSmtp,
+  getApiV1NotificationSmtpOptions,
+  getApiV1NotificationSmtpQueryKey,
   getApiV1NotificationWebhookType,
+  getApiV1NotificationWebhookTypeOptions,
+  getApiV1NotificationWebhookTypeQueryKey,
   getApiV1Servers,
+  getApiV1ServersOptions,
+  getApiV1ServersQueryKey,
   getApiV1ServersSshStatus,
+  getApiV1ServersSshStatusOptions,
+  getApiV1ServersSshStatusQueryKey,
   getApiV1TrailStatusSessionId,
+  getApiV1TrailStatusSessionIdOptions,
+  getApiV1TrailStatusSessionIdQueryKey,
   getApiV1UpdateCheck,
+  getApiV1UpdateCheckOptions,
+  getApiV1UpdateCheckQueryKey,
   getApiV1User,
   getApiV1UserOnboarded,
+  getApiV1UserOnboardedOptions,
+  getApiV1UserOnboardedQueryKey,
+  getApiV1UserOptions,
   getApiV1UserPreferences,
+  getApiV1UserPreferencesOptions,
+  getApiV1UserPreferencesQueryKey,
+  getApiV1UserQueryKey,
   getApiV1UserSettings,
+  getApiV1UserSettingsOptions,
+  getApiV1UserSettingsQueryKey,
   getWs,
   getWsLiveApplicationId,
+  getWsLiveApplicationIdOptions,
+  getWsLiveApplicationIdQueryKey,
+  getWsOptions,
+  getWsQueryKey,
   patchApiV1HealthcheckToggle,
+  patchApiV1HealthcheckToggleMutation,
   patchApiV1UserAvatar,
+  patchApiV1UserAvatarMutation,
   patchApiV1UserName,
+  patchApiV1UserNameMutation,
   patchApiV1UserSettingsAutoUpdate,
+  patchApiV1UserSettingsAutoUpdateMutation,
   patchApiV1UserSettingsFont,
+  patchApiV1UserSettingsFontMutation,
   patchApiV1UserSettingsLanguage,
+  patchApiV1UserSettingsLanguageMutation,
   patchApiV1UserSettingsTheme,
+  patchApiV1UserSettingsThemeMutation,
   postApiV1AuthCliInit,
+  postApiV1AuthCliInitMutation,
   postApiV1ContainerContainerIdLogs,
+  postApiV1ContainerContainerIdLogsMutation,
   postApiV1ContainerContainerIdRestart,
+  postApiV1ContainerContainerIdRestartMutation,
   postApiV1ContainerContainerIdStart,
+  postApiV1ContainerContainerIdStartMutation,
   postApiV1ContainerContainerIdStop,
+  postApiV1ContainerContainerIdStopMutation,
   postApiV1ContainerImages,
+  postApiV1ContainerImagesMutation,
   postApiV1ContainerPruneBuildCache,
+  postApiV1ContainerPruneBuildCacheMutation,
   postApiV1ContainerPruneImages,
+  postApiV1ContainerPruneImagesMutation,
   postApiV1DeployApplication,
   postApiV1DeployApplicationDomains,
+  postApiV1DeployApplicationDomainsMutation,
+  postApiV1DeployApplicationMutation,
   postApiV1DeployApplicationProject,
   postApiV1DeployApplicationProjectAddToFamily,
+  postApiV1DeployApplicationProjectAddToFamilyMutation,
   postApiV1DeployApplicationProjectDeploy,
+  postApiV1DeployApplicationProjectDeployMutation,
   postApiV1DeployApplicationProjectDuplicate,
+  postApiV1DeployApplicationProjectDuplicateMutation,
+  postApiV1DeployApplicationProjectMutation,
   postApiV1DeployApplicationRecover,
+  postApiV1DeployApplicationRecoverMutation,
   postApiV1DeployApplicationRedeploy,
+  postApiV1DeployApplicationRedeployMutation,
   postApiV1DeployApplicationRestart,
+  postApiV1DeployApplicationRestartMutation,
   postApiV1DeployApplicationRollback,
+  postApiV1DeployApplicationRollbackMutation,
   postApiV1Domain,
+  postApiV1DomainMutation,
   postApiV1ExtensionsExecutionExecutionIdCancel,
+  postApiV1ExtensionsExecutionExecutionIdCancelMutation,
   postApiV1ExtensionsExtensionIdFork,
+  postApiV1ExtensionsExtensionIdForkMutation,
   postApiV1ExtensionsExtensionIdRun,
+  postApiV1ExtensionsExtensionIdRunMutation,
   postApiV1FileManagerCopyDirectory,
+  postApiV1FileManagerCopyDirectoryMutation,
   postApiV1FileManagerCreateDirectory,
+  postApiV1FileManagerCreateDirectoryMutation,
   postApiV1FileManagerMoveDirectory,
+  postApiV1FileManagerMoveDirectoryMutation,
   postApiV1FileManagerUpload,
+  postApiV1FileManagerUploadMutation,
   postApiV1GithubConnector,
+  postApiV1GithubConnectorMutation,
   postApiV1GithubConnectorRepositoryBranches,
+  postApiV1GithubConnectorRepositoryBranchesMutation,
   postApiV1Healthcheck,
+  postApiV1HealthcheckMutation,
   postApiV1LivePause,
+  postApiV1LivePauseMutation,
   postApiV1NotificationPreferences,
+  postApiV1NotificationPreferencesMutation,
   postApiV1NotificationSmtp,
+  postApiV1NotificationSmtpMutation,
   postApiV1NotificationWebhook,
+  postApiV1NotificationWebhookMutation,
   postApiV1TrailProvision,
+  postApiV1TrailProvisionMutation,
   postApiV1Update,
+  postApiV1UpdateMutation,
   postApiV1UserOnboarded,
+  postApiV1UserOnboardedMutation,
   postApiV1Webhook,
+  postApiV1WebhookMutation,
   putApiV1ContainerContainerIdResources,
+  putApiV1ContainerContainerIdResourcesMutation,
   putApiV1DeployApplication,
   putApiV1DeployApplicationLabels,
+  putApiV1DeployApplicationLabelsMutation,
+  putApiV1DeployApplicationMutation,
   putApiV1Domain,
+  putApiV1DomainMutation,
   putApiV1FeatureFlags,
+  putApiV1FeatureFlagsMutation,
   putApiV1GithubConnector,
+  putApiV1GithubConnectorMutation,
   putApiV1Healthcheck,
+  putApiV1HealthcheckMutation,
   putApiV1NotificationSmtp,
+  putApiV1NotificationSmtpMutation,
   putApiV1NotificationWebhook,
+  putApiV1NotificationWebhookMutation,
   putApiV1UserPreferences,
+  putApiV1UserPreferencesMutation,
   zAddApplicationDomainRequest,
   zAddApplicationToFamilyRequest,
   zAdminRegisteredResponse,