vercel-api-js 1.0.1 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,4495 @@
+'use strict';
+
+const schemas = require('./shared/vercel-api-js.BaOSBqhR.cjs');
+require('zod');
+
+async function readAccessGroup({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v1/access-groups/${idOrName}`, queryParams, ...requestConfig });
+  return data;
+}
+async function updateAccessGroup({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/access-groups/${idOrName}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteAccessGroup({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/access-groups/${idOrName}`, queryParams, ...requestConfig });
+  return data;
+}
+async function listAccessGroupMembers({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v1/access-groups/${idOrName}/members`, queryParams, ...requestConfig });
+  return data;
+}
+async function listAccessGroups({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v1/access-groups`, queryParams, ...requestConfig });
+  return data;
+}
+async function createAccessGroup({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v1/access-groups`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function listAccessGroupProjects({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v1/access-groups/${idOrName}/projects`, queryParams, ...requestConfig });
+  return data;
+}
+async function createAccessGroupProject({
+  pathParams: { accessGroupIdOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!accessGroupIdOrName) {
+    throw new Error(`Missing required path parameter: accessGroupIdOrName`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/access-groups/${accessGroupIdOrName}/projects`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function readAccessGroupProject({
+  pathParams: { accessGroupIdOrName, projectId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!accessGroupIdOrName) {
+    throw new Error(`Missing required path parameter: accessGroupIdOrName`);
+  }
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  const data = await request({
+    method: "GET",
+    url: `/v1/access-groups/${accessGroupIdOrName}/projects/${projectId}`,
+    queryParams,
+    ...requestConfig
+  });
+  return data;
+}
+async function updateAccessGroupProject({
+  pathParams: { accessGroupIdOrName, projectId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!accessGroupIdOrName) {
+    throw new Error(`Missing required path parameter: accessGroupIdOrName`);
+  }
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/access-groups/${accessGroupIdOrName}/projects/${projectId}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteAccessGroupProject({
+  pathParams: { accessGroupIdOrName, projectId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!accessGroupIdOrName) {
+    throw new Error(`Missing required path parameter: accessGroupIdOrName`);
+  }
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  const data = await request({
+    method: "DELETE",
+    url: `/v1/access-groups/${accessGroupIdOrName}/projects/${projectId}`,
+    queryParams,
+    ...requestConfig
+  });
+  return data;
+}
+async function recordEvents({
+  queryParams,
+  headers,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v8/artifacts/events`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...headers, ...requestConfig.headers }
+  });
+  return data;
+}
+async function status({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v8/artifacts/status`, queryParams, ...requestConfig });
+  return data;
+}
+async function uploadArtifact({
+  pathParams: { hash },
+  headers,
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!hash) {
+    throw new Error(`Missing required path parameter: hash`);
+  }
+  const data = await request({
+    method: "PUT",
+    url: `/v8/artifacts/${hash}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationOctetStream", ...headers, ...requestConfig.headers }
+  });
+  return data;
+}
+async function downloadArtifact({
+  pathParams: { hash },
+  queryParams,
+  headers,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!hash) {
+    throw new Error(`Missing required path parameter: hash`);
+  }
+  const data = await request({
+    method: "GET",
+    url: `/v8/artifacts/${hash}`,
+    queryParams,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return data;
+}
+async function artifactQuery({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v8/artifacts`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function createCheck({
+  pathParams: { deploymentId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/deployments/${deploymentId}/checks`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getAllChecks({
+  pathParams: { deploymentId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/deployments/${deploymentId}/checks`, queryParams, ...requestConfig });
+  return data;
+}
+async function getCheck({
+  pathParams: { deploymentId, checkId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  if (!checkId) {
+    throw new Error(`Missing required path parameter: checkId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/deployments/${deploymentId}/checks/${checkId}`, queryParams, ...requestConfig });
+  return data;
+}
+async function updateCheck({
+  pathParams: { deploymentId, checkId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  if (!checkId) {
+    throw new Error(`Missing required path parameter: checkId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/deployments/${deploymentId}/checks/${checkId}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function rerequestCheck({
+  pathParams: { deploymentId, checkId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  if (!checkId) {
+    throw new Error(`Missing required path parameter: checkId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/deployments/${deploymentId}/checks/${checkId}/rerequest`,
+    queryParams,
+    ...requestConfig
+  });
+  return data;
+}
+async function purgeAllDataCache({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "DELETE", url: `/data-cache/purge-all`, queryParams, ...requestConfig });
+  return data;
+}
+async function updateDataCacheBillingSettings({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "PATCH",
+    url: `/data-cache/billing-settings`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function updateProjectDataCache({
+  pathParams: { projectId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/data-cache/projects/${projectId}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getDeploymentEvents({
+  pathParams: { idOrUrl },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrUrl) {
+    throw new Error(`Missing required path parameter: idOrUrl`);
+  }
+  const data = await request({ method: "GET", url: `/v3/deployments/${idOrUrl}/events`, queryParams, ...requestConfig });
+  return data;
+}
+async function updateIntegrationDeploymentAction({
+  pathParams: { deploymentId, integrationConfigurationId, resourceId, action },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  if (!action) {
+    throw new Error(`Missing required path parameter: action`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/deployments/${deploymentId}/integrations/${integrationConfigurationId}/resources/${resourceId}/actions/${action}`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getDeployment({
+  pathParams: { idOrUrl },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrUrl) {
+    throw new Error(`Missing required path parameter: idOrUrl`);
+  }
+  const data = await request({ method: "GET", url: `/v13/deployments/${idOrUrl}`, queryParams, ...requestConfig });
+  return data;
+}
+async function createDeployment({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v13/deployments`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function cancelDeployment({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "PATCH", url: `/v12/deployments/${id}/cancel`, queryParams, ...requestConfig });
+  return data;
+}
+async function buyDomain({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v5/domains/buy`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function checkDomainPrice({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v4/domains/price`, queryParams, ...requestConfig });
+  return data;
+}
+async function checkDomainStatus({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v4/domains/status`, queryParams, ...requestConfig });
+  return data;
+}
+async function getRecords({
+  pathParams: { domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({ method: "GET", url: `/v4/domains/${domain}/records`, queryParams, ...requestConfig });
+  return data;
+}
+async function createRecord({
+  pathParams: { domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v2/domains/${domain}/records`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function updateRecord({
+  pathParams: { recordId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!recordId) {
+    throw new Error(`Missing required path parameter: recordId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/domains/records/${recordId}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function removeRecord({
+  pathParams: { domain, recordId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  if (!recordId) {
+    throw new Error(`Missing required path parameter: recordId`);
+  }
+  const data = await request({ method: "DELETE", url: `/v2/domains/${domain}/records/${recordId}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getDomainTransfer({
+  pathParams: { domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({ method: "GET", url: `/v1/domains/${domain}/registry`, queryParams, ...requestConfig });
+  return data;
+}
+async function getDomainConfig({
+  pathParams: { domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({ method: "GET", url: `/v6/domains/${domain}/config`, queryParams, ...requestConfig });
+  return data;
+}
+async function getDomain({
+  pathParams: { domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({ method: "GET", url: `/v5/domains/${domain}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getDomains({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v5/domains`, queryParams, ...requestConfig });
+  return data;
+}
+async function createOrTransferDomain({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v7/domains`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function patchDomain({
+  pathParams: { domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v3/domains/${domain}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteDomain({
+  pathParams: { domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({ method: "DELETE", url: `/v6/domains/${domain}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getEdgeConfigs({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v1/edge-config`, queryParams, ...requestConfig });
+  return data;
+}
+async function createEdgeConfig({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v1/edge-config`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getEdgeConfig({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/edge-config/${edgeConfigId}`, queryParams, ...requestConfig });
+  return data;
+}
+async function updateEdgeConfig({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({
+    method: "PUT",
+    url: `/v1/edge-config/${edgeConfigId}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteEdgeConfig({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/edge-config/${edgeConfigId}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getEdgeConfigItems({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/edge-config/${edgeConfigId}/items`, queryParams, ...requestConfig });
+  return data;
+}
+async function patchEdgeConfigItems({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/edge-config/${edgeConfigId}/items`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getEdgeConfigSchema({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/edge-config/${edgeConfigId}/schema`, queryParams, ...requestConfig });
+  return data;
+}
+async function patchEdgeConfigSchema({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/edge-config/${edgeConfigId}/schema`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteEdgeConfigSchema({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/edge-config/${edgeConfigId}/schema`, queryParams, ...requestConfig });
+  return data;
+}
+async function getEdgeConfigItem({
+  pathParams: { edgeConfigId, edgeConfigItemKey },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  if (!edgeConfigItemKey) {
+    throw new Error(`Missing required path parameter: edgeConfigItemKey`);
+  }
+  const data = await request({ method: "GET", url: `/v1/edge-config/${edgeConfigId}/item/${edgeConfigItemKey}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getEdgeConfigTokens({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/edge-config/${edgeConfigId}/tokens`, queryParams, ...requestConfig });
+  return data;
+}
+async function deleteEdgeConfigTokens({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({
+    method: "DELETE",
+    url: `/v1/edge-config/${edgeConfigId}/tokens`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getEdgeConfigToken({
+  pathParams: { edgeConfigId, token },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  if (!token) {
+    throw new Error(`Missing required path parameter: token`);
+  }
+  const data = await request({ method: "GET", url: `/v1/edge-config/${edgeConfigId}/token/${token}`, queryParams, ...requestConfig });
+  return data;
+}
+async function createEdgeConfigToken({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/edge-config/${edgeConfigId}/token`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getEdgeConfigBackup({
+  pathParams: { edgeConfigId, edgeConfigBackupVersionId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  if (!edgeConfigBackupVersionId) {
+    throw new Error(`Missing required path parameter: edgeConfigBackupVersionId`);
+  }
+  const data = await request({
+    method: "GET",
+    url: `/v1/edge-config/${edgeConfigId}/backups/${edgeConfigBackupVersionId}`,
+    queryParams,
+    ...requestConfig
+  });
+  return data;
+}
+async function getEdgeConfigBackups({
+  pathParams: { edgeConfigId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!edgeConfigId) {
+    throw new Error(`Missing required path parameter: edgeConfigId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/edge-config/${edgeConfigId}/backups`, queryParams, ...requestConfig });
+  return data;
+}
+async function listUserEvents({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v3/events`, queryParams, ...requestConfig });
+  return data;
+}
+async function getAccountInfo({
+  pathParams: { integrationConfigurationId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/installations/${integrationConfigurationId}/account`, ...requestConfig });
+  return data;
+}
+async function getMember({
+  pathParams: { integrationConfigurationId, memberId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!memberId) {
+    throw new Error(`Missing required path parameter: memberId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/installations/${integrationConfigurationId}/member/${memberId}`, ...requestConfig });
+  return data;
+}
+async function createEvent({
+  pathParams: { integrationConfigurationId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/installations/${integrationConfigurationId}/events`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getIntegrationResources({
+  pathParams: { integrationConfigurationId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/installations/${integrationConfigurationId}/resources`, ...requestConfig });
+  return data;
+}
+async function getIntegrationResource({
+  pathParams: { integrationConfigurationId, resourceId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  const data = await request({
+    method: "GET",
+    url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}`,
+    ...requestConfig
+  });
+  return data;
+}
+async function deleteIntegrationResource({
+  pathParams: { integrationConfigurationId, resourceId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  const data = await request({
+    method: "DELETE",
+    url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}`,
+    ...requestConfig
+  });
+  return data;
+}
+async function importResource({
+  pathParams: { integrationConfigurationId, resourceId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  const data = await request({
+    method: "PUT",
+    url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function submitBillingData({
+  pathParams: { integrationConfigurationId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/installations/${integrationConfigurationId}/billing`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function submitInvoice({
+  pathParams: { integrationConfigurationId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/installations/${integrationConfigurationId}/billing/invoices`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getInvoice({
+  pathParams: { integrationConfigurationId, invoiceId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!invoiceId) {
+    throw new Error(`Missing required path parameter: invoiceId`);
+  }
+  const data = await request({
+    method: "GET",
+    url: `/v1/installations/${integrationConfigurationId}/billing/invoices/${invoiceId}`,
+    ...requestConfig
+  });
+  return data;
+}
+async function updateInvoice({
+  pathParams: { integrationConfigurationId, invoiceId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!invoiceId) {
+    throw new Error(`Missing required path parameter: invoiceId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/installations/${integrationConfigurationId}/billing/invoices/${invoiceId}/actions`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function submitPrepaymentBalances({
+  pathParams: { integrationConfigurationId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/installations/${integrationConfigurationId}/billing/balance`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function updateResourceSecrets({
+  pathParams: { integrationConfigurationId, integrationProductIdOrSlug, resourceId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!integrationProductIdOrSlug) {
+    throw new Error(`Missing required path parameter: integrationProductIdOrSlug`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  const data = await request({
+    method: "PUT",
+    url: `/v1/installations/${integrationConfigurationId}/products/${integrationProductIdOrSlug}/resources/${resourceId}/secrets`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function updateResourceSecretsById({
+  pathParams: { integrationConfigurationId, resourceId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  const data = await request({
+    method: "PUT",
+    url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/secrets`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getConfigurations({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v1/integrations/configurations`, queryParams, ...requestConfig });
+  return data;
+}
+async function getConfiguration({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "GET", url: `/v1/integrations/configuration/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function deleteConfiguration({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/integrations/configuration/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function exchangeSsoToken({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v1/integrations/sso/token`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getIntegrationLogDrains({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v2/integrations/log-drains`, queryParams, ...requestConfig });
+  return data;
+}
+async function createLogDrain({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v2/integrations/log-drains`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteIntegrationLogDrain({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/integrations/log-drains/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getRuntimeLogs({
+  pathParams: { projectId, deploymentId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  const data = await request({
+    method: "GET",
+    url: `/v1/projects/${projectId}/deployments/${deploymentId}/runtime-logs`,
+    queryParams,
+    ...requestConfig
+  });
+  return data;
+}
+async function createExperimentationItem({
+  pathParams: { integrationConfigurationId, resourceId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/experimentation/items`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function updateExperimentationItem({
+  pathParams: { integrationConfigurationId, resourceId, itemId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  if (!itemId) {
+    throw new Error(`Missing required path parameter: itemId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/experimentation/items/${itemId}`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteExperimentationItem({
+  pathParams: { integrationConfigurationId, resourceId, itemId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  if (!itemId) {
+    throw new Error(`Missing required path parameter: itemId`);
+  }
+  const data = await request({
+    method: "DELETE",
+    url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/experimentation/items/${itemId}`,
+    ...requestConfig
+  });
+  return data;
+}
+async function updateExperimentationEdgeConfig({
+  pathParams: { integrationConfigurationId, resourceId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!integrationConfigurationId) {
+    throw new Error(`Missing required path parameter: integrationConfigurationId`);
+  }
+  if (!resourceId) {
+    throw new Error(`Missing required path parameter: resourceId`);
+  }
+  const data = await request({
+    method: "PUT",
+    url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/experimentation/edge-config`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getProjectMembers({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v1/projects/${idOrName}/members`, queryParams, ...requestConfig });
+  return data;
+}
+async function addProjectMember({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/projects/${idOrName}/members`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function removeProjectMember({
+  pathParams: { idOrName, uid },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!uid) {
+    throw new Error(`Missing required path parameter: uid`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/projects/${idOrName}/members/${uid}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getProjects({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v10/projects`, queryParams, ...requestConfig });
+  return data;
+}
+async function createProject({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v11/projects`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getProject({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v9/projects/${idOrName}`, queryParams, ...requestConfig });
+  return data;
+}
+async function updateProject({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v9/projects/${idOrName}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteProject({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "DELETE", url: `/v9/projects/${idOrName}`, queryParams, ...requestConfig });
+  return data;
+}
+async function createCustomEnvironment({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v9/projects/${idOrName}/custom-environments`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function listCustomEnvironments({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v9/projects/${idOrName}/custom-environments`, queryParams, ...requestConfig });
+  return data;
+}
+async function getCustomEnvironment({
+  pathParams: { idOrName, environmentSlugOrId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!environmentSlugOrId) {
+    throw new Error(`Missing required path parameter: environmentSlugOrId`);
+  }
+  const data = await request({
+    method: "GET",
+    url: `/v9/projects/${idOrName}/custom-environments/${environmentSlugOrId}`,
+    queryParams,
+    ...requestConfig
+  });
+  return data;
+}
+async function updateCustomEnvironment({
+  pathParams: { idOrName, environmentSlugOrId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!environmentSlugOrId) {
+    throw new Error(`Missing required path parameter: environmentSlugOrId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v9/projects/${idOrName}/custom-environments/${environmentSlugOrId}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function removeCustomEnvironment({
+  pathParams: { idOrName, environmentSlugOrId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!environmentSlugOrId) {
+    throw new Error(`Missing required path parameter: environmentSlugOrId`);
+  }
+  const data = await request({
+    method: "DELETE",
+    url: `/v9/projects/${idOrName}/custom-environments/${environmentSlugOrId}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getProjectDomains({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v9/projects/${idOrName}/domains`, queryParams, ...requestConfig });
+  return data;
+}
+async function getProjectDomain({
+  pathParams: { idOrName, domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({ method: "GET", url: `/v9/projects/${idOrName}/domains/${domain}`, queryParams, ...requestConfig });
+  return data;
+}
+async function updateProjectDomain({
+  pathParams: { idOrName, domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v9/projects/${idOrName}/domains/${domain}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function removeProjectDomain({
+  pathParams: { idOrName, domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({
+    method: "DELETE",
+    url: `/v9/projects/${idOrName}/domains/${domain}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function addProjectDomain({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v10/projects/${idOrName}/domains`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function moveProjectDomain({
+  pathParams: { idOrName, domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/projects/${idOrName}/domains/${domain}/move`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function verifyProjectDomain({
+  pathParams: { idOrName, domain },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!domain) {
+    throw new Error(`Missing required path parameter: domain`);
+  }
+  const data = await request({ method: "POST", url: `/v9/projects/${idOrName}/domains/${domain}/verify`, queryParams, ...requestConfig });
+  return data;
+}
+async function filterProjectEnvs({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v10/projects/${idOrName}/env`, queryParams, ...requestConfig });
+  return data;
+}
+async function createProjectEnv({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v10/projects/${idOrName}/env`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getProjectEnv({
+  pathParams: { idOrName, id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "GET", url: `/v1/projects/${idOrName}/env/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function removeProjectEnv({
+  pathParams: { idOrName, id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "DELETE", url: `/v9/projects/${idOrName}/env/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function editProjectEnv({
+  pathParams: { idOrName, id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v9/projects/${idOrName}/env/${id}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getRollingReleaseBillingStatus({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v1/projects/${idOrName}/rolling-release/billing`, queryParams, ...requestConfig });
+  return data;
+}
+async function getRollingReleaseConfig({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v1/projects/${idOrName}/rolling-release/config`, queryParams, ...requestConfig });
+  return data;
+}
+async function deleteRollingReleaseConfig({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/projects/${idOrName}/rolling-release/config`, queryParams, ...requestConfig });
+  return data;
+}
+async function updateRollingReleaseConfig({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "PATCH", url: `/v1/projects/${idOrName}/rolling-release/config`, queryParams, ...requestConfig });
+  return data;
+}
+async function getRollingRelease({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v1/projects/${idOrName}/rolling-release`, queryParams, ...requestConfig });
+  return data;
+}
+async function approveRollingReleaseStage({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/projects/${idOrName}/rolling-release/approve-stage`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function completeRollingRelease({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/projects/${idOrName}/rolling-release/complete`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function createProjectTransferRequest({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/projects/${idOrName}/transfer-request`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function acceptProjectTransferRequest({
+  pathParams: { code },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!code) {
+    throw new Error(`Missing required path parameter: code`);
+  }
+  const data = await request({
+    method: "PUT",
+    url: `/projects/transfer-request/${code}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function updateProjectProtectionBypass({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/projects/${idOrName}/protection-bypass`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function requestPromote({
+  pathParams: { projectId, deploymentId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  if (!deploymentId) {
+    throw new Error(`Missing required path parameter: deploymentId`);
+  }
+  const data = await request({ method: "POST", url: `/v10/projects/${projectId}/promote/${deploymentId}`, queryParams, ...requestConfig });
+  return data;
+}
+async function listPromoteAliases({
+  pathParams: { projectId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/projects/${projectId}/promote/aliases`, queryParams, ...requestConfig });
+  return data;
+}
+async function pauseProject({
+  pathParams: { projectId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  const data = await request({ method: "POST", url: `/v1/projects/${projectId}/pause`, queryParams, ...requestConfig });
+  return data;
+}
+async function unpauseProject({
+  pathParams: { projectId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!projectId) {
+    throw new Error(`Missing required path parameter: projectId`);
+  }
+  const data = await request({ method: "POST", url: `/v1/projects/${projectId}/unpause`, queryParams, ...requestConfig });
+  return data;
+}
+async function updateAttackChallengeMode({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v1/security/attack-mode`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function putFirewallConfig({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "PUT",
+    url: `/v1/security/firewall/config`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function updateFirewallConfig({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/security/firewall/config`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getFirewallConfig({
+  pathParams: { configVersion },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!configVersion) {
+    throw new Error(`Missing required path parameter: configVersion`);
+  }
+  const data = await request({ method: "GET", url: `/v1/security/firewall/config/${configVersion}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getActiveAttackStatus({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v1/security/firewall/attack-status`, queryParams, ...requestConfig });
+  return data;
+}
+async function getBypassIp({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v1/security/firewall/bypass`, queryParams, ...requestConfig });
+  return data;
+}
+async function addBypassIp({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v1/security/firewall/bypass`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function removeBypassIp({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "DELETE",
+    url: `/v1/security/firewall/bypass`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getTeamMembers({
+  pathParams: { teamId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({ method: "GET", url: `/v3/teams/${teamId}/members`, queryParams, ...requestConfig });
+  return data;
+}
+async function inviteUserToTeam({
+  pathParams: { teamId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/teams/${teamId}/members`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function requestAccessToTeam({
+  pathParams: { teamId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/teams/${teamId}/request`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getTeamAccessRequest({
+  pathParams: { userId, teamId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!userId) {
+    throw new Error(`Missing required path parameter: userId`);
+  }
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({ method: "GET", url: `/v1/teams/${teamId}/request/${userId}`, ...requestConfig });
+  return data;
+}
+async function joinTeam({
+  pathParams: { teamId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v1/teams/${teamId}/members/teams/join`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function updateTeamMember({
+  pathParams: { uid, teamId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!uid) {
+    throw new Error(`Missing required path parameter: uid`);
+  }
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v1/teams/${teamId}/members/${uid}`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function removeTeamMember({
+  pathParams: { uid, teamId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!uid) {
+    throw new Error(`Missing required path parameter: uid`);
+  }
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/teams/${teamId}/members/${uid}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getTeam({
+  pathParams: { teamId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({ method: "GET", url: `/v2/teams/${teamId}`, queryParams, ...requestConfig });
+  return data;
+}
+async function patchTeam({
+  pathParams: { teamId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v2/teams/${teamId}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getTeams({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v2/teams`, queryParams, ...requestConfig });
+  return data;
+}
+async function createTeam({ config = {} }) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v1/teams`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteTeam({
+  pathParams: { teamId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({
+    method: "DELETE",
+    url: `/v1/teams/${teamId}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function deleteTeamInviteCode({
+  pathParams: { inviteId, teamId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!inviteId) {
+    throw new Error(`Missing required path parameter: inviteId`);
+  }
+  if (!teamId) {
+    throw new Error(`Missing required path parameter: teamId`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/teams/${teamId}/invites/${inviteId}`, ...requestConfig });
+  return data;
+}
+async function uploadFile({
+  queryParams,
+  headers,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v2/files`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationOctetStream", ...headers, ...requestConfig.headers }
+  });
+  return data;
+}
+async function listAuthTokens({
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v5/user/tokens`, ...requestConfig });
+  return data;
+}
+async function createAuthToken({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v3/user/tokens`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getAuthToken({
+  pathParams: { tokenId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!tokenId) {
+    throw new Error(`Missing required path parameter: tokenId`);
+  }
+  const data = await request({ method: "GET", url: `/v5/user/tokens/${tokenId}`, ...requestConfig });
+  return data;
+}
+async function deleteAuthToken({
+  pathParams: { tokenId },
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!tokenId) {
+    throw new Error(`Missing required path parameter: tokenId`);
+  }
+  const data = await request({ method: "DELETE", url: `/v3/user/tokens/${tokenId}`, ...requestConfig });
+  return data;
+}
+async function getAuthUser({ config = {} }) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v2/user`, ...requestConfig });
+  return data;
+}
+async function requestDelete({ config = {} }) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "DELETE",
+    url: `/v1/user`,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function createWebhook({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v1/webhooks`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getWebhooks({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v1/webhooks`, queryParams, ...requestConfig });
+  return data;
+}
+async function getWebhook({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "GET", url: `/v1/webhooks/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function deleteWebhook({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "DELETE", url: `/v1/webhooks/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function listDeploymentAliases({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "GET", url: `/v2/deployments/${id}/aliases`, queryParams, ...requestConfig });
+  return data;
+}
+async function assignAlias({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v2/deployments/${id}/aliases`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function listAliases({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v4/aliases`, queryParams, ...requestConfig });
+  return data;
+}
+async function getAlias({
+  pathParams: { idOrAlias },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrAlias) {
+    throw new Error(`Missing required path parameter: idOrAlias`);
+  }
+  const data = await request({ method: "GET", url: `/v4/aliases/${idOrAlias}`, queryParams, ...requestConfig });
+  return data;
+}
+async function deleteAlias({
+  pathParams: { aliasId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!aliasId) {
+    throw new Error(`Missing required path parameter: aliasId`);
+  }
+  const data = await request({ method: "DELETE", url: `/v2/aliases/${aliasId}`, queryParams, ...requestConfig });
+  return data;
+}
+async function patchUrlProtectionBypass({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/aliases/${id}/protection-bypass`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function listCerts({ config = {} }) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/certs`, ...requestConfig });
+  return data;
+}
+async function getCertById({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "GET", url: `/v8/certs/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function removeCert({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "DELETE", url: `/v8/certs/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function issueCert({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "POST",
+    url: `/v8/certs`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function uploadCert({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({
+    method: "PUT",
+    url: `/v8/certs`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function listDeploymentFiles({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "GET", url: `/v6/deployments/${id}/files`, queryParams, ...requestConfig });
+  return data;
+}
+async function getDeploymentFileContents({
+  pathParams: { id, fileId },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  if (!fileId) {
+    throw new Error(`Missing required path parameter: fileId`);
+  }
+  const data = await request({ method: "GET", url: `/v8/deployments/${id}/files/${fileId}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getDeployments({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v6/deployments`, queryParams, ...requestConfig });
+  return data;
+}
+async function deleteDeployment({
+  pathParams: { id },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!id) {
+    throw new Error(`Missing required path parameter: id`);
+  }
+  const data = await request({ method: "DELETE", url: `/v13/deployments/${id}`, queryParams, ...requestConfig });
+  return data;
+}
+async function getSecrets({
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  const data = await request({ method: "GET", url: `/v3/secrets`, queryParams, ...requestConfig });
+  return data;
+}
+async function createSecret({
+  pathParams: { name },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!name) {
+    throw new Error(`Missing required path parameter: name`);
+  }
+  const data = await request({
+    method: "POST",
+    url: `/v2/secrets/${name}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function renameSecret({
+  pathParams: { name },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!name) {
+    throw new Error(`Missing required path parameter: name`);
+  }
+  const data = await request({
+    method: "PATCH",
+    url: `/v2/secrets/${name}`,
+    queryParams,
+    ...requestConfig,
+    headers: { "Content-Type": "applicationJson", ...requestConfig.headers }
+  });
+  return data;
+}
+async function getSecret({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "GET", url: `/v3/secrets/${idOrName}`, queryParams, ...requestConfig });
+  return data;
+}
+async function deleteSecret({
+  pathParams: { idOrName },
+  queryParams,
+  config = {}
+}) {
+  const { client: request = schemas.client, ...requestConfig } = config;
+  if (!idOrName) {
+    throw new Error(`Missing required path parameter: idOrName`);
+  }
+  const data = await request({ method: "DELETE", url: `/v2/secrets/${idOrName}`, queryParams, ...requestConfig });
+  return data;
+}
+const operationsByPath$1 = {
+  "GET /v1/access-groups/{idOrName}": readAccessGroup,
+  "POST /v1/access-groups/{idOrName}": updateAccessGroup,
+  "DELETE /v1/access-groups/{idOrName}": deleteAccessGroup,
+  "GET /v1/access-groups/{idOrName}/members": listAccessGroupMembers,
+  "GET /v1/access-groups": listAccessGroups,
+  "POST /v1/access-groups": createAccessGroup,
+  "GET /v1/access-groups/{idOrName}/projects": listAccessGroupProjects,
+  "POST /v1/access-groups/{accessGroupIdOrName}/projects": createAccessGroupProject,
+  "GET /v1/access-groups/{accessGroupIdOrName}/projects/{projectId}": readAccessGroupProject,
+  "PATCH /v1/access-groups/{accessGroupIdOrName}/projects/{projectId}": updateAccessGroupProject,
+  "DELETE /v1/access-groups/{accessGroupIdOrName}/projects/{projectId}": deleteAccessGroupProject,
+  "POST /v8/artifacts/events": recordEvents,
+  "GET /v8/artifacts/status": status,
+  "PUT /v8/artifacts/{hash}": uploadArtifact,
+  "GET /v8/artifacts/{hash}": downloadArtifact,
+  "POST /v8/artifacts": artifactQuery,
+  "POST /v1/deployments/{deploymentId}/checks": createCheck,
+  "GET /v1/deployments/{deploymentId}/checks": getAllChecks,
+  "GET /v1/deployments/{deploymentId}/checks/{checkId}": getCheck,
+  "PATCH /v1/deployments/{deploymentId}/checks/{checkId}": updateCheck,
+  "POST /v1/deployments/{deploymentId}/checks/{checkId}/rerequest": rerequestCheck,
+  "DELETE /data-cache/purge-all": purgeAllDataCache,
+  "PATCH /data-cache/billing-settings": updateDataCacheBillingSettings,
+  "PATCH /v1/data-cache/projects/{projectId}": updateProjectDataCache,
+  "GET /v3/deployments/{idOrUrl}/events": getDeploymentEvents,
+  "PATCH /v1/deployments/{deploymentId}/integrations/{integrationConfigurationId}/resources/{resourceId}/actions/{action}": updateIntegrationDeploymentAction,
+  "GET /v13/deployments/{idOrUrl}": getDeployment,
+  "POST /v13/deployments": createDeployment,
+  "PATCH /v12/deployments/{id}/cancel": cancelDeployment,
+  "POST /v5/domains/buy": buyDomain,
+  "GET /v4/domains/price": checkDomainPrice,
+  "GET /v4/domains/status": checkDomainStatus,
+  "GET /v4/domains/{domain}/records": getRecords,
+  "POST /v2/domains/{domain}/records": createRecord,
+  "PATCH /v1/domains/records/{recordId}": updateRecord,
+  "DELETE /v2/domains/{domain}/records/{recordId}": removeRecord,
+  "GET /v1/domains/{domain}/registry": getDomainTransfer,
+  "GET /v6/domains/{domain}/config": getDomainConfig,
+  "GET /v5/domains/{domain}": getDomain,
+  "GET /v5/domains": getDomains,
+  "POST /v7/domains": createOrTransferDomain,
+  "PATCH /v3/domains/{domain}": patchDomain,
+  "DELETE /v6/domains/{domain}": deleteDomain,
+  "GET /v1/edge-config": getEdgeConfigs,
+  "POST /v1/edge-config": createEdgeConfig,
+  "GET /v1/edge-config/{edgeConfigId}": getEdgeConfig,
+  "PUT /v1/edge-config/{edgeConfigId}": updateEdgeConfig,
+  "DELETE /v1/edge-config/{edgeConfigId}": deleteEdgeConfig,
+  "GET /v1/edge-config/{edgeConfigId}/items": getEdgeConfigItems,
+  "PATCH /v1/edge-config/{edgeConfigId}/items": patchEdgeConfigItems,
+  "GET /v1/edge-config/{edgeConfigId}/schema": getEdgeConfigSchema,
+  "POST /v1/edge-config/{edgeConfigId}/schema": patchEdgeConfigSchema,
+  "DELETE /v1/edge-config/{edgeConfigId}/schema": deleteEdgeConfigSchema,
+  "GET /v1/edge-config/{edgeConfigId}/item/{edgeConfigItemKey}": getEdgeConfigItem,
+  "GET /v1/edge-config/{edgeConfigId}/tokens": getEdgeConfigTokens,
+  "DELETE /v1/edge-config/{edgeConfigId}/tokens": deleteEdgeConfigTokens,
+  "GET /v1/edge-config/{edgeConfigId}/token/{token}": getEdgeConfigToken,
+  "POST /v1/edge-config/{edgeConfigId}/token": createEdgeConfigToken,
+  "GET /v1/edge-config/{edgeConfigId}/backups/{edgeConfigBackupVersionId}": getEdgeConfigBackup,
+  "GET /v1/edge-config/{edgeConfigId}/backups": getEdgeConfigBackups,
+  "GET /v3/events": listUserEvents,
+  "GET /v1/installations/{integrationConfigurationId}/account": getAccountInfo,
+  "GET /v1/installations/{integrationConfigurationId}/member/{memberId}": getMember,
+  "POST /v1/installations/{integrationConfigurationId}/events": createEvent,
+  "GET /v1/installations/{integrationConfigurationId}/resources": getIntegrationResources,
+  "GET /v1/installations/{integrationConfigurationId}/resources/{resourceId}": getIntegrationResource,
+  "DELETE /v1/installations/{integrationConfigurationId}/resources/{resourceId}": deleteIntegrationResource,
+  "PUT /v1/installations/{integrationConfigurationId}/resources/{resourceId}": importResource,
+  "POST /v1/installations/{integrationConfigurationId}/billing": submitBillingData,
+  "POST /v1/installations/{integrationConfigurationId}/billing/invoices": submitInvoice,
+  "GET /v1/installations/{integrationConfigurationId}/billing/invoices/{invoiceId}": getInvoice,
+  "POST /v1/installations/{integrationConfigurationId}/billing/invoices/{invoiceId}/actions": updateInvoice,
+  "POST /v1/installations/{integrationConfigurationId}/billing/balance": submitPrepaymentBalances,
+  "PUT /v1/installations/{integrationConfigurationId}/products/{integrationProductIdOrSlug}/resources/{resourceId}/secrets": updateResourceSecrets,
+  "PUT /v1/installations/{integrationConfigurationId}/resources/{resourceId}/secrets": updateResourceSecretsById,
+  "GET /v1/integrations/configurations": getConfigurations,
+  "GET /v1/integrations/configuration/{id}": getConfiguration,
+  "DELETE /v1/integrations/configuration/{id}": deleteConfiguration,
+  "POST /v1/integrations/sso/token": exchangeSsoToken,
+  "GET /v2/integrations/log-drains": getIntegrationLogDrains,
+  "POST /v2/integrations/log-drains": createLogDrain,
+  "DELETE /v1/integrations/log-drains/{id}": deleteIntegrationLogDrain,
+  "GET /v1/projects/{projectId}/deployments/{deploymentId}/runtime-logs": getRuntimeLogs,
+  "POST /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/items": createExperimentationItem,
+  "PATCH /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/items/{itemId}": updateExperimentationItem,
+  "DELETE /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/items/{itemId}": deleteExperimentationItem,
+  "PUT /v1/installations/{integrationConfigurationId}/resources/{resourceId}/experimentation/edge-config": updateExperimentationEdgeConfig,
+  "GET /v1/projects/{idOrName}/members": getProjectMembers,
+  "POST /v1/projects/{idOrName}/members": addProjectMember,
+  "DELETE /v1/projects/{idOrName}/members/{uid}": removeProjectMember,
+  "GET /v10/projects": getProjects,
+  "POST /v11/projects": createProject,
+  "GET /v9/projects/{idOrName}": getProject,
+  "PATCH /v9/projects/{idOrName}": updateProject,
+  "DELETE /v9/projects/{idOrName}": deleteProject,
+  "POST /v9/projects/{idOrName}/custom-environments": createCustomEnvironment,
+  "GET /v9/projects/{idOrName}/custom-environments": listCustomEnvironments,
+  "GET /v9/projects/{idOrName}/custom-environments/{environmentSlugOrId}": getCustomEnvironment,
+  "PATCH /v9/projects/{idOrName}/custom-environments/{environmentSlugOrId}": updateCustomEnvironment,
+  "DELETE /v9/projects/{idOrName}/custom-environments/{environmentSlugOrId}": removeCustomEnvironment,
+  "GET /v9/projects/{idOrName}/domains": getProjectDomains,
+  "GET /v9/projects/{idOrName}/domains/{domain}": getProjectDomain,
+  "PATCH /v9/projects/{idOrName}/domains/{domain}": updateProjectDomain,
+  "DELETE /v9/projects/{idOrName}/domains/{domain}": removeProjectDomain,
+  "POST /v10/projects/{idOrName}/domains": addProjectDomain,
+  "POST /v1/projects/{idOrName}/domains/{domain}/move": moveProjectDomain,
+  "POST /v9/projects/{idOrName}/domains/{domain}/verify": verifyProjectDomain,
+  "GET /v10/projects/{idOrName}/env": filterProjectEnvs,
+  "POST /v10/projects/{idOrName}/env": createProjectEnv,
+  "GET /v1/projects/{idOrName}/env/{id}": getProjectEnv,
+  "DELETE /v9/projects/{idOrName}/env/{id}": removeProjectEnv,
+  "PATCH /v9/projects/{idOrName}/env/{id}": editProjectEnv,
+  "GET /v1/projects/{idOrName}/rolling-release/billing": getRollingReleaseBillingStatus,
+  "GET /v1/projects/{idOrName}/rolling-release/config": getRollingReleaseConfig,
+  "DELETE /v1/projects/{idOrName}/rolling-release/config": deleteRollingReleaseConfig,
+  "PATCH /v1/projects/{idOrName}/rolling-release/config": updateRollingReleaseConfig,
+  "GET /v1/projects/{idOrName}/rolling-release": getRollingRelease,
+  "POST /v1/projects/{idOrName}/rolling-release/approve-stage": approveRollingReleaseStage,
+  "POST /v1/projects/{idOrName}/rolling-release/complete": completeRollingRelease,
+  "POST /projects/{idOrName}/transfer-request": createProjectTransferRequest,
+  "PUT /projects/transfer-request/{code}": acceptProjectTransferRequest,
+  "PATCH /v1/projects/{idOrName}/protection-bypass": updateProjectProtectionBypass,
+  "POST /v10/projects/{projectId}/promote/{deploymentId}": requestPromote,
+  "GET /v1/projects/{projectId}/promote/aliases": listPromoteAliases,
+  "POST /v1/projects/{projectId}/pause": pauseProject,
+  "POST /v1/projects/{projectId}/unpause": unpauseProject,
+  "POST /v1/security/attack-mode": updateAttackChallengeMode,
+  "PUT /v1/security/firewall/config": putFirewallConfig,
+  "PATCH /v1/security/firewall/config": updateFirewallConfig,
+  "GET /v1/security/firewall/config/{configVersion}": getFirewallConfig,
+  "GET /v1/security/firewall/attack-status": getActiveAttackStatus,
+  "GET /v1/security/firewall/bypass": getBypassIp,
+  "POST /v1/security/firewall/bypass": addBypassIp,
+  "DELETE /v1/security/firewall/bypass": removeBypassIp,
+  "GET /v3/teams/{teamId}/members": getTeamMembers,
+  "POST /v1/teams/{teamId}/members": inviteUserToTeam,
+  "POST /v1/teams/{teamId}/request": requestAccessToTeam,
+  "GET /v1/teams/{teamId}/request/{userId}": getTeamAccessRequest,
+  "POST /v1/teams/{teamId}/members/teams/join": joinTeam,
+  "PATCH /v1/teams/{teamId}/members/{uid}": updateTeamMember,
+  "DELETE /v1/teams/{teamId}/members/{uid}": removeTeamMember,
+  "GET /v2/teams/{teamId}": getTeam,
+  "PATCH /v2/teams/{teamId}": patchTeam,
+  "GET /v2/teams": getTeams,
+  "POST /v1/teams": createTeam,
+  "DELETE /v1/teams/{teamId}": deleteTeam,
+  "DELETE /v1/teams/{teamId}/invites/{inviteId}": deleteTeamInviteCode,
+  "POST /v2/files": uploadFile,
+  "GET /v5/user/tokens": listAuthTokens,
+  "POST /v3/user/tokens": createAuthToken,
+  "GET /v5/user/tokens/{tokenId}": getAuthToken,
+  "DELETE /v3/user/tokens/{tokenId}": deleteAuthToken,
+  "GET /v2/user": getAuthUser,
+  "DELETE /v1/user": requestDelete,
+  "POST /v1/webhooks": createWebhook,
+  "GET /v1/webhooks": getWebhooks,
+  "GET /v1/webhooks/{id}": getWebhook,
+  "DELETE /v1/webhooks/{id}": deleteWebhook,
+  "GET /v2/deployments/{id}/aliases": listDeploymentAliases,
+  "POST /v2/deployments/{id}/aliases": assignAlias,
+  "GET /v4/aliases": listAliases,
+  "GET /v4/aliases/{idOrAlias}": getAlias,
+  "DELETE /v2/aliases/{aliasId}": deleteAlias,
+  "PATCH /aliases/{id}/protection-bypass": patchUrlProtectionBypass,
+  "GET /certs": listCerts,
+  "GET /v8/certs/{id}": getCertById,
+  "DELETE /v8/certs/{id}": removeCert,
+  "POST /v8/certs": issueCert,
+  "PUT /v8/certs": uploadCert,
+  "GET /v6/deployments/{id}/files": listDeploymentFiles,
+  "GET /v8/deployments/{id}/files/{fileId}": getDeploymentFileContents,
+  "GET /v6/deployments": getDeployments,
+  "DELETE /v13/deployments/{id}": deleteDeployment,
+  "GET /v3/secrets": getSecrets,
+  "POST /v2/secrets/{name}": createSecret,
+  "PATCH /v2/secrets/{name}": renameSecret,
+  "GET /v3/secrets/{idOrName}": getSecret,
+  "DELETE /v2/secrets/{idOrName}": deleteSecret
+};
+const operationsByTag$1 = {
+  accessGroups: {
+    readAccessGroup,
+    updateAccessGroup,
+    deleteAccessGroup,
+    listAccessGroupMembers,
+    listAccessGroups,
+    createAccessGroup,
+    listAccessGroupProjects,
+    createAccessGroupProject,
+    readAccessGroupProject,
+    updateAccessGroupProject,
+    deleteAccessGroupProject
+  },
+  artifacts: {
+    recordEvents,
+    status,
+    uploadArtifact,
+    downloadArtifact,
+    artifactQuery
+  },
+  checks: {
+    createCheck,
+    getAllChecks,
+    getCheck,
+    updateCheck,
+    rerequestCheck
+  },
+  projects: {
+    updateProjectDataCache,
+    getProjects,
+    createProject,
+    getProject,
+    updateProject,
+    deleteProject,
+    getProjectDomains,
+    getProjectDomain,
+    updateProjectDomain,
+    removeProjectDomain,
+    addProjectDomain,
+    moveProjectDomain,
+    verifyProjectDomain,
+    filterProjectEnvs,
+    createProjectEnv,
+    getProjectEnv,
+    removeProjectEnv,
+    editProjectEnv,
+    createProjectTransferRequest,
+    acceptProjectTransferRequest,
+    updateProjectProtectionBypass,
+    requestPromote,
+    listPromoteAliases,
+    pauseProject,
+    unpauseProject
+  },
+  deployments: {
+    getDeploymentEvents,
+    updateIntegrationDeploymentAction,
+    getDeployment,
+    createDeployment,
+    cancelDeployment,
+    uploadFile,
+    listDeploymentFiles,
+    getDeploymentFileContents,
+    getDeployments,
+    deleteDeployment
+  },
+  integrations: {
+    updateIntegrationDeploymentAction,
+    getConfigurations,
+    getConfiguration,
+    deleteConfiguration
+  },
+  domains: {
+    buyDomain,
+    checkDomainPrice,
+    checkDomainStatus,
+    getDomainTransfer,
+    getDomainConfig,
+    getDomain,
+    getDomains,
+    createOrTransferDomain,
+    patchDomain,
+    deleteDomain
+  },
+  dns: {
+    getRecords,
+    createRecord,
+    updateRecord,
+    removeRecord
+  },
+  edgeConfig: {
+    getEdgeConfigs,
+    createEdgeConfig,
+    getEdgeConfig,
+    updateEdgeConfig,
+    deleteEdgeConfig,
+    getEdgeConfigItems,
+    patchEdgeConfigItems,
+    getEdgeConfigSchema,
+    patchEdgeConfigSchema,
+    deleteEdgeConfigSchema,
+    getEdgeConfigItem,
+    getEdgeConfigTokens,
+    deleteEdgeConfigTokens,
+    getEdgeConfigToken,
+    createEdgeConfigToken,
+    getEdgeConfigBackup,
+    getEdgeConfigBackups
+  },
+  user: {
+    listUserEvents,
+    getAuthUser,
+    requestDelete
+  },
+  marketplace: {
+    getAccountInfo,
+    getMember,
+    createEvent,
+    getIntegrationResources,
+    getIntegrationResource,
+    deleteIntegrationResource,
+    importResource,
+    submitBillingData,
+    submitInvoice,
+    getInvoice,
+    updateInvoice,
+    submitPrepaymentBalances,
+    updateResourceSecrets,
+    updateResourceSecretsById,
+    exchangeSsoToken,
+    createExperimentationItem,
+    updateExperimentationItem,
+    deleteExperimentationItem,
+    updateExperimentationEdgeConfig
+  },
+  authentication: {
+    exchangeSsoToken,
+    listAuthTokens,
+    createAuthToken,
+    getAuthToken,
+    deleteAuthToken
+  },
+  logdrains: {
+    getIntegrationLogDrains,
+    createLogDrain,
+    deleteIntegrationLogDrain
+  },
+  logs: {
+    getRuntimeLogs
+  },
+  projectmembers: {
+    getProjectMembers,
+    addProjectMember,
+    removeProjectMember
+  },
+  environment: {
+    createCustomEnvironment,
+    listCustomEnvironments,
+    getCustomEnvironment,
+    updateCustomEnvironment,
+    removeCustomEnvironment
+  },
+  rollingRelease: {
+    getRollingReleaseBillingStatus,
+    getRollingReleaseConfig,
+    deleteRollingReleaseConfig,
+    updateRollingReleaseConfig,
+    getRollingRelease,
+    approveRollingReleaseStage,
+    completeRollingRelease
+  },
+  security: {
+    updateAttackChallengeMode,
+    putFirewallConfig,
+    updateFirewallConfig,
+    getFirewallConfig,
+    getActiveAttackStatus,
+    getBypassIp,
+    addBypassIp,
+    removeBypassIp
+  },
+  teams: {
+    getTeamMembers,
+    inviteUserToTeam,
+    requestAccessToTeam,
+    getTeamAccessRequest,
+    joinTeam,
+    updateTeamMember,
+    removeTeamMember,
+    getTeam,
+    patchTeam,
+    getTeams,
+    createTeam,
+    deleteTeam,
+    deleteTeamInviteCode
+  },
+  webhooks: {
+    createWebhook,
+    getWebhooks,
+    getWebhook,
+    deleteWebhook
+  },
+  aliases: {
+    listDeploymentAliases,
+    assignAlias,
+    listAliases,
+    getAlias,
+    deleteAlias,
+    patchUrlProtectionBypass
+  },
+  certs: {
+    getCertById,
+    removeCert,
+    issueCert,
+    uploadCert
+  },
+  secrets: {
+    getSecrets,
+    createSecret,
+    renameSecret,
+    getSecret,
+    deleteSecret
+  }
+};
+const tagDictionary$1 = {
+  accessGroups: {
+    GET: [
+      "readAccessGroup",
+      "listAccessGroupMembers",
+      "listAccessGroups",
+      "listAccessGroupProjects",
+      "readAccessGroupProject"
+    ],
+    POST: ["updateAccessGroup", "createAccessGroup", "createAccessGroupProject"],
+    DELETE: ["deleteAccessGroup", "deleteAccessGroupProject"],
+    PATCH: ["updateAccessGroupProject"]
+  },
+  artifacts: {
+    POST: ["recordEvents", "artifactQuery"],
+    GET: ["status", "downloadArtifact"],
+    PUT: ["uploadArtifact"]
+  },
+  checks: {
+    POST: ["createCheck", "rerequestCheck"],
+    GET: ["getAllChecks", "getCheck"],
+    PATCH: ["updateCheck"]
+  },
+  projects: {
+    PATCH: [
+      "updateProjectDataCache",
+      "updateProject",
+      "updateProjectDomain",
+      "editProjectEnv",
+      "updateProjectProtectionBypass"
+    ],
+    GET: [
+      "getProjects",
+      "getProject",
+      "getProjectDomains",
+      "getProjectDomain",
+      "filterProjectEnvs",
+      "getProjectEnv",
+      "listPromoteAliases"
+    ],
+    POST: [
+      "createProject",
+      "addProjectDomain",
+      "moveProjectDomain",
+      "verifyProjectDomain",
+      "createProjectEnv",
+      "createProjectTransferRequest",
+      "requestPromote",
+      "pauseProject",
+      "unpauseProject"
+    ],
+    DELETE: ["deleteProject", "removeProjectDomain", "removeProjectEnv"],
+    PUT: ["acceptProjectTransferRequest"]
+  },
+  deployments: {
+    GET: ["getDeploymentEvents", "getDeployment", "listDeploymentFiles", "getDeploymentFileContents", "getDeployments"],
+    PATCH: ["updateIntegrationDeploymentAction", "cancelDeployment"],
+    POST: ["createDeployment", "uploadFile"],
+    DELETE: ["deleteDeployment"]
+  },
+  integrations: {
+    PATCH: ["updateIntegrationDeploymentAction"],
+    GET: ["getConfigurations", "getConfiguration"],
+    DELETE: ["deleteConfiguration"]
+  },
+  domains: {
+    POST: ["buyDomain", "createOrTransferDomain"],
+    GET: ["checkDomainPrice", "checkDomainStatus", "getDomainTransfer", "getDomainConfig", "getDomain", "getDomains"],
+    PATCH: ["patchDomain"],
+    DELETE: ["deleteDomain"]
+  },
+  dns: {
+    GET: ["getRecords"],
+    POST: ["createRecord"],
+    PATCH: ["updateRecord"],
+    DELETE: ["removeRecord"]
+  },
+  edgeConfig: {
+    GET: [
+      "getEdgeConfigs",
+      "getEdgeConfig",
+      "getEdgeConfigItems",
+      "getEdgeConfigSchema",
+      "getEdgeConfigItem",
+      "getEdgeConfigTokens",
+      "getEdgeConfigToken",
+      "getEdgeConfigBackup",
+      "getEdgeConfigBackups"
+    ],
+    POST: ["createEdgeConfig", "patchEdgeConfigSchema", "createEdgeConfigToken"],
+    PUT: ["updateEdgeConfig"],
+    DELETE: ["deleteEdgeConfig", "deleteEdgeConfigSchema", "deleteEdgeConfigTokens"],
+    PATCH: ["patchEdgeConfigItems"]
+  },
+  user: {
+    GET: ["listUserEvents", "getAuthUser"],
+    DELETE: ["requestDelete"]
+  },
+  marketplace: {
+    GET: ["getAccountInfo", "getMember", "getIntegrationResources", "getIntegrationResource", "getInvoice"],
+    POST: [
+      "createEvent",
+      "submitBillingData",
+      "submitInvoice",
+      "updateInvoice",
+      "submitPrepaymentBalances",
+      "exchangeSsoToken",
+      "createExperimentationItem"
+    ],
+    DELETE: ["deleteIntegrationResource", "deleteExperimentationItem"],
+    PUT: ["importResource", "updateResourceSecrets", "updateResourceSecretsById", "updateExperimentationEdgeConfig"],
+    PATCH: ["updateExperimentationItem"]
+  },
+  authentication: {
+    POST: ["exchangeSsoToken", "createAuthToken"],
+    GET: ["listAuthTokens", "getAuthToken"],
+    DELETE: ["deleteAuthToken"]
+  },
+  logdrains: {
+    GET: ["getIntegrationLogDrains"],
+    POST: ["createLogDrain"],
+    DELETE: ["deleteIntegrationLogDrain"]
+  },
+  logs: {
+    GET: ["getRuntimeLogs"]
+  },
+  projectmembers: {
+    GET: ["getProjectMembers"],
+    POST: ["addProjectMember"],
+    DELETE: ["removeProjectMember"]
+  },
+  environment: {
+    POST: ["createCustomEnvironment"],
+    GET: ["listCustomEnvironments", "getCustomEnvironment"],
+    PATCH: ["updateCustomEnvironment"],
+    DELETE: ["removeCustomEnvironment"]
+  },
+  rollingRelease: {
+    GET: ["getRollingReleaseBillingStatus", "getRollingReleaseConfig", "getRollingRelease"],
+    DELETE: ["deleteRollingReleaseConfig"],
+    PATCH: ["updateRollingReleaseConfig"],
+    POST: ["approveRollingReleaseStage", "completeRollingRelease"]
+  },
+  security: {
+    POST: ["updateAttackChallengeMode", "addBypassIp"],
+    PUT: ["putFirewallConfig"],
+    PATCH: ["updateFirewallConfig"],
+    GET: ["getFirewallConfig", "getActiveAttackStatus", "getBypassIp"],
+    DELETE: ["removeBypassIp"]
+  },
+  teams: {
+    GET: ["getTeamMembers", "getTeamAccessRequest", "getTeam", "getTeams"],
+    POST: ["inviteUserToTeam", "requestAccessToTeam", "joinTeam", "createTeam"],
+    PATCH: ["updateTeamMember", "patchTeam"],
+    DELETE: ["removeTeamMember", "deleteTeam", "deleteTeamInviteCode"]
+  },
+  webhooks: {
+    POST: ["createWebhook"],
+    GET: ["getWebhooks", "getWebhook"],
+    DELETE: ["deleteWebhook"]
+  },
+  aliases: {
+    GET: ["listDeploymentAliases", "listAliases", "getAlias"],
+    POST: ["assignAlias"],
+    DELETE: ["deleteAlias"],
+    PATCH: ["patchUrlProtectionBypass"]
+  },
+  certs: {
+    GET: ["getCertById"],
+    DELETE: ["removeCert"],
+    POST: ["issueCert"],
+    PUT: ["uploadCert"]
+  },
+  secrets: {
+    GET: ["getSecrets", "getSecret"],
+    POST: ["createSecret"],
+    PATCH: ["renameSecret"],
+    DELETE: ["deleteSecret"]
+  }
+};
+
+const Components = {
+  __proto__: null,
+  acceptProjectTransferRequest: acceptProjectTransferRequest,
+  addBypassIp: addBypassIp,
+  addProjectDomain: addProjectDomain,
+  addProjectMember: addProjectMember,
+  approveRollingReleaseStage: approveRollingReleaseStage,
+  artifactQuery: artifactQuery,
+  assignAlias: assignAlias,
+  buyDomain: buyDomain,
+  cancelDeployment: cancelDeployment,
+  checkDomainPrice: checkDomainPrice,
+  checkDomainStatus: checkDomainStatus,
+  completeRollingRelease: completeRollingRelease,
+  createAccessGroup: createAccessGroup,
+  createAccessGroupProject: createAccessGroupProject,
+  createAuthToken: createAuthToken,
+  createCheck: createCheck,
+  createCustomEnvironment: createCustomEnvironment,
+  createDeployment: createDeployment,
+  createEdgeConfig: createEdgeConfig,
+  createEdgeConfigToken: createEdgeConfigToken,
+  createEvent: createEvent,
+  createExperimentationItem: createExperimentationItem,
+  createLogDrain: createLogDrain,
+  createOrTransferDomain: createOrTransferDomain,
+  createProject: createProject,
+  createProjectEnv: createProjectEnv,
+  createProjectTransferRequest: createProjectTransferRequest,
+  createRecord: createRecord,
+  createSecret: createSecret,
+  createTeam: createTeam,
+  createWebhook: createWebhook,
+  deleteAccessGroup: deleteAccessGroup,
+  deleteAccessGroupProject: deleteAccessGroupProject,
+  deleteAlias: deleteAlias,
+  deleteAuthToken: deleteAuthToken,
+  deleteConfiguration: deleteConfiguration,
+  deleteDeployment: deleteDeployment,
+  deleteDomain: deleteDomain,
+  deleteEdgeConfig: deleteEdgeConfig,
+  deleteEdgeConfigSchema: deleteEdgeConfigSchema,
+  deleteEdgeConfigTokens: deleteEdgeConfigTokens,
+  deleteExperimentationItem: deleteExperimentationItem,
+  deleteIntegrationLogDrain: deleteIntegrationLogDrain,
+  deleteIntegrationResource: deleteIntegrationResource,
+  deleteProject: deleteProject,
+  deleteRollingReleaseConfig: deleteRollingReleaseConfig,
+  deleteSecret: deleteSecret,
+  deleteTeam: deleteTeam,
+  deleteTeamInviteCode: deleteTeamInviteCode,
+  deleteWebhook: deleteWebhook,
+  downloadArtifact: downloadArtifact,
+  editProjectEnv: editProjectEnv,
+  exchangeSsoToken: exchangeSsoToken,
+  filterProjectEnvs: filterProjectEnvs,
+  getAccountInfo: getAccountInfo,
+  getActiveAttackStatus: getActiveAttackStatus,
+  getAlias: getAlias,
+  getAllChecks: getAllChecks,
+  getAuthToken: getAuthToken,
+  getAuthUser: getAuthUser,
+  getBypassIp: getBypassIp,
+  getCertById: getCertById,
+  getCheck: getCheck,
+  getConfiguration: getConfiguration,
+  getConfigurations: getConfigurations,
+  getCustomEnvironment: getCustomEnvironment,
+  getDeployment: getDeployment,
+  getDeploymentEvents: getDeploymentEvents,
+  getDeploymentFileContents: getDeploymentFileContents,
+  getDeployments: getDeployments,
+  getDomain: getDomain,
+  getDomainConfig: getDomainConfig,
+  getDomainTransfer: getDomainTransfer,
+  getDomains: getDomains,
+  getEdgeConfig: getEdgeConfig,
+  getEdgeConfigBackup: getEdgeConfigBackup,
+  getEdgeConfigBackups: getEdgeConfigBackups,
+  getEdgeConfigItem: getEdgeConfigItem,
+  getEdgeConfigItems: getEdgeConfigItems,
+  getEdgeConfigSchema: getEdgeConfigSchema,
+  getEdgeConfigToken: getEdgeConfigToken,
+  getEdgeConfigTokens: getEdgeConfigTokens,
+  getEdgeConfigs: getEdgeConfigs,
+  getFirewallConfig: getFirewallConfig,
+  getIntegrationLogDrains: getIntegrationLogDrains,
+  getIntegrationResource: getIntegrationResource,
+  getIntegrationResources: getIntegrationResources,
+  getInvoice: getInvoice,
+  getMember: getMember,
+  getProject: getProject,
+  getProjectDomain: getProjectDomain,
+  getProjectDomains: getProjectDomains,
+  getProjectEnv: getProjectEnv,
+  getProjectMembers: getProjectMembers,
+  getProjects: getProjects,
+  getRecords: getRecords,
+  getRollingRelease: getRollingRelease,
+  getRollingReleaseBillingStatus: getRollingReleaseBillingStatus,
+  getRollingReleaseConfig: getRollingReleaseConfig,
+  getRuntimeLogs: getRuntimeLogs,
+  getSecret: getSecret,
+  getSecrets: getSecrets,
+  getTeam: getTeam,
+  getTeamAccessRequest: getTeamAccessRequest,
+  getTeamMembers: getTeamMembers,
+  getTeams: getTeams,
+  getWebhook: getWebhook,
+  getWebhooks: getWebhooks,
+  importResource: importResource,
+  inviteUserToTeam: inviteUserToTeam,
+  issueCert: issueCert,
+  joinTeam: joinTeam,
+  listAccessGroupMembers: listAccessGroupMembers,
+  listAccessGroupProjects: listAccessGroupProjects,
+  listAccessGroups: listAccessGroups,
+  listAliases: listAliases,
+  listAuthTokens: listAuthTokens,
+  listCerts: listCerts,
+  listCustomEnvironments: listCustomEnvironments,
+  listDeploymentAliases: listDeploymentAliases,
+  listDeploymentFiles: listDeploymentFiles,
+  listPromoteAliases: listPromoteAliases,
+  listUserEvents: listUserEvents,
+  moveProjectDomain: moveProjectDomain,
+  operationsByPath: operationsByPath$1,
+  operationsByTag: operationsByTag$1,
+  patchDomain: patchDomain,
+  patchEdgeConfigItems: patchEdgeConfigItems,
+  patchEdgeConfigSchema: patchEdgeConfigSchema,
+  patchTeam: patchTeam,
+  patchUrlProtectionBypass: patchUrlProtectionBypass,
+  pauseProject: pauseProject,
+  purgeAllDataCache: purgeAllDataCache,
+  putFirewallConfig: putFirewallConfig,
+  readAccessGroup: readAccessGroup,
+  readAccessGroupProject: readAccessGroupProject,
+  recordEvents: recordEvents,
+  removeBypassIp: removeBypassIp,
+  removeCert: removeCert,
+  removeCustomEnvironment: removeCustomEnvironment,
+  removeProjectDomain: removeProjectDomain,
+  removeProjectEnv: removeProjectEnv,
+  removeProjectMember: removeProjectMember,
+  removeRecord: removeRecord,
+  removeTeamMember: removeTeamMember,
+  renameSecret: renameSecret,
+  requestAccessToTeam: requestAccessToTeam,
+  requestDelete: requestDelete,
+  requestPromote: requestPromote,
+  rerequestCheck: rerequestCheck,
+  status: status,
+  submitBillingData: submitBillingData,
+  submitInvoice: submitInvoice,
+  submitPrepaymentBalances: submitPrepaymentBalances,
+  tagDictionary: tagDictionary$1,
+  unpauseProject: unpauseProject,
+  updateAccessGroup: updateAccessGroup,
+  updateAccessGroupProject: updateAccessGroupProject,
+  updateAttackChallengeMode: updateAttackChallengeMode,
+  updateCheck: updateCheck,
+  updateCustomEnvironment: updateCustomEnvironment,
+  updateDataCacheBillingSettings: updateDataCacheBillingSettings,
+  updateEdgeConfig: updateEdgeConfig,
+  updateExperimentationEdgeConfig: updateExperimentationEdgeConfig,
+  updateExperimentationItem: updateExperimentationItem,
+  updateFirewallConfig: updateFirewallConfig,
+  updateIntegrationDeploymentAction: updateIntegrationDeploymentAction,
+  updateInvoice: updateInvoice,
+  updateProject: updateProject,
+  updateProjectDataCache: updateProjectDataCache,
+  updateProjectDomain: updateProjectDomain,
+  updateProjectProtectionBypass: updateProjectProtectionBypass,
+  updateRecord: updateRecord,
+  updateResourceSecrets: updateResourceSecrets,
+  updateResourceSecretsById: updateResourceSecretsById,
+  updateRollingReleaseConfig: updateRollingReleaseConfig,
+  updateTeamMember: updateTeamMember,
+  uploadArtifact: uploadArtifact,
+  uploadCert: uploadCert,
+  uploadFile: uploadFile,
+  verifyProjectDomain: verifyProjectDomain
+};
+
+const ACLActionEnum = {
+  create: "create",
+  delete: "delete",
+  list: "list",
+  read: "read",
+  update: "update"
+};
+const entitiesTypeEnum = {
+  author: "author",
+  bitbucket_login: "bitbucket_login",
+  bold: "bold",
+  deployment_host: "deployment_host",
+  dns_record: "dns_record",
+  "edge-config": "edge-config",
+  env_var_name: "env_var_name",
+  flag: "flag",
+  "flags-segment": "flags-segment",
+  "flags-settings": "flags-settings",
+  git_link: "git_link",
+  github_login: "github_login",
+  gitlab_login: "gitlab_login",
+  hook_name: "hook_name",
+  integration: "integration",
+  link: "link",
+  project_name: "project_name",
+  scaling_rules: "scaling_rules",
+  store: "store",
+  system: "system",
+  target: "target"
+};
+const principalTypeEnum = {
+  user: "user"
+};
+const principalTypeEnum2 = {
+  app: "app"
+};
+const viaTypeEnum = {
+  user: "user"
+};
+const viaTypeEnum2 = {
+  app: "app"
+};
+const payloadActionEnum = {
+  created: "created",
+  updated: "updated",
+  deleted: "deleted",
+  archived: "archived",
+  unarchived: "unarchived"
+};
+const payloadNextRoleEnum = {
+  ADMIN: "ADMIN",
+  PROJECT_DEVELOPER: "PROJECT_DEVELOPER",
+  PROJECT_VIEWER: "PROJECT_VIEWER"
+};
+const payloadPreviousRoleEnum = {
+  ADMIN: "ADMIN",
+  PROJECT_DEVELOPER: "PROJECT_DEVELOPER",
+  PROJECT_VIEWER: "PROJECT_VIEWER"
+};
+const payloadActionEnum2 = {
+  created: "created",
+  removed: "removed"
+};
+const payloadTypeEnum = {
+  system: "system",
+  encrypted: "encrypted",
+  plain: "plain",
+  sensitive: "sensitive"
+};
+const payloadTargetEnum = {
+  production: "production",
+  preview: "preview",
+  development: "development"
+};
+const oldEnvVarTypeEnum = {
+  system: "system",
+  encrypted: "encrypted",
+  plain: "plain",
+  sensitive: "sensitive"
+};
+const oldEnvVarTargetEnum = {
+  production: "production",
+  preview: "preview",
+  development: "development"
+};
+const newEnvVarTypeEnum = {
+  system: "system",
+  encrypted: "encrypted",
+  plain: "plain",
+  sensitive: "sensitive"
+};
+const newEnvVarTargetEnum = {
+  production: "production",
+  preview: "preview",
+  development: "development"
+};
+const updateDiffOldTargetEnum = {
+  production: "production",
+  preview: "preview",
+  development: "development"
+};
+const updateDiffNewTargetEnum = {
+  production: "production",
+  preview: "preview",
+  development: "development"
+};
+const payloadActionEnum3 = {
+  log: "log",
+  challenge: "challenge",
+  deny: "deny"
+};
+const actionEnum = {
+  log: "log",
+  challenge: "challenge",
+  deny: "deny"
+};
+const blockHistoryActionEnum = {
+  "hard-blocked": "hard-blocked",
+  "soft-blocked": "soft-blocked",
+  unblocked: "unblocked"
+};
+const billingPlanEnum = {
+  pro: "pro",
+  enterprise: "enterprise",
+  hobby: "hobby"
+};
+const credentialsTypeEnum = {
+  gitlab: "gitlab",
+  bitbucket: "bitbucket",
+  google: "google",
+  "github-oauth": "github-oauth",
+  "github-oauth-limited": "github-oauth-limited"
+};
+const credentialsTypeEnum2 = {
+  "github-oauth-custom-host": "github-oauth-custom-host"
+};
+const newOwnerImportFlowGitProviderEnum = {
+  github: "github",
+  gitlab: "gitlab",
+  bitbucket: "bitbucket",
+  "github-limited": "github-limited",
+  "github-custom-host": "github-custom-host"
+};
+const buildMachinePurchaseTypeEnum = {
+  enhanced: "enhanced",
+  turbo: "turbo"
+};
+const activeDashboardViewsViewPreferenceEnum = {
+  cards: "cards",
+  list: "list"
+};
+const activeDashboardViewsFavoritesViewPreferenceEnum = {
+  open: "open",
+  closed: "closed"
+};
+const activeDashboardViewsRecentsViewPreferenceEnum = {
+  open: "open",
+  closed: "closed"
+};
+const siftRouteNameEnum = {
+  string: "string"
+};
+const softBlockReasonEnum = {
+  SUBSCRIPTION_CANCELED: "SUBSCRIPTION_CANCELED",
+  SUBSCRIPTION_EXPIRED: "SUBSCRIPTION_EXPIRED",
+  UNPAID_INVOICE: "UNPAID_INVOICE",
+  ENTERPRISE_TRIAL_ENDED: "ENTERPRISE_TRIAL_ENDED",
+  FAIR_USE_LIMITS_EXCEEDED: "FAIR_USE_LIMITS_EXCEEDED",
+  BLOCKED_FOR_PLATFORM_ABUSE: "BLOCKED_FOR_PLATFORM_ABUSE"
+};
+const softBlockBlockedDueToOverageTypeEnum = {
+  analyticsUsage: "analyticsUsage",
+  artifacts: "artifacts",
+  bandwidth: "bandwidth",
+  blobTotalAdvancedRequests: "blobTotalAdvancedRequests",
+  blobTotalAvgSizeInBytes: "blobTotalAvgSizeInBytes",
+  blobTotalGetResponseObjectSizeInBytes: "blobTotalGetResponseObjectSizeInBytes",
+  blobTotalSimpleRequests: "blobTotalSimpleRequests",
+  connectDataTransfer: "connectDataTransfer",
+  dataCacheRead: "dataCacheRead",
+  dataCacheWrite: "dataCacheWrite",
+  edgeConfigRead: "edgeConfigRead",
+  edgeConfigWrite: "edgeConfigWrite",
+  edgeFunctionExecutionUnits: "edgeFunctionExecutionUnits",
+  edgeMiddlewareInvocations: "edgeMiddlewareInvocations",
+  edgeRequestAdditionalCpuDuration: "edgeRequestAdditionalCpuDuration",
+  edgeRequest: "edgeRequest",
+  elasticConcurrencyBuildSlots: "elasticConcurrencyBuildSlots",
+  fastDataTransfer: "fastDataTransfer",
+  fastOriginTransfer: "fastOriginTransfer",
+  fluidCpuDuration: "fluidCpuDuration",
+  fluidDuration: "fluidDuration",
+  functionDuration: "functionDuration",
+  functionInvocation: "functionInvocation",
+  imageOptimizationCacheRead: "imageOptimizationCacheRead",
+  imageOptimizationCacheWrite: "imageOptimizationCacheWrite",
+  imageOptimizationTransformation: "imageOptimizationTransformation",
+  logDrainsVolume: "logDrainsVolume",
+  monitoringMetric: "monitoringMetric",
+  blobDataTransfer: "blobDataTransfer",
+  observabilityEvent: "observabilityEvent",
+  onDemandConcurrencyMinutes: "onDemandConcurrencyMinutes",
+  runtimeCacheRead: "runtimeCacheRead",
+  runtimeCacheWrite: "runtimeCacheWrite",
+  serverlessFunctionExecution: "serverlessFunctionExecution",
+  sourceImages: "sourceImages",
+  wafOwaspExcessBytes: "wafOwaspExcessBytes",
+  wafOwaspRequests: "wafOwaspRequests",
+  wafRateLimitRequest: "wafRateLimitRequest",
+  webAnalyticsEvent: "webAnalyticsEvent"
+};
+const teamsRoleEnum = {
+  OWNER: "OWNER",
+  MEMBER: "MEMBER",
+  DEVELOPER: "DEVELOPER",
+  SECURITY: "SECURITY",
+  BILLING: "BILLING",
+  VIEWER: "VIEWER",
+  CONTRIBUTOR: "CONTRIBUTOR"
+};
+const teamsTeamRolesEnum = {
+  OWNER: "OWNER",
+  MEMBER: "MEMBER",
+  DEVELOPER: "DEVELOPER",
+  SECURITY: "SECURITY",
+  BILLING: "BILLING",
+  VIEWER: "VIEWER",
+  CONTRIBUTOR: "CONTRIBUTOR"
+};
+const teamsTeamPermissionsEnum = {
+  CreateProject: "CreateProject",
+  FullProductionDeployment: "FullProductionDeployment",
+  UsageViewer: "UsageViewer",
+  EnvVariableManager: "EnvVariableManager",
+  EnvironmentManager: "EnvironmentManager"
+};
+const joinedFromOriginEnum = {
+  teams: "teams",
+  saml: "saml",
+  link: "link",
+  github: "github",
+  gitlab: "gitlab",
+  bitbucket: "bitbucket",
+  mail: "mail",
+  import: "import",
+  dsync: "dsync",
+  feedback: "feedback",
+  "organization-teams": "organization-teams"
+};
+const newOwnerTypeEnum = {
+  user: "user"
+};
+const newOwnerEnablePreviewFeedbackEnum = {
+  default: "default",
+  on: "on",
+  off: "off",
+  "on-force": "on-force",
+  "off-force": "off-force",
+  "default-force": "default-force"
+};
+const webAnalyticsBlockReasonEnum = {
+  admin_override: "admin_override",
+  limits_exceeded: "limits_exceeded"
+};
+const monitoringBlockReasonEnum = {
+  admin_override: "admin_override",
+  limits_exceeded: "limits_exceeded"
+};
+const monitoringBlockTypeEnum = {
+  soft: "soft",
+  hard: "hard"
+};
+const observabilityPlusBlockReasonEnum = {
+  admin_override: "admin_override",
+  limits_exceeded: "limits_exceeded"
+};
+const observabilityPlusBlockTypeEnum = {
+  soft: "soft",
+  hard: "hard"
+};
+const dataCacheBlockReasonEnum = {
+  admin_override: "admin_override",
+  limits_exceeded: "limits_exceeded"
+};
+const imageOptimizationTransformationBlockReasonEnum = {
+  admin_override: "admin_override",
+  limits_exceeded: "limits_exceeded"
+};
+const sourceImagesBlockReasonEnum = {
+  admin_override: "admin_override",
+  limits_exceeded: "limits_exceeded"
+};
+const blobBlockReasonEnum = {
+  admin_override: "admin_override",
+  limits_exceeded: "limits_exceeded"
+};
+const blobOverageReasonEnum = {
+  analyticsUsage: "analyticsUsage",
+  artifacts: "artifacts",
+  bandwidth: "bandwidth",
+  blobTotalAdvancedRequests: "blobTotalAdvancedRequests",
+  blobTotalAvgSizeInBytes: "blobTotalAvgSizeInBytes",
+  blobTotalGetResponseObjectSizeInBytes: "blobTotalGetResponseObjectSizeInBytes",
+  blobTotalSimpleRequests: "blobTotalSimpleRequests",
+  connectDataTransfer: "connectDataTransfer",
+  dataCacheRead: "dataCacheRead",
+  dataCacheWrite: "dataCacheWrite",
+  edgeConfigRead: "edgeConfigRead",
+  edgeConfigWrite: "edgeConfigWrite",
+  edgeFunctionExecutionUnits: "edgeFunctionExecutionUnits",
+  edgeMiddlewareInvocations: "edgeMiddlewareInvocations",
+  edgeRequestAdditionalCpuDuration: "edgeRequestAdditionalCpuDuration",
+  edgeRequest: "edgeRequest",
+  elasticConcurrencyBuildSlots: "elasticConcurrencyBuildSlots",
+  fastDataTransfer: "fastDataTransfer",
+  fastOriginTransfer: "fastOriginTransfer",
+  fluidCpuDuration: "fluidCpuDuration",
+  fluidDuration: "fluidDuration",
+  functionDuration: "functionDuration",
+  functionInvocation: "functionInvocation",
+  imageOptimizationCacheRead: "imageOptimizationCacheRead",
+  imageOptimizationCacheWrite: "imageOptimizationCacheWrite",
+  imageOptimizationTransformation: "imageOptimizationTransformation",
+  logDrainsVolume: "logDrainsVolume",
+  monitoringMetric: "monitoringMetric",
+  blobDataTransfer: "blobDataTransfer",
+  observabilityEvent: "observabilityEvent",
+  onDemandConcurrencyMinutes: "onDemandConcurrencyMinutes",
+  runtimeCacheRead: "runtimeCacheRead",
+  runtimeCacheWrite: "runtimeCacheWrite",
+  serverlessFunctionExecution: "serverlessFunctionExecution",
+  sourceImages: "sourceImages",
+  wafOwaspExcessBytes: "wafOwaspExcessBytes",
+  wafOwaspRequests: "wafOwaspRequests",
+  wafRateLimitRequest: "wafRateLimitRequest",
+  webAnalyticsEvent: "webAnalyticsEvent"
+};
+const postgresBlockReasonEnum = {
+  admin_override: "admin_override",
+  limits_exceeded: "limits_exceeded"
+};
+const postgresOverageReasonEnum = {
+  analyticsUsage: "analyticsUsage",
+  artifacts: "artifacts",
+  bandwidth: "bandwidth",
+  blobTotalAdvancedRequests: "blobTotalAdvancedRequests",
+  blobTotalAvgSizeInBytes: "blobTotalAvgSizeInBytes",
+  blobTotalGetResponseObjectSizeInBytes: "blobTotalGetResponseObjectSizeInBytes",
+  blobTotalSimpleRequests: "blobTotalSimpleRequests",
+  connectDataTransfer: "connectDataTransfer",
+  dataCacheRead: "dataCacheRead",
+  dataCacheWrite: "dataCacheWrite",
+  edgeConfigRead: "edgeConfigRead",
+  edgeConfigWrite: "edgeConfigWrite",
+  edgeFunctionExecutionUnits: "edgeFunctionExecutionUnits",
+  edgeMiddlewareInvocations: "edgeMiddlewareInvocations",
+  edgeRequestAdditionalCpuDuration: "edgeRequestAdditionalCpuDuration",
+  edgeRequest: "edgeRequest",
+  elasticConcurrencyBuildSlots: "elasticConcurrencyBuildSlots",
+  fastDataTransfer: "fastDataTransfer",
+  fastOriginTransfer: "fastOriginTransfer",
+  fluidCpuDuration: "fluidCpuDuration",
+  fluidDuration: "fluidDuration",
+  functionDuration: "functionDuration",
+  functionInvocation: "functionInvocation",
+  imageOptimizationCacheRead: "imageOptimizationCacheRead",
+  imageOptimizationCacheWrite: "imageOptimizationCacheWrite",
+  imageOptimizationTransformation: "imageOptimizationTransformation",
+  logDrainsVolume: "logDrainsVolume",
+  monitoringMetric: "monitoringMetric",
+  blobDataTransfer: "blobDataTransfer",
+  observabilityEvent: "observabilityEvent",
+  onDemandConcurrencyMinutes: "onDemandConcurrencyMinutes",
+  runtimeCacheRead: "runtimeCacheRead",
+  runtimeCacheWrite: "runtimeCacheWrite",
+  serverlessFunctionExecution: "serverlessFunctionExecution",
+  sourceImages: "sourceImages",
+  wafOwaspExcessBytes: "wafOwaspExcessBytes",
+  wafOwaspRequests: "wafOwaspRequests",
+  wafRateLimitRequest: "wafRateLimitRequest",
+  webAnalyticsEvent: "webAnalyticsEvent"
+};
+const redisBlockReasonEnum = {
+  admin_override: "admin_override",
+  limits_exceeded: "limits_exceeded"
+};
+const redisOverageReasonEnum = {
+  analyticsUsage: "analyticsUsage",
+  artifacts: "artifacts",
+  bandwidth: "bandwidth",
+  blobTotalAdvancedRequests: "blobTotalAdvancedRequests",
+  blobTotalAvgSizeInBytes: "blobTotalAvgSizeInBytes",
+  blobTotalGetResponseObjectSizeInBytes: "blobTotalGetResponseObjectSizeInBytes",
+  blobTotalSimpleRequests: "blobTotalSimpleRequests",
+  connectDataTransfer: "connectDataTransfer",
+  dataCacheRead: "dataCacheRead",
+  dataCacheWrite: "dataCacheWrite",
+  edgeConfigRead: "edgeConfigRead",
+  edgeConfigWrite: "edgeConfigWrite",
+  edgeFunctionExecutionUnits: "edgeFunctionExecutionUnits",
+  edgeMiddlewareInvocations: "edgeMiddlewareInvocations",
+  edgeRequestAdditionalCpuDuration: "edgeRequestAdditionalCpuDuration",
+  edgeRequest: "edgeRequest",
+  elasticConcurrencyBuildSlots: "elasticConcurrencyBuildSlots",
+  fastDataTransfer: "fastDataTransfer",
+  fastOriginTransfer: "fastOriginTransfer",
+  fluidCpuDuration: "fluidCpuDuration",
+  fluidDuration: "fluidDuration",
+  functionDuration: "functionDuration",
+  functionInvocation: "functionInvocation",
+  imageOptimizationCacheRead: "imageOptimizationCacheRead",
+  imageOptimizationCacheWrite: "imageOptimizationCacheWrite",
+  imageOptimizationTransformation: "imageOptimizationTransformation",
+  logDrainsVolume: "logDrainsVolume",
+  monitoringMetric: "monitoringMetric",
+  blobDataTransfer: "blobDataTransfer",
+  observabilityEvent: "observabilityEvent",
+  onDemandConcurrencyMinutes: "onDemandConcurrencyMinutes",
+  runtimeCacheRead: "runtimeCacheRead",
+  runtimeCacheWrite: "runtimeCacheWrite",
+  serverlessFunctionExecution: "serverlessFunctionExecution",
+  sourceImages: "sourceImages",
+  wafOwaspExcessBytes: "wafOwaspExcessBytes",
+  wafOwaspRequests: "wafOwaspRequests",
+  wafRateLimitRequest: "wafRateLimitRequest",
+  webAnalyticsEvent: "webAnalyticsEvent"
+};
+const newOwnerVersionEnum = {
+  northstar: "northstar"
+};
+const browserNameEnum = {
+  iphone: "iphone",
+  ipad: "ipad",
+  ipod: "ipod",
+  chrome: "chrome",
+  firefox: "firefox",
+  mozilla: "mozilla",
+  unknown: "unknown"
+};
+const osNameEnum = {
+  unknown: "unknown",
+  darwin: "darwin",
+  win32: "win32",
+  win: "win",
+  windows: "windows",
+  linux: "linux",
+  freebsd: "freebsd",
+  sunos: "sunos",
+  mac: "mac",
+  ios: "ios",
+  android: "android",
+  "Mac OS": "Mac OS",
+  "OS X": "OS X"
+};
+const roleEnum = {
+  OWNER: "OWNER",
+  MEMBER: "MEMBER",
+  DEVELOPER: "DEVELOPER",
+  SECURITY: "SECURITY",
+  BILLING: "BILLING",
+  VIEWER: "VIEWER",
+  CONTRIBUTOR: "CONTRIBUTOR"
+};
+const joinedFromOriginEnum2 = {
+  teams: "teams",
+  saml: "saml",
+  link: "link",
+  github: "github",
+  gitlab: "gitlab",
+  bitbucket: "bitbucket",
+  mail: "mail",
+  import: "import",
+  dsync: "dsync",
+  feedback: "feedback",
+  "organization-teams": "organization-teams"
+};
+const ssoProtectionDeploymentTypeEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains"
+};
+const payloadSsoProtectionEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains"
+};
+const oldSsoProtectionDeploymentTypeEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains"
+};
+const payloadOldSsoProtectionEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains"
+};
+const passwordProtectionDeploymentTypeEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains"
+};
+const payloadPasswordProtectionEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains"
+};
+const oldPasswordProtectionDeploymentTypeEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains"
+};
+const payloadOldPasswordProtectionEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains"
+};
+const payloadTrustedIpsEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains",
+  production: "production"
+};
+const payloadOldTrustedIpsEnum = {
+  all: "all",
+  preview: "preview",
+  prod_deployment_urls_and_all_previews: "prod_deployment_urls_and_all_previews",
+  all_except_custom_domains: "all_except_custom_domains",
+  production: "production"
+};
+const payloadActionEnum4 = {
+  enabled: "enabled",
+  disabled: "disabled",
+  regenerated: "regenerated"
+};
+const oldConnectConfigurationsEnvIdEnum = {
+  preview: "preview",
+  production: "production"
+};
+const newConnectConfigurationsEnvIdEnum = {
+  preview: "preview",
+  production: "production"
+};
+const budgetTypeEnum = {
+  fixed: "fixed"
+};
+const budgetPricingPlanEnum = {
+  legacy: "legacy",
+  unbundled: "unbundled"
+};
+const budgetItemTypeEnum = {
+  fixed: "fixed"
+};
+const budgetItemPricingPlanEnum = {
+  legacy: "legacy",
+  unbundled: "unbundled"
+};
+const payloadTypeEnum2 = {
+  redis: "redis",
+  postgres: "postgres",
+  "edge-config": "edge-config",
+  blob: "blob",
+  integration: "integration"
+};
+const payloadStoreTypeEnum = {
+  redis: "redis",
+  postgres: "postgres"
+};
+const projectMembershipRoleEnum = {
+  ADMIN: "ADMIN",
+  PROJECT_DEVELOPER: "PROJECT_DEVELOPER",
+  PROJECT_VIEWER: "PROJECT_VIEWER"
+};
+const removedMembershipRoleEnum = {
+  ADMIN: "ADMIN",
+  PROJECT_DEVELOPER: "PROJECT_DEVELOPER",
+  PROJECT_VIEWER: "PROJECT_VIEWER"
+};
+const projectMembershipRoleEnum2 = {
+  ADMIN: "ADMIN",
+  PROJECT_DEVELOPER: "PROJECT_DEVELOPER",
+  PROJECT_VIEWER: "PROJECT_VIEWER"
+};
+const projectMembershipPreviousRoleEnum = {
+  ADMIN: "ADMIN",
+  PROJECT_DEVELOPER: "PROJECT_DEVELOPER",
+  PROJECT_VIEWER: "PROJECT_VIEWER"
+};
+const projectRoleEnum = {
+  ADMIN: "ADMIN",
+  PROJECT_DEVELOPER: "PROJECT_DEVELOPER",
+  PROJECT_VIEWER: "PROJECT_VIEWER"
+};
+const payloadActionEnum5 = {
+  enable: "enable",
+  disable: "disable"
+};
+const payloadTierEnum = {
+  pro: "pro",
+  plus: "plus"
+};
+const payloadGrantTypeEnum = {
+  authorization_code: "authorization_code",
+  refresh_token: "refresh_token",
+  "urn:ietf:params:oauth:grant-type:device_code": "urn:ietf:params:oauth:grant-type:device_code",
+  client_credentials: "client_credentials"
+};
+const payloadAuthMethodEnum = {
+  email: "email",
+  saml: "saml",
+  github: "github",
+  gitlab: "gitlab",
+  bitbucket: "bitbucket",
+  manual: "manual",
+  passkey: "passkey",
+  otp: "otp",
+  sms: "sms",
+  invite: "invite",
+  google: "google"
+};
+const rolesEnum = {
+  OWNER: "OWNER",
+  MEMBER: "MEMBER",
+  DEVELOPER: "DEVELOPER",
+  SECURITY: "SECURITY",
+  BILLING: "BILLING",
+  VIEWER: "VIEWER",
+  CONTRIBUTOR: "CONTRIBUTOR"
+};
+const teamEnablePreviewFeedbackEnum = {
+  default: "default",
+  "default-force": "default-force",
+  off: "off",
+  "off-force": "off-force",
+  on: "on",
+  "on-force": "on-force"
+};
+const teamEnableProductionFeedbackEnum = {
+  default: "default",
+  "default-force": "default-force",
+  off: "off",
+  "off-force": "off-force",
+  on: "on",
+  "on-force": "on-force"
+};
+const teamSensitiveEnvironmentVariablePolicyEnum = {
+  default: "default",
+  off: "off",
+  on: "on"
+};
+const membershipRoleEnum = {
+  BILLING: "BILLING",
+  CONTRIBUTOR: "CONTRIBUTOR",
+  DEVELOPER: "DEVELOPER",
+  MEMBER: "MEMBER",
+  OWNER: "OWNER",
+  SECURITY: "SECURITY",
+  VIEWER: "VIEWER"
+};
+const membershipTeamRolesEnum = {
+  BILLING: "BILLING",
+  CONTRIBUTOR: "CONTRIBUTOR",
+  DEVELOPER: "DEVELOPER",
+  MEMBER: "MEMBER",
+  OWNER: "OWNER",
+  SECURITY: "SECURITY",
+  VIEWER: "VIEWER"
+};
+const membershipTeamPermissionsEnum = {
+  CreateProject: "CreateProject",
+  EnvVariableManager: "EnvVariableManager",
+  EnvironmentManager: "EnvironmentManager",
+  FullProductionDeployment: "FullProductionDeployment",
+  UsageViewer: "UsageViewer"
+};
+const joinedFromOriginEnum3 = {
+  bitbucket: "bitbucket",
+  dsync: "dsync",
+  feedback: "feedback",
+  github: "github",
+  gitlab: "gitlab",
+  import: "import",
+  link: "link",
+  mail: "mail",
+  "organization-teams": "organization-teams",
+  saml: "saml",
+  teams: "teams"
+};
+const teamLimitedLimitedByEnum = {
+  mfa: "mfa",
+  scope: "scope"
+};
+const membershipRoleEnum2 = {
+  BILLING: "BILLING",
+  CONTRIBUTOR: "CONTRIBUTOR",
+  DEVELOPER: "DEVELOPER",
+  MEMBER: "MEMBER",
+  OWNER: "OWNER",
+  SECURITY: "SECURITY",
+  VIEWER: "VIEWER"
+};
+const membershipTeamRolesEnum2 = {
+  BILLING: "BILLING",
+  CONTRIBUTOR: "CONTRIBUTOR",
+  DEVELOPER: "DEVELOPER",
+  MEMBER: "MEMBER",
+  OWNER: "OWNER",
+  SECURITY: "SECURITY",
+  VIEWER: "VIEWER"
+};
+const membershipTeamPermissionsEnum2 = {
+  CreateProject: "CreateProject",
+  EnvVariableManager: "EnvVariableManager",
+  EnvironmentManager: "EnvironmentManager",
+  FullProductionDeployment: "FullProductionDeployment",
+  UsageViewer: "UsageViewer"
+};
+const joinedFromOriginEnum4 = {
+  bitbucket: "bitbucket",
+  dsync: "dsync",
+  feedback: "feedback",
+  github: "github",
+  gitlab: "gitlab",
+  import: "import",
+  link: "link",
+  mail: "mail",
+  "organization-teams": "organization-teams",
+  saml: "saml",
+  teams: "teams"
+};
+const scopesTypeEnum = {
+  user: "user"
+};
+const sudoOriginEnum = {
+  totp: "totp",
+  webauthn: "webauthn",
+  "recovery-code": "recovery-code"
+};
+const scopesOriginEnum = {
+  saml: "saml",
+  github: "github",
+  gitlab: "gitlab",
+  bitbucket: "bitbucket",
+  email: "email",
+  manual: "manual",
+  passkey: "passkey",
+  otp: "otp",
+  sms: "sms",
+  invite: "invite",
+  google: "google"
+};
+const scopesTypeEnum2 = {
+  team: "team"
+};
+const scopesOriginEnum2 = {
+  saml: "saml",
+  github: "github",
+  gitlab: "gitlab",
+  bitbucket: "bitbucket",
+  email: "email",
+  manual: "manual",
+  passkey: "passkey",
+  otp: "otp",
+  sms: "sms",
+  invite: "invite",
+  google: "google"
+};
+const softBlockReasonEnum2 = {
+  BLOCKED_FOR_PLATFORM_ABUSE: "BLOCKED_FOR_PLATFORM_ABUSE",
+  ENTERPRISE_TRIAL_ENDED: "ENTERPRISE_TRIAL_ENDED",
+  FAIR_USE_LIMITS_EXCEEDED: "FAIR_USE_LIMITS_EXCEEDED",
+  SUBSCRIPTION_CANCELED: "SUBSCRIPTION_CANCELED",
+  SUBSCRIPTION_EXPIRED: "SUBSCRIPTION_EXPIRED",
+  UNPAID_INVOICE: "UNPAID_INVOICE"
+};
+const softBlockBlockedDueToOverageTypeEnum2 = {
+  analyticsUsage: "analyticsUsage",
+  artifacts: "artifacts",
+  bandwidth: "bandwidth",
+  blobDataTransfer: "blobDataTransfer",
+  blobTotalAdvancedRequests: "blobTotalAdvancedRequests",
+  blobTotalAvgSizeInBytes: "blobTotalAvgSizeInBytes",
+  blobTotalGetResponseObjectSizeInBytes: "blobTotalGetResponseObjectSizeInBytes",
+  blobTotalSimpleRequests: "blobTotalSimpleRequests",
+  connectDataTransfer: "connectDataTransfer",
+  dataCacheRead: "dataCacheRead",
+  dataCacheWrite: "dataCacheWrite",
+  edgeConfigRead: "edgeConfigRead",
+  edgeConfigWrite: "edgeConfigWrite",
+  edgeFunctionExecutionUnits: "edgeFunctionExecutionUnits",
+  edgeMiddlewareInvocations: "edgeMiddlewareInvocations",
+  edgeRequest: "edgeRequest",
+  edgeRequestAdditionalCpuDuration: "edgeRequestAdditionalCpuDuration",
+  elasticConcurrencyBuildSlots: "elasticConcurrencyBuildSlots",
+  fastDataTransfer: "fastDataTransfer",
+  fastOriginTransfer: "fastOriginTransfer",
+  fluidCpuDuration: "fluidCpuDuration",
+  fluidDuration: "fluidDuration",
+  functionDuration: "functionDuration",
+  functionInvocation: "functionInvocation",
+  imageOptimizationCacheRead: "imageOptimizationCacheRead",
+  imageOptimizationCacheWrite: "imageOptimizationCacheWrite",
+  imageOptimizationTransformation: "imageOptimizationTransformation",
+  logDrainsVolume: "logDrainsVolume",
+  monitoringMetric: "monitoringMetric",
+  observabilityEvent: "observabilityEvent",
+  onDemandConcurrencyMinutes: "onDemandConcurrencyMinutes",
+  runtimeCacheRead: "runtimeCacheRead",
+  runtimeCacheWrite: "runtimeCacheWrite",
+  serverlessFunctionExecution: "serverlessFunctionExecution",
+  sourceImages: "sourceImages",
+  wafOwaspExcessBytes: "wafOwaspExcessBytes",
+  wafOwaspRequests: "wafOwaspRequests",
+  wafRateLimitRequest: "wafRateLimitRequest",
+  webAnalyticsEvent: "webAnalyticsEvent"
+};
+const buildMachinePurchaseTypeEnum2 = {
+  enhanced: "enhanced",
+  turbo: "turbo"
+};
+const activeDashboardViewsViewPreferenceEnum2 = {
+  cards: "cards",
+  list: "list"
+};
+const activeDashboardViewsFavoritesViewPreferenceEnum2 = {
+  closed: "closed",
+  open: "open"
+};
+const activeDashboardViewsRecentsViewPreferenceEnum2 = {
+  closed: "closed",
+  open: "open"
+};
+const authUserImportFlowGitProviderEnum = {
+  bitbucket: "bitbucket",
+  github: "github",
+  "github-custom-host": "github-custom-host",
+  "github-limited": "github-limited",
+  gitlab: "gitlab"
+};
+const fileTreeTypeEnum = {
+  directory: "directory",
+  file: "file",
+  invalid: "invalid",
+  lambda: "lambda",
+  middleware: "middleware",
+  symlink: "symlink"
+};
+const getDeploymentEventsQueryParamsDirectionEnum = {
+  backward: "backward",
+  forward: "forward"
+};
+const getDeploymentEventsQueryParamsFollowEnum = {
+  "0": 0,
+  "1": 1
+};
+const getDeploymentEventsQueryParamsDelimiterEnum = {
+  "0": 0,
+  "1": 1
+};
+const getDeploymentEventsQueryParamsBuildsEnum = {
+  "0": 0,
+  "1": 1
+};
+const createDeploymentQueryParamsForceNewEnum = {
+  "0": "0",
+  "1": "1"
+};
+const createDeploymentQueryParamsSkipAutoDetectionConfirmationEnum = {
+  "0": "0",
+  "1": "1"
+};
+const checkDomainPriceQueryParamsTypeEnum = {
+  new: "new",
+  renewal: "renewal",
+  transfer: "transfer",
+  redemption: "redemption"
+};
+const getDomainConfigQueryParamsStrictEnum = {
+  true: "true",
+  false: "false"
+};
+const getConfigurationsQueryParamsViewEnum = {
+  account: "account",
+  project: "project"
+};
+const getConfigurationsQueryParamsInstallationTypeEnum = {
+  marketplace: "marketplace",
+  external: "external"
+};
+const getProjectsQueryParamsGitForkProtectionEnum = {
+  "1": "1",
+  "0": "0"
+};
+const getProjectDomainsQueryParamsProductionEnum = {
+  true: "true",
+  false: "false"
+};
+const getProjectDomainsQueryParamsTargetEnum = {
+  production: "production",
+  preview: "preview"
+};
+const getProjectDomainsQueryParamsRedirectsEnum = {
+  true: "true",
+  false: "false"
+};
+const getProjectDomainsQueryParamsVerifiedEnum = {
+  true: "true",
+  false: "false"
+};
+const getProjectDomainsQueryParamsOrderEnum = {
+  ASC: "ASC",
+  DESC: "DESC"
+};
+const filterProjectEnvsQueryParamsDecryptEnum = {
+  true: "true",
+  false: "false"
+};
+const getRollingReleaseQueryParamsStateEnum = {
+  ACTIVE: "ACTIVE",
+  COMPLETE: "COMPLETE",
+  ABORTED: "ABORTED"
+};
+const getTeamMembersQueryParamsRoleEnum = {
+  OWNER: "OWNER",
+  MEMBER: "MEMBER",
+  DEVELOPER: "DEVELOPER",
+  VIEWER: "VIEWER",
+  BILLING: "BILLING",
+  CONTRIBUTOR: "CONTRIBUTOR"
+};
+const getSecretQueryParamsDecryptEnum = {
+  true: "true",
+  false: "false"
+};
+
+const types = {
+  __proto__: null,
+  ACLActionEnum: ACLActionEnum,
+  actionEnum: actionEnum,
+  activeDashboardViewsFavoritesViewPreferenceEnum: activeDashboardViewsFavoritesViewPreferenceEnum,
+  activeDashboardViewsFavoritesViewPreferenceEnum2: activeDashboardViewsFavoritesViewPreferenceEnum2,
+  activeDashboardViewsRecentsViewPreferenceEnum: activeDashboardViewsRecentsViewPreferenceEnum,
+  activeDashboardViewsRecentsViewPreferenceEnum2: activeDashboardViewsRecentsViewPreferenceEnum2,
+  activeDashboardViewsViewPreferenceEnum: activeDashboardViewsViewPreferenceEnum,
+  activeDashboardViewsViewPreferenceEnum2: activeDashboardViewsViewPreferenceEnum2,
+  authUserImportFlowGitProviderEnum: authUserImportFlowGitProviderEnum,
+  billingPlanEnum: billingPlanEnum,
+  blobBlockReasonEnum: blobBlockReasonEnum,
+  blobOverageReasonEnum: blobOverageReasonEnum,
+  blockHistoryActionEnum: blockHistoryActionEnum,
+  browserNameEnum: browserNameEnum,
+  budgetItemPricingPlanEnum: budgetItemPricingPlanEnum,
+  budgetItemTypeEnum: budgetItemTypeEnum,
+  budgetPricingPlanEnum: budgetPricingPlanEnum,
+  budgetTypeEnum: budgetTypeEnum,
+  buildMachinePurchaseTypeEnum: buildMachinePurchaseTypeEnum,
+  buildMachinePurchaseTypeEnum2: buildMachinePurchaseTypeEnum2,
+  checkDomainPriceQueryParamsTypeEnum: checkDomainPriceQueryParamsTypeEnum,
+  createDeploymentQueryParamsForceNewEnum: createDeploymentQueryParamsForceNewEnum,
+  createDeploymentQueryParamsSkipAutoDetectionConfirmationEnum: createDeploymentQueryParamsSkipAutoDetectionConfirmationEnum,
+  credentialsTypeEnum: credentialsTypeEnum,
+  credentialsTypeEnum2: credentialsTypeEnum2,
+  dataCacheBlockReasonEnum: dataCacheBlockReasonEnum,
+  entitiesTypeEnum: entitiesTypeEnum,
+  fileTreeTypeEnum: fileTreeTypeEnum,
+  filterProjectEnvsQueryParamsDecryptEnum: filterProjectEnvsQueryParamsDecryptEnum,
+  getConfigurationsQueryParamsInstallationTypeEnum: getConfigurationsQueryParamsInstallationTypeEnum,
+  getConfigurationsQueryParamsViewEnum: getConfigurationsQueryParamsViewEnum,
+  getDeploymentEventsQueryParamsBuildsEnum: getDeploymentEventsQueryParamsBuildsEnum,
+  getDeploymentEventsQueryParamsDelimiterEnum: getDeploymentEventsQueryParamsDelimiterEnum,
+  getDeploymentEventsQueryParamsDirectionEnum: getDeploymentEventsQueryParamsDirectionEnum,
+  getDeploymentEventsQueryParamsFollowEnum: getDeploymentEventsQueryParamsFollowEnum,
+  getDomainConfigQueryParamsStrictEnum: getDomainConfigQueryParamsStrictEnum,
+  getProjectDomainsQueryParamsOrderEnum: getProjectDomainsQueryParamsOrderEnum,
+  getProjectDomainsQueryParamsProductionEnum: getProjectDomainsQueryParamsProductionEnum,
+  getProjectDomainsQueryParamsRedirectsEnum: getProjectDomainsQueryParamsRedirectsEnum,
+  getProjectDomainsQueryParamsTargetEnum: getProjectDomainsQueryParamsTargetEnum,
+  getProjectDomainsQueryParamsVerifiedEnum: getProjectDomainsQueryParamsVerifiedEnum,
+  getProjectsQueryParamsGitForkProtectionEnum: getProjectsQueryParamsGitForkProtectionEnum,
+  getRollingReleaseQueryParamsStateEnum: getRollingReleaseQueryParamsStateEnum,
+  getSecretQueryParamsDecryptEnum: getSecretQueryParamsDecryptEnum,
+  getTeamMembersQueryParamsRoleEnum: getTeamMembersQueryParamsRoleEnum,
+  imageOptimizationTransformationBlockReasonEnum: imageOptimizationTransformationBlockReasonEnum,
+  joinedFromOriginEnum: joinedFromOriginEnum,
+  joinedFromOriginEnum2: joinedFromOriginEnum2,
+  joinedFromOriginEnum3: joinedFromOriginEnum3,
+  joinedFromOriginEnum4: joinedFromOriginEnum4,
+  membershipRoleEnum: membershipRoleEnum,
+  membershipRoleEnum2: membershipRoleEnum2,
+  membershipTeamPermissionsEnum: membershipTeamPermissionsEnum,
+  membershipTeamPermissionsEnum2: membershipTeamPermissionsEnum2,
+  membershipTeamRolesEnum: membershipTeamRolesEnum,
+  membershipTeamRolesEnum2: membershipTeamRolesEnum2,
+  monitoringBlockReasonEnum: monitoringBlockReasonEnum,
+  monitoringBlockTypeEnum: monitoringBlockTypeEnum,
+  newConnectConfigurationsEnvIdEnum: newConnectConfigurationsEnvIdEnum,
+  newEnvVarTargetEnum: newEnvVarTargetEnum,
+  newEnvVarTypeEnum: newEnvVarTypeEnum,
+  newOwnerEnablePreviewFeedbackEnum: newOwnerEnablePreviewFeedbackEnum,
+  newOwnerImportFlowGitProviderEnum: newOwnerImportFlowGitProviderEnum,
+  newOwnerTypeEnum: newOwnerTypeEnum,
+  newOwnerVersionEnum: newOwnerVersionEnum,
+  observabilityPlusBlockReasonEnum: observabilityPlusBlockReasonEnum,
+  observabilityPlusBlockTypeEnum: observabilityPlusBlockTypeEnum,
+  oldConnectConfigurationsEnvIdEnum: oldConnectConfigurationsEnvIdEnum,
+  oldEnvVarTargetEnum: oldEnvVarTargetEnum,
+  oldEnvVarTypeEnum: oldEnvVarTypeEnum,
+  oldPasswordProtectionDeploymentTypeEnum: oldPasswordProtectionDeploymentTypeEnum,
+  oldSsoProtectionDeploymentTypeEnum: oldSsoProtectionDeploymentTypeEnum,
+  osNameEnum: osNameEnum,
+  passwordProtectionDeploymentTypeEnum: passwordProtectionDeploymentTypeEnum,
+  payloadActionEnum: payloadActionEnum,
+  payloadActionEnum2: payloadActionEnum2,
+  payloadActionEnum3: payloadActionEnum3,
+  payloadActionEnum4: payloadActionEnum4,
+  payloadActionEnum5: payloadActionEnum5,
+  payloadAuthMethodEnum: payloadAuthMethodEnum,
+  payloadGrantTypeEnum: payloadGrantTypeEnum,
+  payloadNextRoleEnum: payloadNextRoleEnum,
+  payloadOldPasswordProtectionEnum: payloadOldPasswordProtectionEnum,
+  payloadOldSsoProtectionEnum: payloadOldSsoProtectionEnum,
+  payloadOldTrustedIpsEnum: payloadOldTrustedIpsEnum,
+  payloadPasswordProtectionEnum: payloadPasswordProtectionEnum,
+  payloadPreviousRoleEnum: payloadPreviousRoleEnum,
+  payloadSsoProtectionEnum: payloadSsoProtectionEnum,
+  payloadStoreTypeEnum: payloadStoreTypeEnum,
+  payloadTargetEnum: payloadTargetEnum,
+  payloadTierEnum: payloadTierEnum,
+  payloadTrustedIpsEnum: payloadTrustedIpsEnum,
+  payloadTypeEnum: payloadTypeEnum,
+  payloadTypeEnum2: payloadTypeEnum2,
+  postgresBlockReasonEnum: postgresBlockReasonEnum,
+  postgresOverageReasonEnum: postgresOverageReasonEnum,
+  principalTypeEnum: principalTypeEnum,
+  principalTypeEnum2: principalTypeEnum2,
+  projectMembershipPreviousRoleEnum: projectMembershipPreviousRoleEnum,
+  projectMembershipRoleEnum: projectMembershipRoleEnum,
+  projectMembershipRoleEnum2: projectMembershipRoleEnum2,
+  projectRoleEnum: projectRoleEnum,
+  redisBlockReasonEnum: redisBlockReasonEnum,
+  redisOverageReasonEnum: redisOverageReasonEnum,
+  removedMembershipRoleEnum: removedMembershipRoleEnum,
+  roleEnum: roleEnum,
+  rolesEnum: rolesEnum,
+  scopesOriginEnum: scopesOriginEnum,
+  scopesOriginEnum2: scopesOriginEnum2,
+  scopesTypeEnum: scopesTypeEnum,
+  scopesTypeEnum2: scopesTypeEnum2,
+  siftRouteNameEnum: siftRouteNameEnum,
+  softBlockBlockedDueToOverageTypeEnum: softBlockBlockedDueToOverageTypeEnum,
+  softBlockBlockedDueToOverageTypeEnum2: softBlockBlockedDueToOverageTypeEnum2,
+  softBlockReasonEnum: softBlockReasonEnum,
+  softBlockReasonEnum2: softBlockReasonEnum2,
+  sourceImagesBlockReasonEnum: sourceImagesBlockReasonEnum,
+  ssoProtectionDeploymentTypeEnum: ssoProtectionDeploymentTypeEnum,
+  sudoOriginEnum: sudoOriginEnum,
+  teamEnablePreviewFeedbackEnum: teamEnablePreviewFeedbackEnum,
+  teamEnableProductionFeedbackEnum: teamEnableProductionFeedbackEnum,
+  teamLimitedLimitedByEnum: teamLimitedLimitedByEnum,
+  teamSensitiveEnvironmentVariablePolicyEnum: teamSensitiveEnvironmentVariablePolicyEnum,
+  teamsRoleEnum: teamsRoleEnum,
+  teamsTeamPermissionsEnum: teamsTeamPermissionsEnum,
+  teamsTeamRolesEnum: teamsTeamRolesEnum,
+  updateDiffNewTargetEnum: updateDiffNewTargetEnum,
+  updateDiffOldTargetEnum: updateDiffOldTargetEnum,
+  viaTypeEnum: viaTypeEnum,
+  viaTypeEnum2: viaTypeEnum2,
+  webAnalyticsBlockReasonEnum: webAnalyticsBlockReasonEnum
+};
+
+function formEncoded(data) {
+  return Object.entries(data).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+
+class VercelApi {
+  token;
+  fetch;
+  constructor(options) {
+    this.token = options.token;
+    this.fetch = options.fetch || fetch;
+    if (!this.fetch) throw new Error("Fetch is required");
+  }
+  get api() {
+    const getConfig = async () => ({
+      token: this.token,
+      fetchImpl: this.fetch
+    });
+    return new Proxy(
+      {},
+      {
+        get: (_target, namespace) => {
+          if (operationsByTag$1[namespace] === void 0) {
+            return void 0;
+          }
+          return new Proxy(
+            {},
+            {
+              get: (_target2, operation) => {
+                if (operationsByTag$1[namespace][operation] === void 0) {
+                  return void 0;
+                }
+                const method = operationsByTag$1[namespace][operation];
+                return async (params) => {
+                  return await method({ ...params, config: await getConfig() });
+                };
+              }
+            }
+          );
+        }
+      }
+    );
+  }
+  get auth() {
+    return {
+      accessToken: async ({
+        code,
+        redirectUri,
+        clientId,
+        clientSecret
+      }) => {
+        const result = await schemas.client({
+          method: "POST",
+          url: `/v2/oauth/access_token`,
+          token: null,
+          fetchImpl: this.fetch,
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: formEncoded({ code, redirect_uri: redirectUri, client_id: clientId, client_secret: clientSecret })
+        });
+        return {
+          accessToken: result.access_token,
+          tokenType: result.token_type,
+          installationId: result.installation_id,
+          userId: result.user_id,
+          teamId: result.team_id
+        };
+      }
+    };
+  }
+  async request(endpoint, params) {
+    const [method = "", url = ""] = endpoint.split(" ");
+    const extraParams = params || {};
+    const result = await schemas.client({
+      ...extraParams,
+      method,
+      url,
+      token: this.token,
+      fetchImpl: this.fetch
+    });
+    return result;
+  }
+}
+
+const { operationsByPath, operationsByTag, tagDictionary, ...Fetchers } = Components;
+const Helpers = { operationsByPath, operationsByTag, tagDictionary };
+
+exports.Schemas = schemas.schemas;
+exports.Fetchers = Fetchers;
+exports.Helpers = Helpers;
+exports.Types = types;
+exports.VercelApi = VercelApi;