@nixopus/api-client 0.0.3 → 0.0.4

package/dist/index.mjs

@@ -1,3 +1,6 @@
+// src/@tanstack/react-query.gen.ts
+import { infiniteQueryOptions, queryOptions } from "@tanstack/react-query";
+
 // src/core/bodySerializer.gen.ts
 var jsonBodySerializer = {
   bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
@@ -1313,6 +1316,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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => 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) => queryOptions({
+  queryFn: async ({ queryKey, signal }) => {
+    const { data } = await getWsLiveApplicationId({
+      ...options,
+      ...queryKey[0],
+      signal,
+      throwOnError: true
+    });
+    return data;
+  },
+  queryKey: getWsLiveApplicationIdQueryKey(options)
+});
+
 // src/zod.gen.ts
 import { z } from "zod";
 var zAddApplicationDomainRequest = z.object({
@@ -5159,113 +6662,269 @@ var zGetApiV1DeployApplicationsData = z.object({
 var zGetApiV1DeployApplicationsResponse = zListApplicationsResponse;
 export {
   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,