vercel-api-js 1.0.0 → 1.0.1

package/dist/generated/components.js

@@ -190,113 +190,125 @@ const fetcher_1 = __importDefault(require("../utils/fetcher.js"));
 /**
  * @description Allows to read an access group
  * @summary Reads an access group
- * {@link v1AccessGroupsIdOrName}
+ * {@link /v1/access-groups/:idOrName}
  */
-async function readAccessGroup({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function readAccessGroup({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v1AccessGroupsIdOrName`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/access-groups/${idOrName}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows to update an access group metadata
  * @summary Update an access group
- * {@link v1AccessGroupsIdOrName}
+ * {@link /v1/access-groups/:idOrName}
  */
-async function updateAccessGroup({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function updateAccessGroup({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'POST', url: `v1AccessGroupsIdOrName`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/access-groups/${idOrName}`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Allows to delete an access group
  * @summary Deletes an access group
- * {@link v1AccessGroupsIdOrName}
+ * {@link /v1/access-groups/:idOrName}
  */
-async function deleteAccessGroup({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function deleteAccessGroup({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'DELETE', url: `v1AccessGroupsIdOrName`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/access-groups/${idOrName}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description List members of an access group
  * @summary List members of an access group
- * {@link v1AccessGroupsIdOrNameMembers}
+ * {@link /v1/access-groups/:idOrName/members}
  */
-async function listAccessGroupMembers({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function listAccessGroupMembers({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v1AccessGroupsIdOrNameMembers`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/access-groups/${idOrName}/members`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description List access groups
  * @summary List access groups for a team, project or member
- * {@link v1AccessGroups}
+ * {@link /v1/access-groups}
  */
-async function listAccessGroups({ queryParams, config = {}, }) {
+async function listAccessGroups({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v1AccessGroups`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/access-groups`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows to create an access group
  * @summary Creates an access group
- * {@link v1AccessGroups}
+ * {@link /v1/access-groups}
  */
-async function createAccessGroup({ queryParams, config = {}, }) {
+async function createAccessGroup({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v1AccessGroups`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/access-groups`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description List projects of an access group
  * @summary List projects of an access group
- * {@link v1AccessGroupsIdOrNameProjects}
+ * {@link /v1/access-groups/:idOrName/projects}
  */
-async function listAccessGroupProjects({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function listAccessGroupProjects({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v1AccessGroupsIdOrNameProjects`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/access-groups/${idOrName}/projects`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows creation of an access group project
  * @summary Create an access group project
- * {@link v1AccessGroupsAccessGroupIdOrNameProjects}
+ * {@link /v1/access-groups/:accessGroupIdOrName/projects}
  */
-async function createAccessGroupProject({ pathParams: { accessGroupIdOrName }, queryParams, config = {}, }) {
+async function createAccessGroupProject({ pathParams: { accessGroupIdOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!accessGroupIdOrName) {
         throw new Error(`Missing required path parameter: accessGroupIdOrName`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1AccessGroupsAccessGroupIdOrNameProjects`,
+        url: `/v1/access-groups/${accessGroupIdOrName}/projects`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Allows reading an access group project
  * @summary Reads an access group project
- * {@link v1AccessGroupsAccessGroupIdOrNameProjectsProjectId}
+ * {@link /v1/access-groups/:accessGroupIdOrName/projects/:projectId}
  */
-async function readAccessGroupProject({ pathParams: { accessGroupIdOrName, projectId }, queryParams, config = {}, }) {
+async function readAccessGroupProject({ pathParams: { accessGroupIdOrName, projectId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!accessGroupIdOrName) {
         throw new Error(`Missing required path parameter: accessGroupIdOrName`);
@@ -304,15 +316,20 @@ async function readAccessGroupProject({ pathParams: { accessGroupIdOrName, proje
     if (!projectId) {
         throw new Error(`Missing required path parameter: projectId`);
     }
-    const data = await request({ method: 'GET', url: `v1AccessGroupsAccessGroupIdOrNameProjectsProjectId`, queryParams, ...requestConfig });
+    const data = await request({
+        method: 'GET',
+        url: `/v1/access-groups/${accessGroupIdOrName}/projects/${projectId}`,
+        queryParams,
+        ...requestConfig
+    });
     return data;
 }
 /**
  * @description Allows update of an access group project
  * @summary Update an access group project
- * {@link v1AccessGroupsAccessGroupIdOrNameProjectsProjectId}
+ * {@link /v1/access-groups/:accessGroupIdOrName/projects/:projectId}
  */
-async function updateAccessGroupProject({ pathParams: { accessGroupIdOrName, projectId }, queryParams, config = {}, }) {
+async function updateAccessGroupProject({ pathParams: { accessGroupIdOrName, projectId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!accessGroupIdOrName) {
         throw new Error(`Missing required path parameter: accessGroupIdOrName`);
@@ -322,19 +339,19 @@ async function updateAccessGroupProject({ pathParams: { accessGroupIdOrName, pro
     }
     const data = await request({
         method: 'PATCH',
-        url: `v1AccessGroupsAccessGroupIdOrNameProjectsProjectId`,
+        url: `/v1/access-groups/${accessGroupIdOrName}/projects/${projectId}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Allows deletion of an access group project
  * @summary Delete an access group project
- * {@link v1AccessGroupsAccessGroupIdOrNameProjectsProjectId}
+ * {@link /v1/access-groups/:accessGroupIdOrName/projects/:projectId}
  */
-async function deleteAccessGroupProject({ pathParams: { accessGroupIdOrName, projectId }, queryParams, config = {}, }) {
+async function deleteAccessGroupProject({ pathParams: { accessGroupIdOrName, projectId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!accessGroupIdOrName) {
         throw new Error(`Missing required path parameter: accessGroupIdOrName`);
@@ -342,115 +359,132 @@ async function deleteAccessGroupProject({ pathParams: { accessGroupIdOrName, pro
     if (!projectId) {
         throw new Error(`Missing required path parameter: projectId`);
     }
-    const data = await request({ method: 'DELETE', url: `v1AccessGroupsAccessGroupIdOrNameProjectsProjectId`, queryParams, ...requestConfig });
+    const data = await request({
+        method: 'DELETE',
+        url: `/v1/access-groups/${accessGroupIdOrName}/projects/${projectId}`,
+        queryParams,
+        ...requestConfig
+    });
     return data;
 }
 /**
  * @description Records an artifacts cache usage event. The body of this request is an array of cache usage events. The supported event types are `HIT` and `MISS`. The source is either `LOCAL` the cache event was on the users filesystem cache or `REMOTE` if the cache event is for a remote cache. When the event is a `HIT` the request also accepts a number `duration` which is the time taken to generate the artifact in the cache.
  * @summary Record an artifacts cache usage event
- * {@link v8ArtifactsEvents}
+ * {@link /v8/artifacts/events}
  */
-async function recordEvents({ queryParams, headers, config = {}, }) {
+async function recordEvents({ queryParams, headers, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     const data = await request({
         method: 'POST',
-        url: `v8ArtifactsEvents`,
+        url: `/v8/artifacts/events`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...headers, ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...headers, ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Check the status of Remote Caching for this principal. Returns a JSON-encoded status indicating if Remote Caching is enabled, disabled, or disabled due to usage limits.
  * @summary Get status of Remote Caching for this principal
- * {@link v8ArtifactsStatus}
+ * {@link /v8/artifacts/status}
  */
 async function status({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v8ArtifactsStatus`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v8/artifacts/status`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Uploads a cache artifact identified by the `hash` specified on the path. The cache artifact can then be downloaded with the provided `hash`.
  * @summary Upload a cache artifact
- * {@link v8ArtifactsHash}
+ * {@link /v8/artifacts/:hash}
  */
-async function uploadArtifact({ pathParams: { hash }, headers, queryParams, config = {}, }) {
+async function uploadArtifact({ pathParams: { hash }, headers, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!hash) {
         throw new Error(`Missing required path parameter: hash`);
     }
     const data = await request({
         method: 'PUT',
-        url: `v8ArtifactsHash`,
+        url: `/v8/artifacts/${hash}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationOctetStream', ...headers, ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationOctetStream', ...headers, ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Downloads a cache artifact indentified by its `hash` specified on the request path. The artifact is downloaded as an octet-stream. The client should verify the content-length header and response body.
  * @summary Download a cache artifact
- * {@link v8ArtifactsHash}
+ * {@link /v8/artifacts/:hash}
  */
-async function downloadArtifact({ pathParams: { hash }, queryParams, headers, config = {}, }) {
+async function downloadArtifact({ pathParams: { hash }, queryParams, headers, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!hash) {
         throw new Error(`Missing required path parameter: hash`);
     }
-    const data = await request({ method: 'GET', url: `v8ArtifactsHash`, queryParams, ...requestConfig, headers: { ...headers, ...requestConfig.headers } });
+    const data = await request({
+        method: 'GET',
+        url: `/v8/artifacts/${hash}`,
+        queryParams,
+        ...requestConfig,
+        headers: { ...headers, ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Query information about an array of artifacts.
  * @summary Query information about an artifact
- * {@link v8Artifacts}
+ * {@link /v8/artifacts}
  */
-async function artifactQuery({ queryParams, config = {}, }) {
+async function artifactQuery({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v8Artifacts`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v8/artifacts`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Creates a new check. This endpoint must be called with an OAuth2 or it will produce a 400 error.
  * @summary Creates a new Check
- * {@link v1DeploymentsDeploymentIdChecks}
+ * {@link /v1/deployments/:deploymentId/checks}
  */
-async function createCheck({ pathParams: { deploymentId }, queryParams, config = {}, }) {
+async function createCheck({ pathParams: { deploymentId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!deploymentId) {
         throw new Error(`Missing required path parameter: deploymentId`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1DeploymentsDeploymentIdChecks`,
+        url: `/v1/deployments/${deploymentId}/checks`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description List all of the checks created for a deployment.
  * @summary Retrieve a list of all checks
- * {@link v1DeploymentsDeploymentIdChecks}
+ * {@link /v1/deployments/:deploymentId/checks}
  */
-async function getAllChecks({ pathParams: { deploymentId }, queryParams, config = {}, }) {
+async function getAllChecks({ pathParams: { deploymentId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!deploymentId) {
         throw new Error(`Missing required path parameter: deploymentId`);
     }
-    const data = await request({ method: 'GET', url: `v1DeploymentsDeploymentIdChecks`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/deployments/${deploymentId}/checks`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Return a detailed response for a single check.
  * @summary Get a single check
- * {@link v1DeploymentsDeploymentIdChecksCheckId}
+ * {@link /v1/deployments/:deploymentId/checks/:checkId}
  */
-async function getCheck({ pathParams: { deploymentId, checkId }, queryParams, config = {}, }) {
+async function getCheck({ pathParams: { deploymentId, checkId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!deploymentId) {
         throw new Error(`Missing required path parameter: deploymentId`);
@@ -458,15 +492,15 @@ async function getCheck({ pathParams: { deploymentId, checkId }, queryParams, co
     if (!checkId) {
         throw new Error(`Missing required path parameter: checkId`);
     }
-    const data = await request({ method: 'GET', url: `v1DeploymentsDeploymentIdChecksCheckId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/deployments/${deploymentId}/checks/${checkId}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Update an existing check. This endpoint must be called with an OAuth2 or it will produce a 400 error.
  * @summary Update a check
- * {@link v1DeploymentsDeploymentIdChecksCheckId}
+ * {@link /v1/deployments/:deploymentId/checks/:checkId}
  */
-async function updateCheck({ pathParams: { deploymentId, checkId }, queryParams, config = {}, }) {
+async function updateCheck({ pathParams: { deploymentId, checkId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!deploymentId) {
         throw new Error(`Missing required path parameter: deploymentId`);
@@ -476,19 +510,19 @@ async function updateCheck({ pathParams: { deploymentId, checkId }, queryParams,
     }
     const data = await request({
         method: 'PATCH',
-        url: `v1DeploymentsDeploymentIdChecksCheckId`,
+        url: `/v1/deployments/${deploymentId}/checks/${checkId}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Rerequest a selected check that has failed.
  * @summary Rerequest a check
- * {@link v1DeploymentsDeploymentIdChecksCheckIdRerequest}
+ * {@link /v1/deployments/:deploymentId/checks/:checkId/rerequest}
  */
-async function rerequestCheck({ pathParams: { deploymentId, checkId }, queryParams, config = {}, }) {
+async function rerequestCheck({ pathParams: { deploymentId, checkId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!deploymentId) {
         throw new Error(`Missing required path parameter: deploymentId`);
@@ -496,63 +530,73 @@ async function rerequestCheck({ pathParams: { deploymentId, checkId }, queryPara
     if (!checkId) {
         throw new Error(`Missing required path parameter: checkId`);
     }
-    const data = await request({ method: 'POST', url: `v1DeploymentsDeploymentIdChecksCheckIdRerequest`, queryParams, ...requestConfig });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/deployments/${deploymentId}/checks/${checkId}/rerequest`,
+        queryParams,
+        ...requestConfig
+    });
     return data;
 }
 /**
- * {@link dataCachePurgeAll}
+ * {@link /data-cache/purge-all}
  */
-async function purgeAllDataCache({ queryParams, config = {}, }) {
+async function purgeAllDataCache({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'DELETE', url: `dataCachePurgeAll`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/data-cache/purge-all`, queryParams, ...requestConfig });
     return data;
 }
 /**
- * {@link dataCacheBillingSettings}
+ * {@link /data-cache/billing-settings}
  */
 async function updateDataCacheBillingSettings({ config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'PATCH', url: `dataCacheBillingSettings`, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'PATCH',
+        url: `/data-cache/billing-settings`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Update the data cache feature on a project.
  * @summary Update the data cache feature
- * {@link v1DataCacheProjectsProjectId}
+ * {@link /v1/data-cache/projects/:projectId}
  */
-async function updateProjectDataCache({ pathParams: { projectId }, queryParams, config = {}, }) {
+async function updateProjectDataCache({ pathParams: { projectId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!projectId) {
         throw new Error(`Missing required path parameter: projectId`);
     }
     const data = await request({
         method: 'PATCH',
-        url: `v1DataCacheProjectsProjectId`,
+        url: `/v1/data-cache/projects/${projectId}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Get the build logs of a deployment by deployment ID and build ID. It can work as an infinite stream of logs or as a JSON endpoint depending on the input parameters.
  * @summary Get deployment events
- * {@link v3DeploymentsIdOrUrlEvents}
+ * {@link /v3/deployments/:idOrUrl/events}
  */
-async function getDeploymentEvents({ pathParams: { idOrUrl }, queryParams, config = {}, }) {
+async function getDeploymentEvents({ pathParams: { idOrUrl }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrUrl) {
         throw new Error(`Missing required path parameter: idOrUrl`);
     }
-    const data = await request({ method: 'GET', url: `v3DeploymentsIdOrUrlEvents`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v3/deployments/${idOrUrl}/events`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Updates the deployment integration action for the specified integration installation
  * @summary Update deployment integration action
- * {@link v1DeploymentsDeploymentIdIntegrationsIntegrationConfigurationIdResourcesResourceIdActionsAction}
+ * {@link /v1/deployments/:deploymentId/integrations/:integrationConfigurationId/resources/:resourceId/actions/:action}
  */
-async function updateIntegrationDeploymentAction({ pathParams: { deploymentId, integrationConfigurationId, resourceId, action }, config = {}, }) {
+async function updateIntegrationDeploymentAction({ pathParams: { deploymentId, integrationConfigurationId, resourceId, action }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!deploymentId) {
         throw new Error(`Missing required path parameter: deploymentId`);
@@ -568,129 +612,147 @@ async function updateIntegrationDeploymentAction({ pathParams: { deploymentId, i
     }
     const data = await request({
         method: 'PATCH',
-        url: `v1DeploymentsDeploymentIdIntegrationsIntegrationConfigurationIdResourcesResourceIdActionsAction`,
+        url: `/v1/deployments/${deploymentId}/integrations/${integrationConfigurationId}/resources/${resourceId}/actions/${action}`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Retrieves information for a deployment either by supplying its ID (`id` property) or Hostname (`url` property). Additional details will be included when the authenticated user or team is an owner of the deployment.
  * @summary Get a deployment by ID or URL
- * {@link v13DeploymentsIdOrUrl}
+ * {@link /v13/deployments/:idOrUrl}
  */
-async function getDeployment({ pathParams: { idOrUrl }, queryParams, config = {}, }) {
+async function getDeployment({ pathParams: { idOrUrl }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrUrl) {
         throw new Error(`Missing required path parameter: idOrUrl`);
     }
-    const data = await request({ method: 'GET', url: `v13DeploymentsIdOrUrl`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v13/deployments/${idOrUrl}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Create a new deployment with all the required and intended data. If the deployment is not a git deployment, all files must be provided with the request, either referenced or inlined. Additionally, a deployment id can be specified to redeploy a previous deployment.
  * @summary Create a new deployment
- * {@link v13Deployments}
+ * {@link /v13/deployments}
  */
-async function createDeployment({ queryParams, config = {}, }) {
+async function createDeployment({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v13Deployments`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v13/deployments`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description This endpoint allows you to cancel a deployment which is currently building, by supplying its `id` in the URL.
  * @summary Cancel a deployment
- * {@link v12DeploymentsIdCancel}
+ * {@link /v12/deployments/:id/cancel}
  */
-async function cancelDeployment({ pathParams: { id }, queryParams, config = {}, }) {
+async function cancelDeployment({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'PATCH', url: `v12DeploymentsIdCancel`, queryParams, ...requestConfig });
+    const data = await request({ method: 'PATCH', url: `/v12/deployments/${id}/cancel`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows to purchase the specified domain.
  * @summary Purchase a domain
- * {@link v5DomainsBuy}
+ * {@link /v5/domains/buy}
  */
-async function buyDomain({ queryParams, config = {}, }) {
+async function buyDomain({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v5DomainsBuy`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v5/domains/buy`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Check the price to purchase a domain and how long a single purchase period is.
  * @summary Check the price for a domain
- * {@link v4DomainsPrice}
+ * {@link /v4/domains/price}
  */
-async function checkDomainPrice({ queryParams, config = {}, }) {
+async function checkDomainPrice({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v4DomainsPrice`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v4/domains/price`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Check if a domain name is available for purchase.
  * @summary Check a Domain Availability
- * {@link v4DomainsStatus}
+ * {@link /v4/domains/status}
  */
-async function checkDomainStatus({ queryParams, config = {}, }) {
+async function checkDomainStatus({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v4DomainsStatus`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v4/domains/status`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieves a list of DNS records created for a domain name. By default it returns 20 records if no limit is provided. The rest can be retrieved using the pagination options.
  * @summary List existing DNS records
- * {@link v4DomainsDomainRecords}
+ * {@link /v4/domains/:domain/records}
  */
-async function getRecords({ pathParams: { domain }, queryParams, config = {}, }) {
+async function getRecords({ pathParams: { domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
     }
-    const data = await request({ method: 'GET', url: `v4DomainsDomainRecords`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v4/domains/${domain}/records`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Creates a DNS record for a domain.
  * @summary Create a DNS record
- * {@link v2DomainsDomainRecords}
+ * {@link /v2/domains/:domain/records}
  */
-async function createRecord({ pathParams: { domain }, queryParams, config = {}, }) {
+async function createRecord({ pathParams: { domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
     }
-    const data = await request({ method: 'POST', url: `v2DomainsDomainRecords`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v2/domains/${domain}/records`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Updates an existing DNS record for a domain name.
  * @summary Update an existing DNS record
- * {@link v1DomainsRecordsRecordId}
+ * {@link /v1/domains/records/:recordId}
  */
-async function updateRecord({ pathParams: { recordId }, queryParams, config = {}, }) {
+async function updateRecord({ pathParams: { recordId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!recordId) {
         throw new Error(`Missing required path parameter: recordId`);
     }
     const data = await request({
         method: 'PATCH',
-        url: `v1DomainsRecordsRecordId`,
+        url: `/v1/domains/records/${recordId}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Removes an existing DNS record from a domain name.
  * @summary Delete a DNS record
- * {@link v2DomainsDomainRecordsRecordId}
+ * {@link /v2/domains/:domain/records/:recordId}
  */
-async function removeRecord({ pathParams: { domain, recordId }, queryParams, config = {}, }) {
+async function removeRecord({ pathParams: { domain, recordId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
@@ -698,236 +760,260 @@ async function removeRecord({ pathParams: { domain, recordId }, queryParams, con
     if (!recordId) {
         throw new Error(`Missing required path parameter: recordId`);
     }
-    const data = await request({ method: 'DELETE', url: `v2DomainsDomainRecordsRecordId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v2/domains/${domain}/records/${recordId}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Fetch domain transfer availability or transfer status if a transfer is in progress.
  * @summary Get domain transfer info.
- * {@link v1DomainsDomainRegistry}
+ * {@link /v1/domains/:domain/registry}
  */
-async function getDomainTransfer({ pathParams: { domain }, queryParams, config = {}, }) {
+async function getDomainTransfer({ pathParams: { domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
     }
-    const data = await request({ method: 'GET', url: `v1DomainsDomainRegistry`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/domains/${domain}/registry`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Get a Domain's configuration.
  * @summary Get a Domain's configuration
- * {@link v6DomainsDomainConfig}
+ * {@link /v6/domains/:domain/config}
  */
-async function getDomainConfig({ pathParams: { domain }, queryParams, config = {}, }) {
+async function getDomainConfig({ pathParams: { domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
     }
-    const data = await request({ method: 'GET', url: `v6DomainsDomainConfig`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v6/domains/${domain}/config`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Get information for a single domain in an account or team.
  * @summary Get Information for a Single Domain
- * {@link v5DomainsDomain}
+ * {@link /v5/domains/:domain}
  */
-async function getDomain({ pathParams: { domain }, queryParams, config = {}, }) {
+async function getDomain({ pathParams: { domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
     }
-    const data = await request({ method: 'GET', url: `v5DomainsDomain`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v5/domains/${domain}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieves a list of domains registered for the authenticated user or team. By default it returns the last 20 domains if no limit is provided.
  * @summary List all the domains
- * {@link v5Domains}
+ * {@link /v5/domains}
  */
-async function getDomains({ queryParams, config = {}, }) {
+async function getDomains({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v5Domains`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v5/domains`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description This endpoint is used for adding a new apex domain name with Vercel for the authenticating user. Can also be used for initiating a domain transfer request from an external Registrar to Vercel.
  * @summary Register or transfer-in a new Domain
- * {@link v7Domains}
+ * {@link /v7/domains}
  */
-async function createOrTransferDomain({ queryParams, config = {}, }) {
+async function createOrTransferDomain({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v7Domains`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v7/domains`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Update or move apex domain.
  * @summary Update or move apex domain
- * {@link v3DomainsDomain}
+ * {@link /v3/domains/:domain}
  */
-async function patchDomain({ pathParams: { domain }, queryParams, config = {}, }) {
+async function patchDomain({ pathParams: { domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
     }
-    const data = await request({ method: 'PATCH', url: `v3DomainsDomain`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'PATCH',
+        url: `/v3/domains/${domain}`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Delete a previously registered domain name from Vercel. Deleting a domain will automatically remove any associated aliases.
  * @summary Remove a domain by name
- * {@link v6DomainsDomain}
+ * {@link /v6/domains/:domain}
  */
-async function deleteDomain({ pathParams: { domain }, queryParams, config = {}, }) {
+async function deleteDomain({ pathParams: { domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
     }
-    const data = await request({ method: 'DELETE', url: `v6DomainsDomain`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v6/domains/${domain}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Returns all Edge Configs.
  * @summary Get Edge Configs
- * {@link v1EdgeConfig}
+ * {@link /v1/edge-config}
  */
-async function getEdgeConfigs({ queryParams, config = {}, }) {
+async function getEdgeConfigs({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v1EdgeConfig`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/edge-config`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Creates an Edge Config.
  * @summary Create an Edge Config
- * {@link v1EdgeConfig}
+ * {@link /v1/edge-config}
  */
-async function createEdgeConfig({ queryParams, config = {}, }) {
+async function createEdgeConfig({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v1EdgeConfig`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/edge-config`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Returns an Edge Config.
  * @summary Get an Edge Config
- * {@link v1EdgeConfigEdgeConfigId}
+ * {@link /v1/edge-config/:edgeConfigId}
  */
-async function getEdgeConfig({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function getEdgeConfig({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
-    const data = await request({ method: 'GET', url: `v1EdgeConfigEdgeConfigId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/edge-config/${edgeConfigId}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Updates an Edge Config.
  * @summary Update an Edge Config
- * {@link v1EdgeConfigEdgeConfigId}
+ * {@link /v1/edge-config/:edgeConfigId}
  */
-async function updateEdgeConfig({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function updateEdgeConfig({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
-    const data = await request({ method: 'PUT', url: `v1EdgeConfigEdgeConfigId`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'PUT',
+        url: `/v1/edge-config/${edgeConfigId}`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Delete an Edge Config by id.
  * @summary Delete an Edge Config
- * {@link v1EdgeConfigEdgeConfigId}
+ * {@link /v1/edge-config/:edgeConfigId}
  */
-async function deleteEdgeConfig({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function deleteEdgeConfig({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
-    const data = await request({ method: 'DELETE', url: `v1EdgeConfigEdgeConfigId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/edge-config/${edgeConfigId}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Returns all items of an Edge Config.
  * @summary Get Edge Config items
- * {@link v1EdgeConfigEdgeConfigIdItems}
+ * {@link /v1/edge-config/:edgeConfigId/items}
  */
-async function getEdgeConfigItems({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function getEdgeConfigItems({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
-    const data = await request({ method: 'GET', url: `v1EdgeConfigEdgeConfigIdItems`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/edge-config/${edgeConfigId}/items`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Update multiple Edge Config Items in batch.
  * @summary Update Edge Config items in batch
- * {@link v1EdgeConfigEdgeConfigIdItems}
+ * {@link /v1/edge-config/:edgeConfigId/items}
  */
-async function patchEdgeConfigItems({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function patchEdgeConfigItems({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
     const data = await request({
         method: 'PATCH',
-        url: `v1EdgeConfigEdgeConfigIdItems`,
+        url: `/v1/edge-config/${edgeConfigId}/items`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Returns the schema of an Edge Config.
  * @summary Get Edge Config schema
- * {@link v1EdgeConfigEdgeConfigIdSchema}
+ * {@link /v1/edge-config/:edgeConfigId/schema}
  */
-async function getEdgeConfigSchema({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function getEdgeConfigSchema({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
-    const data = await request({ method: 'GET', url: `v1EdgeConfigEdgeConfigIdSchema`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/edge-config/${edgeConfigId}/schema`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Update an Edge Config's schema.
  * @summary Update Edge Config schema
- * {@link v1EdgeConfigEdgeConfigIdSchema}
+ * {@link /v1/edge-config/:edgeConfigId/schema}
  */
-async function patchEdgeConfigSchema({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function patchEdgeConfigSchema({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1EdgeConfigEdgeConfigIdSchema`,
+        url: `/v1/edge-config/${edgeConfigId}/schema`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Deletes the schema of existing Edge Config.
  * @summary Delete an Edge Config's schema
- * {@link v1EdgeConfigEdgeConfigIdSchema}
+ * {@link /v1/edge-config/:edgeConfigId/schema}
  */
-async function deleteEdgeConfigSchema({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function deleteEdgeConfigSchema({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
-    const data = await request({ method: 'DELETE', url: `v1EdgeConfigEdgeConfigIdSchema`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/edge-config/${edgeConfigId}/schema`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Returns a specific Edge Config Item.
  * @summary Get an Edge Config item
- * {@link v1EdgeConfigEdgeConfigIdItemEdgeConfigItemKey}
+ * {@link /v1/edge-config/:edgeConfigId/item/:edgeConfigItemKey}
  */
-async function getEdgeConfigItem({ pathParams: { edgeConfigId, edgeConfigItemKey }, queryParams, config = {}, }) {
+async function getEdgeConfigItem({ pathParams: { edgeConfigId, edgeConfigItemKey }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
@@ -935,47 +1021,47 @@ async function getEdgeConfigItem({ pathParams: { edgeConfigId, edgeConfigItemKey
     if (!edgeConfigItemKey) {
         throw new Error(`Missing required path parameter: edgeConfigItemKey`);
     }
-    const data = await request({ method: 'GET', url: `v1EdgeConfigEdgeConfigIdItemEdgeConfigItemKey`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/edge-config/${edgeConfigId}/item/${edgeConfigItemKey}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Returns all tokens of an Edge Config.
  * @summary Get all tokens of an Edge Config
- * {@link v1EdgeConfigEdgeConfigIdTokens}
+ * {@link /v1/edge-config/:edgeConfigId/tokens}
  */
-async function getEdgeConfigTokens({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function getEdgeConfigTokens({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
-    const data = await request({ method: 'GET', url: `v1EdgeConfigEdgeConfigIdTokens`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/edge-config/${edgeConfigId}/tokens`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Deletes one or more tokens of an existing Edge Config.
  * @summary Delete one or more Edge Config tokens
- * {@link v1EdgeConfigEdgeConfigIdTokens}
+ * {@link /v1/edge-config/:edgeConfigId/tokens}
  */
-async function deleteEdgeConfigTokens({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function deleteEdgeConfigTokens({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
     const data = await request({
         method: 'DELETE',
-        url: `v1EdgeConfigEdgeConfigIdTokens`,
+        url: `/v1/edge-config/${edgeConfigId}/tokens`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Return meta data about an Edge Config token.
  * @summary Get Edge Config token meta data
- * {@link v1EdgeConfigEdgeConfigIdTokenToken}
+ * {@link /v1/edge-config/:edgeConfigId/token/:token}
  */
-async function getEdgeConfigToken({ pathParams: { edgeConfigId, token }, queryParams, config = {}, }) {
+async function getEdgeConfigToken({ pathParams: { edgeConfigId, token }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
@@ -983,34 +1069,34 @@ async function getEdgeConfigToken({ pathParams: { edgeConfigId, token }, queryPa
     if (!token) {
         throw new Error(`Missing required path parameter: token`);
     }
-    const data = await request({ method: 'GET', url: `v1EdgeConfigEdgeConfigIdTokenToken`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/edge-config/${edgeConfigId}/token/${token}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Adds a token to an existing Edge Config.
  * @summary Create an Edge Config token
- * {@link v1EdgeConfigEdgeConfigIdToken}
+ * {@link /v1/edge-config/:edgeConfigId/token}
  */
-async function createEdgeConfigToken({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function createEdgeConfigToken({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1EdgeConfigEdgeConfigIdToken`,
+        url: `/v1/edge-config/${edgeConfigId}/token`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Retrieves a specific version of an Edge Config from backup storage.
  * @summary Get Edge Config backup
- * {@link v1EdgeConfigEdgeConfigIdBackupsEdgeConfigBackupVersionId}
+ * {@link /v1/edge-config/:edgeConfigId/backups/:edgeConfigBackupVersionId}
  */
-async function getEdgeConfigBackup({ pathParams: { edgeConfigId, edgeConfigBackupVersionId }, queryParams, config = {}, }) {
+async function getEdgeConfigBackup({ pathParams: { edgeConfigId, edgeConfigBackupVersionId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
@@ -1018,51 +1104,56 @@ async function getEdgeConfigBackup({ pathParams: { edgeConfigId, edgeConfigBacku
     if (!edgeConfigBackupVersionId) {
         throw new Error(`Missing required path parameter: edgeConfigBackupVersionId`);
     }
-    const data = await request({ method: 'GET', url: `v1EdgeConfigEdgeConfigIdBackupsEdgeConfigBackupVersionId`, queryParams, ...requestConfig });
+    const data = await request({
+        method: 'GET',
+        url: `/v1/edge-config/${edgeConfigId}/backups/${edgeConfigBackupVersionId}`,
+        queryParams,
+        ...requestConfig
+    });
     return data;
 }
 /**
  * @description Returns backups of an Edge Config.
  * @summary Get Edge Config backups
- * {@link v1EdgeConfigEdgeConfigIdBackups}
+ * {@link /v1/edge-config/:edgeConfigId/backups}
  */
-async function getEdgeConfigBackups({ pathParams: { edgeConfigId }, queryParams, config = {}, }) {
+async function getEdgeConfigBackups({ pathParams: { edgeConfigId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!edgeConfigId) {
         throw new Error(`Missing required path parameter: edgeConfigId`);
     }
-    const data = await request({ method: 'GET', url: `v1EdgeConfigEdgeConfigIdBackups`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/edge-config/${edgeConfigId}/backups`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieves a list of "events" generated by the User on Vercel. Events are generated when the User performs a particular action, such as logging in, creating a deployment, and joining a Team (just to name a few). When the `teamId` parameter is supplied, then the events that are returned will be in relation to the Team that was specified.
  * @summary List User Events
- * {@link v3Events}
+ * {@link /v3/events}
  */
-async function listUserEvents({ queryParams, config = {}, }) {
+async function listUserEvents({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v3Events`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v3/events`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Fetches the best account or user’s contact info
  * @summary Get Account Information
- * {@link v1InstallationsIntegrationConfigurationIdAccount}
+ * {@link /v1/installations/:integrationConfigurationId/account}
  */
-async function getAccountInfo({ pathParams: { integrationConfigurationId }, config = {}, }) {
+async function getAccountInfo({ pathParams: { integrationConfigurationId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
     }
-    const data = await request({ method: 'GET', url: `v1InstallationsIntegrationConfigurationIdAccount`, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/installations/${integrationConfigurationId}/account`, ...requestConfig });
     return data;
 }
 /**
  * @description Returns the member role and other information for a given member ID ("user_id" claim in the SSO OIDC token).
  * @summary Get Member Information
- * {@link v1InstallationsIntegrationConfigurationIdMemberMemberId}
+ * {@link /v1/installations/:integrationConfigurationId/member/:memberId}
  */
-async function getMember({ pathParams: { integrationConfigurationId, memberId }, config = {}, }) {
+async function getMember({ pathParams: { integrationConfigurationId, memberId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1070,46 +1161,46 @@ async function getMember({ pathParams: { integrationConfigurationId, memberId },
     if (!memberId) {
         throw new Error(`Missing required path parameter: memberId`);
     }
-    const data = await request({ method: 'GET', url: `v1InstallationsIntegrationConfigurationIdMemberMemberId`, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/installations/${integrationConfigurationId}/member/${memberId}`, ...requestConfig });
     return data;
 }
 /**
  * @description Partner notifies Vercel of any changes made to an Installation or a Resource. Vercel is expected to use `list-resources` and other read APIs to get the new state.<br/> <br/> `resource.updated` event should be dispatched when any state of a resource linked to Vercel is modified by the partner.<br/> `installation.updated` event should be dispatched when an installation's billing plan is changed via the provider instead of Vercel.<br/> <br/> Resource update use cases: <br/> <br/> - The user renames a database in the partner’s application. The partner should dispatch a `resource.updated` event to notify Vercel to update the resource in Vercel’s datastores.<br/> - A resource has been suspended due to a lack of use. The partner should dispatch a `resource.updated` event to notify Vercel to update the resource's status in Vercel's datastores.<br/>
  * @summary Create Event
- * {@link v1InstallationsIntegrationConfigurationIdEvents}
+ * {@link /v1/installations/:integrationConfigurationId/events}
  */
-async function createEvent({ pathParams: { integrationConfigurationId }, config = {}, }) {
+async function createEvent({ pathParams: { integrationConfigurationId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1InstallationsIntegrationConfigurationIdEvents`,
+        url: `/v1/installations/${integrationConfigurationId}/events`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Get all resources for a given installation ID.
  * @summary Get Integration Resources
- * {@link v1InstallationsIntegrationConfigurationIdResources}
+ * {@link /v1/installations/:integrationConfigurationId/resources}
  */
-async function getIntegrationResources({ pathParams: { integrationConfigurationId }, config = {}, }) {
+async function getIntegrationResources({ pathParams: { integrationConfigurationId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
     }
-    const data = await request({ method: 'GET', url: `v1InstallationsIntegrationConfigurationIdResources`, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/installations/${integrationConfigurationId}/resources`, ...requestConfig });
     return data;
 }
 /**
  * @description Get a resource by its partner ID.
  * @summary Get Integration Resource
- * {@link v1InstallationsIntegrationConfigurationIdResourcesResourceId}
+ * {@link /v1/installations/:integrationConfigurationId/resources/:resourceId}
  */
-async function getIntegrationResource({ pathParams: { integrationConfigurationId, resourceId }, config = {}, }) {
+async function getIntegrationResource({ pathParams: { integrationConfigurationId, resourceId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1117,15 +1208,19 @@ async function getIntegrationResource({ pathParams: { integrationConfigurationId
     if (!resourceId) {
         throw new Error(`Missing required path parameter: resourceId`);
     }
-    const data = await request({ method: 'GET', url: `v1InstallationsIntegrationConfigurationIdResourcesResourceId`, ...requestConfig });
+    const data = await request({
+        method: 'GET',
+        url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}`,
+        ...requestConfig
+    });
     return data;
 }
 /**
  * @description Delete a resource owned by the selected installation ID.
  * @summary Delete Integration Resource
- * {@link v1InstallationsIntegrationConfigurationIdResourcesResourceId}
+ * {@link /v1/installations/:integrationConfigurationId/resources/:resourceId}
  */
-async function deleteIntegrationResource({ pathParams: { integrationConfigurationId, resourceId }, config = {}, }) {
+async function deleteIntegrationResource({ pathParams: { integrationConfigurationId, resourceId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1133,15 +1228,19 @@ async function deleteIntegrationResource({ pathParams: { integrationConfiguratio
     if (!resourceId) {
         throw new Error(`Missing required path parameter: resourceId`);
     }
-    const data = await request({ method: 'DELETE', url: `v1InstallationsIntegrationConfigurationIdResourcesResourceId`, ...requestConfig });
+    const data = await request({
+        method: 'DELETE',
+        url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}`,
+        ...requestConfig
+    });
     return data;
 }
 /**
  * @description This endpoint imports (upserts) a resource to Vercel's installation. This may be needed if resources can be independently created on the partner's side and need to be synchronized to Vercel.
  * @summary Import Resource
- * {@link v1InstallationsIntegrationConfigurationIdResourcesResourceId}
+ * {@link /v1/installations/:integrationConfigurationId/resources/:resourceId}
  */
-async function importResource({ pathParams: { integrationConfigurationId, resourceId }, config = {}, }) {
+async function importResource({ pathParams: { integrationConfigurationId, resourceId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1151,54 +1250,54 @@ async function importResource({ pathParams: { integrationConfigurationId, resour
     }
     const data = await request({
         method: 'PUT',
-        url: `v1InstallationsIntegrationConfigurationIdResourcesResourceId`,
+        url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Sends the billing and usage data. The partner should do this at least once a day and ideally once per hour. <br/> Use the `credentials.access_token` we provided in the [Upsert Installation](#upsert-installation) body to authorize this request.
  * @summary Submit Billing Data
- * {@link v1InstallationsIntegrationConfigurationIdBilling}
+ * {@link /v1/installations/:integrationConfigurationId/billing}
  */
-async function submitBillingData({ pathParams: { integrationConfigurationId }, config = {}, }) {
+async function submitBillingData({ pathParams: { integrationConfigurationId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1InstallationsIntegrationConfigurationIdBilling`,
+        url: `/v1/installations/${integrationConfigurationId}/billing`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description This endpoint allows the partner to submit an invoice to Vercel. The invoice is created in Vercel's billing system and sent to the customer. Depending on the type of billing plan, the invoice can be sent at a time of signup, at the start of the billing period, or at the end of the billing period.<br/> <br/> Use the `credentials.access_token` we provided in the [Upsert Installation](#upsert-installation) body to authorize this request. <br/> There are several limitations to the invoice submission:<br/> <br/> 1. A resource can only be billed once per the billing period and the billing plan.<br/> 2. The billing plan used to bill the resource must have been active for this resource during the billing period.<br/> 3. The billing plan used must be a subscription plan.<br/> 4. The interim usage data must be sent hourly for all types of subscriptions. See [Send subscription billing and usage data](#send-subscription-billing-and-usage-data) API on how to send interim billing and usage data.<br/>
  * @summary Submit Invoice
- * {@link v1InstallationsIntegrationConfigurationIdBillingInvoices}
+ * {@link /v1/installations/:integrationConfigurationId/billing/invoices}
  */
-async function submitInvoice({ pathParams: { integrationConfigurationId }, config = {}, }) {
+async function submitInvoice({ pathParams: { integrationConfigurationId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1InstallationsIntegrationConfigurationIdBillingInvoices`,
+        url: `/v1/installations/${integrationConfigurationId}/billing/invoices`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Get Invoice details and status for a given invoice ID.<br/> <br/> See Billing Events with Webhooks documentation on how to receive invoice events. This endpoint is used to retrieve the invoice details.
  * @summary Get Invoice
- * {@link v1InstallationsIntegrationConfigurationIdBillingInvoicesInvoiceId}
+ * {@link /v1/installations/:integrationConfigurationId/billing/invoices/:invoiceId}
  */
-async function getInvoice({ pathParams: { integrationConfigurationId, invoiceId }, config = {}, }) {
+async function getInvoice({ pathParams: { integrationConfigurationId, invoiceId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1206,15 +1305,19 @@ async function getInvoice({ pathParams: { integrationConfigurationId, invoiceId
     if (!invoiceId) {
         throw new Error(`Missing required path parameter: invoiceId`);
     }
-    const data = await request({ method: 'GET', url: `v1InstallationsIntegrationConfigurationIdBillingInvoicesInvoiceId`, ...requestConfig });
+    const data = await request({
+        method: 'GET',
+        url: `/v1/installations/${integrationConfigurationId}/billing/invoices/${invoiceId}`,
+        ...requestConfig
+    });
     return data;
 }
 /**
  * @description This endpoint allows the partner to request a refund for an invoice to Vercel. The invoice is created using the [Submit Invoice API](#submit-invoice-api).
  * @summary Invoice Actions
- * {@link v1InstallationsIntegrationConfigurationIdBillingInvoicesInvoiceIdActions}
+ * {@link /v1/installations/:integrationConfigurationId/billing/invoices/:invoiceId/actions}
  */
-async function updateInvoice({ pathParams: { integrationConfigurationId, invoiceId }, config = {}, }) {
+async function updateInvoice({ pathParams: { integrationConfigurationId, invoiceId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1224,36 +1327,36 @@ async function updateInvoice({ pathParams: { integrationConfigurationId, invoice
     }
     const data = await request({
         method: 'POST',
-        url: `v1InstallationsIntegrationConfigurationIdBillingInvoicesInvoiceIdActions`,
+        url: `/v1/installations/${integrationConfigurationId}/billing/invoices/${invoiceId}/actions`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Sends the prepayment balances. The partner should do this at least once a day and ideally once per hour. <br/> Use the `credentials.access_token` we provided in the [Upsert Installation](#upsert-installation) body to authorize this request.
  * @summary Submit Prepayment Balances
- * {@link v1InstallationsIntegrationConfigurationIdBillingBalance}
+ * {@link /v1/installations/:integrationConfigurationId/billing/balance}
  */
-async function submitPrepaymentBalances({ pathParams: { integrationConfigurationId }, config = {}, }) {
+async function submitPrepaymentBalances({ pathParams: { integrationConfigurationId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1InstallationsIntegrationConfigurationIdBillingBalance`,
+        url: `/v1/installations/${integrationConfigurationId}/billing/balance`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description This endpoint is deprecated and replaced with the endpoint [Update Resource Secrets](#update-resource-secrets). <br/> This endpoint updates the secrets of a resource. If a resource has projects connected, the connected secrets are updated with the new secrets. The old secrets may still be used by existing connected projects because they are not automatically redeployed. Redeployment is a manual action and must be completed by the user. All new project connections will use the new secrets.<br/> <br/> Use cases for this endpoint:<br/> <br/> - Resetting the credentials of a database in the partner. If the user requests the credentials to be updated in the partner’s application, the partner post the new set of secrets to Vercel, the user should redeploy their application and the expire the old credentials.<br/>
  * @summary Update Resource Secrets (Deprecated)
- * {@link v1InstallationsIntegrationConfigurationIdProductsIntegrationProductIdOrSlugResourcesResourceIdSecrets}
+ * {@link /v1/installations/:integrationConfigurationId/products/:integrationProductIdOrSlug/resources/:resourceId/secrets}
  */
-async function updateResourceSecrets({ pathParams: { integrationConfigurationId, integrationProductIdOrSlug, resourceId }, config = {}, }) {
+async function updateResourceSecrets({ pathParams: { integrationConfigurationId, integrationProductIdOrSlug, resourceId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1266,18 +1369,18 @@ async function updateResourceSecrets({ pathParams: { integrationConfigurationId,
     }
     const data = await request({
         method: 'PUT',
-        url: `v1InstallationsIntegrationConfigurationIdProductsIntegrationProductIdOrSlugResourcesResourceIdSecrets`,
+        url: `/v1/installations/${integrationConfigurationId}/products/${integrationProductIdOrSlug}/resources/${resourceId}/secrets`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description This endpoint updates the secrets of a resource. If a resource has projects connected, the connected secrets are updated with the new secrets. The old secrets may still be used by existing connected projects because they are not automatically redeployed. Redeployment is a manual action and must be completed by the user. All new project connections will use the new secrets.<br/> <br/> Use cases for this endpoint:<br/> <br/> - Resetting the credentials of a database in the partner. If the user requests the credentials to be updated in the partner’s application, the partner post the new set of secrets to Vercel, the user should redeploy their application and the expire the old credentials.<br/>
  * @summary Update Resource Secrets
- * {@link v1InstallationsIntegrationConfigurationIdResourcesResourceIdSecrets}
+ * {@link /v1/installations/:integrationConfigurationId/resources/:resourceId/secrets}
  */
-async function updateResourceSecretsById({ pathParams: { integrationConfigurationId, resourceId }, config = {}, }) {
+async function updateResourceSecretsById({ pathParams: { integrationConfigurationId, resourceId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1287,97 +1390,108 @@ async function updateResourceSecretsById({ pathParams: { integrationConfiguratio
     }
     const data = await request({
         method: 'PUT',
-        url: `v1InstallationsIntegrationConfigurationIdResourcesResourceIdSecrets`,
+        url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/secrets`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Allows to retrieve all configurations for an authenticated integration. When the `project` view is used, configurations generated for the authorization flow will be filtered out of the results.
  * @summary Get configurations for the authenticated user or team
- * {@link v1IntegrationsConfigurations}
+ * {@link /v1/integrations/configurations}
  */
-async function getConfigurations({ queryParams, config = {}, }) {
+async function getConfigurations({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v1IntegrationsConfigurations`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/integrations/configurations`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows to retrieve a the configuration with the provided id in case it exists. The authenticated user or team must be the owner of the config in order to access it.
  * @summary Retrieve an integration configuration
- * {@link v1IntegrationsConfigurationId}
+ * {@link /v1/integrations/configuration/:id}
  */
-async function getConfiguration({ pathParams: { id }, queryParams, config = {}, }) {
+async function getConfiguration({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'GET', url: `v1IntegrationsConfigurationId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/integrations/configuration/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows to remove the configuration with the `id` provided in the parameters. The configuration and all of its resources will be removed. This includes Webhooks, LogDrains and Project Env variables.
  * @summary Delete an integration configuration
- * {@link v1IntegrationsConfigurationId}
+ * {@link /v1/integrations/configuration/:id}
  */
-async function deleteConfiguration({ pathParams: { id }, queryParams, config = {}, }) {
+async function deleteConfiguration({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'DELETE', url: `v1IntegrationsConfigurationId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/integrations/configuration/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description During the autorization process, Vercel sends the user to the provider [redirectLoginUrl](https://vercel.com/docs/integrations/create-integration/submit-integration#redirect-login-url), that includes the OAuth authorization `code` parameter. The provider then calls the SSO Token Exchange endpoint with the sent code and receives the OIDC token. They log the user in based on this token and redirects the user back to the Vercel account using deep-link parameters included the redirectLoginUrl. Providers should not persist the returned `id_token` in a database since the token will expire. See [**Authentication with SSO**](https://vercel.com/docs/integrations/create-integration/marketplace-api#authentication-with-sso) for more details.
  * @summary SSO Token Exchange
- * {@link v1IntegrationsSsoToken}
+ * {@link /v1/integrations/sso/token}
  */
 async function exchangeSsoToken({ config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v1IntegrationsSsoToken`, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/integrations/sso/token`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Retrieves a list of all Integration log drains that are defined for the authenticated user or team. When using an OAuth2 token, the list is limited to log drains created by the authenticated integration.
  * @summary Retrieves a list of Integration log drains
- * {@link v2IntegrationsLogDrains}
+ * {@link /v2/integrations/log-drains}
  */
-async function getIntegrationLogDrains({ queryParams, config = {}, }) {
+async function getIntegrationLogDrains({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v2IntegrationsLogDrains`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v2/integrations/log-drains`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Creates an Integration log drain. This endpoint must be called with an OAuth2 client (integration), since log drains are tied to integrations. If it is called with a different token type it will produce a 400 error.
  * @summary Creates a new Integration Log Drain
- * {@link v2IntegrationsLogDrains}
+ * {@link /v2/integrations/log-drains}
  */
-async function createLogDrain({ queryParams, config = {}, }) {
+async function createLogDrain({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v2IntegrationsLogDrains`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v2/integrations/log-drains`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Deletes the Integration log drain with the provided `id`. When using an OAuth2 Token, the log drain can be deleted only if the integration owns it.
  * @summary Deletes the Integration log drain with the provided `id`
- * {@link v1IntegrationsLogDrainsId}
+ * {@link /v1/integrations/log-drains/:id}
  */
-async function deleteIntegrationLogDrain({ pathParams: { id }, queryParams, config = {}, }) {
+async function deleteIntegrationLogDrain({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'DELETE', url: `v1IntegrationsLogDrainsId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/integrations/log-drains/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Returns a stream of logs for a given deployment.
  * @summary Get logs for a deployment
- * {@link v1ProjectsProjectIdDeploymentsDeploymentIdRuntimeLogs}
+ * {@link /v1/projects/:projectId/deployments/:deploymentId/runtime-logs}
  */
-async function getRuntimeLogs({ pathParams: { projectId, deploymentId }, queryParams, config = {}, }) {
+async function getRuntimeLogs({ pathParams: { projectId, deploymentId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!projectId) {
         throw new Error(`Missing required path parameter: projectId`);
@@ -1385,15 +1499,20 @@ async function getRuntimeLogs({ pathParams: { projectId, deploymentId }, queryPa
     if (!deploymentId) {
         throw new Error(`Missing required path parameter: deploymentId`);
     }
-    const data = await request({ method: 'GET', url: `v1ProjectsProjectIdDeploymentsDeploymentIdRuntimeLogs`, queryParams, ...requestConfig });
+    const data = await request({
+        method: 'GET',
+        url: `/v1/projects/${projectId}/deployments/${deploymentId}/runtime-logs`,
+        queryParams,
+        ...requestConfig
+    });
     return data;
 }
 /**
  * @description Create one or multiple experimentation items
  * @summary Create one or multiple experimentation items
- * {@link v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationItems}
+ * {@link /v1/installations/:integrationConfigurationId/resources/:resourceId/experimentation/items}
  */
-async function createExperimentationItem({ pathParams: { integrationConfigurationId, resourceId }, config = {}, }) {
+async function createExperimentationItem({ pathParams: { integrationConfigurationId, resourceId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1403,18 +1522,18 @@ async function createExperimentationItem({ pathParams: { integrationConfiguratio
     }
     const data = await request({
         method: 'POST',
-        url: `v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationItems`,
+        url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/experimentation/items`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Patch an existing experimentation item
  * @summary Patch an existing experimentation item
- * {@link v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationItemsItemId}
+ * {@link /v1/installations/:integrationConfigurationId/resources/:resourceId/experimentation/items/:itemId}
  */
-async function updateExperimentationItem({ pathParams: { integrationConfigurationId, resourceId, itemId }, config = {}, }) {
+async function updateExperimentationItem({ pathParams: { integrationConfigurationId, resourceId, itemId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1427,18 +1546,18 @@ async function updateExperimentationItem({ pathParams: { integrationConfiguratio
     }
     const data = await request({
         method: 'PATCH',
-        url: `v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationItemsItemId`,
+        url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/experimentation/items/${itemId}`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Delete an existing experimentation item
  * @summary Delete an existing experimentation item
- * {@link v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationItemsItemId}
+ * {@link /v1/installations/:integrationConfigurationId/resources/:resourceId/experimentation/items/:itemId}
  */
-async function deleteExperimentationItem({ pathParams: { integrationConfigurationId, resourceId, itemId }, config = {}, }) {
+async function deleteExperimentationItem({ pathParams: { integrationConfigurationId, resourceId, itemId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1449,15 +1568,19 @@ async function deleteExperimentationItem({ pathParams: { integrationConfiguratio
     if (!itemId) {
         throw new Error(`Missing required path parameter: itemId`);
     }
-    const data = await request({ method: 'DELETE', url: `v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationItemsItemId`, ...requestConfig });
+    const data = await request({
+        method: 'DELETE',
+        url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/experimentation/items/${itemId}`,
+        ...requestConfig
+    });
     return data;
 }
 /**
  * @description When the user enabled Edge Config syncing, then this endpoint can be used by the partner to push their configuration data into the relevant Edge Config.
  * @summary Push data into a user-provided Edge Config
- * {@link v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationEdgeConfig}
+ * {@link /v1/installations/:integrationConfigurationId/resources/:resourceId/experimentation/edge-config}
  */
-async function updateExperimentationEdgeConfig({ pathParams: { integrationConfigurationId, resourceId }, config = {}, }) {
+async function updateExperimentationEdgeConfig({ pathParams: { integrationConfigurationId, resourceId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!integrationConfigurationId) {
         throw new Error(`Missing required path parameter: integrationConfigurationId`);
@@ -1467,50 +1590,50 @@ async function updateExperimentationEdgeConfig({ pathParams: { integrationConfig
     }
     const data = await request({
         method: 'PUT',
-        url: `v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationEdgeConfig`,
+        url: `/v1/installations/${integrationConfigurationId}/resources/${resourceId}/experimentation/edge-config`,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Lists all members of a project.
  * @summary List project members
- * {@link v1ProjectsIdOrNameMembers}
+ * {@link /v1/projects/:idOrName/members}
  */
-async function getProjectMembers({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function getProjectMembers({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v1ProjectsIdOrNameMembers`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/projects/${idOrName}/members`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Adds a new member to the project.
  * @summary Adds a new member to a project.
- * {@link v1ProjectsIdOrNameMembers}
+ * {@link /v1/projects/:idOrName/members}
  */
-async function addProjectMember({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function addProjectMember({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1ProjectsIdOrNameMembers`,
+        url: `/v1/projects/${idOrName}/members`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Remove a member from a specific project
  * @summary Remove a Project Member
- * {@link v1ProjectsIdOrNameMembersUid}
+ * {@link /v1/projects/:idOrName/members/:uid}
  */
-async function removeProjectMember({ pathParams: { idOrName, uid }, queryParams, config = {}, }) {
+async function removeProjectMember({ pathParams: { idOrName, uid }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1518,106 +1641,118 @@ async function removeProjectMember({ pathParams: { idOrName, uid }, queryParams,
     if (!uid) {
         throw new Error(`Missing required path parameter: uid`);
     }
-    const data = await request({ method: 'DELETE', url: `v1ProjectsIdOrNameMembersUid`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/projects/${idOrName}/members/${uid}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows to retrieve the list of projects of the authenticated user or team. The list will be paginated and the provided query parameters allow filtering the returned projects.
  * @summary Retrieve a list of projects
- * {@link v10Projects}
+ * {@link /v10/projects}
  */
-async function getProjects({ queryParams, config = {}, }) {
+async function getProjects({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v10Projects`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v10/projects`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows to create a new project with the provided configuration. It only requires the project `name` but more configuration can be provided to override the defaults.
  * @summary Create a new project
- * {@link v11Projects}
+ * {@link /v11/projects}
  */
-async function createProject({ queryParams, config = {}, }) {
+async function createProject({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v11Projects`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v11/projects`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Get the information for a specific project by passing either the project `id` or `name` in the URL.
  * @summary Find a project by id or name
- * {@link v9ProjectsIdOrName}
+ * {@link /v9/projects/:idOrName}
  */
-async function getProject({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function getProject({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v9ProjectsIdOrName`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v9/projects/${idOrName}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Update the fields of a project using either its `name` or `id`.
  * @summary Update an existing project
- * {@link v9ProjectsIdOrName}
+ * {@link /v9/projects/:idOrName}
  */
-async function updateProject({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function updateProject({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'PATCH', url: `v9ProjectsIdOrName`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'PATCH',
+        url: `/v9/projects/${idOrName}`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Delete a specific project by passing either the project `id` or `name` in the URL.
  * @summary Delete a Project
- * {@link v9ProjectsIdOrName}
+ * {@link /v9/projects/:idOrName}
  */
-async function deleteProject({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function deleteProject({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'DELETE', url: `v9ProjectsIdOrName`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v9/projects/${idOrName}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Creates a custom environment for the current project. Cannot be named 'Production' or 'Preview'.
  * @summary Create a custom environment for the current project.
- * {@link v9ProjectsIdOrNameCustomEnvironments}
+ * {@link /v9/projects/:idOrName/custom-environments}
  */
-async function createCustomEnvironment({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function createCustomEnvironment({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
     const data = await request({
         method: 'POST',
-        url: `v9ProjectsIdOrNameCustomEnvironments`,
+        url: `/v9/projects/${idOrName}/custom-environments`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Retrieve custom environments for the project. Must not be named 'Production' or 'Preview'.
  * @summary Retrieve custom environments
- * {@link v9ProjectsIdOrNameCustomEnvironments}
+ * {@link /v9/projects/:idOrName/custom-environments}
  */
-async function listCustomEnvironments({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function listCustomEnvironments({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v9ProjectsIdOrNameCustomEnvironments`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v9/projects/${idOrName}/custom-environments`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieve a custom environment for the project. Must not be named 'Production' or 'Preview'.
  * @summary Retrieve a custom environment
- * {@link v9ProjectsIdOrNameCustomEnvironmentsEnvironmentSlugOrId}
+ * {@link /v9/projects/:idOrName/custom-environments/:environmentSlugOrId}
  */
-async function getCustomEnvironment({ pathParams: { idOrName, environmentSlugOrId }, queryParams, config = {}, }) {
+async function getCustomEnvironment({ pathParams: { idOrName, environmentSlugOrId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1625,15 +1760,20 @@ async function getCustomEnvironment({ pathParams: { idOrName, environmentSlugOrI
     if (!environmentSlugOrId) {
         throw new Error(`Missing required path parameter: environmentSlugOrId`);
     }
-    const data = await request({ method: 'GET', url: `v9ProjectsIdOrNameCustomEnvironmentsEnvironmentSlugOrId`, queryParams, ...requestConfig });
+    const data = await request({
+        method: 'GET',
+        url: `/v9/projects/${idOrName}/custom-environments/${environmentSlugOrId}`,
+        queryParams,
+        ...requestConfig
+    });
     return data;
 }
 /**
  * @description Update a custom environment for the project. Must not be named 'Production' or 'Preview'.
  * @summary Update a custom environment
- * {@link v9ProjectsIdOrNameCustomEnvironmentsEnvironmentSlugOrId}
+ * {@link /v9/projects/:idOrName/custom-environments/:environmentSlugOrId}
  */
-async function updateCustomEnvironment({ pathParams: { idOrName, environmentSlugOrId }, queryParams, config = {}, }) {
+async function updateCustomEnvironment({ pathParams: { idOrName, environmentSlugOrId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1643,19 +1783,19 @@ async function updateCustomEnvironment({ pathParams: { idOrName, environmentSlug
     }
     const data = await request({
         method: 'PATCH',
-        url: `v9ProjectsIdOrNameCustomEnvironmentsEnvironmentSlugOrId`,
+        url: `/v9/projects/${idOrName}/custom-environments/${environmentSlugOrId}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Remove a custom environment for the project. Must not be named 'Production' or 'Preview'.
  * @summary Remove a custom environment
- * {@link v9ProjectsIdOrNameCustomEnvironmentsEnvironmentSlugOrId}
+ * {@link /v9/projects/:idOrName/custom-environments/:environmentSlugOrId}
  */
-async function removeCustomEnvironment({ pathParams: { idOrName, environmentSlugOrId }, queryParams, config = {}, }) {
+async function removeCustomEnvironment({ pathParams: { idOrName, environmentSlugOrId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1665,32 +1805,32 @@ async function removeCustomEnvironment({ pathParams: { idOrName, environmentSlug
     }
     const data = await request({
         method: 'DELETE',
-        url: `v9ProjectsIdOrNameCustomEnvironmentsEnvironmentSlugOrId`,
+        url: `/v9/projects/${idOrName}/custom-environments/${environmentSlugOrId}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Retrieve the domains associated with a given project by passing either the project `id` or `name` in the URL.
  * @summary Retrieve project domains by project by id or name
- * {@link v9ProjectsIdOrNameDomains}
+ * {@link /v9/projects/:idOrName/domains}
  */
-async function getProjectDomains({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function getProjectDomains({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v9ProjectsIdOrNameDomains`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v9/projects/${idOrName}/domains`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Get project domain by project id/name and domain name.
  * @summary Get a project domain
- * {@link v9ProjectsIdOrNameDomainsDomain}
+ * {@link /v9/projects/:idOrName/domains/:domain}
  */
-async function getProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {}, }) {
+async function getProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1698,15 +1838,15 @@ async function getProjectDomain({ pathParams: { idOrName, domain }, queryParams,
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
     }
-    const data = await request({ method: 'GET', url: `v9ProjectsIdOrNameDomainsDomain`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v9/projects/${idOrName}/domains/${domain}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Update a project domain's configuration, including the name, git branch and redirect of the domain.
  * @summary Update a project domain
- * {@link v9ProjectsIdOrNameDomainsDomain}
+ * {@link /v9/projects/:idOrName/domains/:domain}
  */
-async function updateProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {}, }) {
+async function updateProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1716,19 +1856,19 @@ async function updateProjectDomain({ pathParams: { idOrName, domain }, queryPara
     }
     const data = await request({
         method: 'PATCH',
-        url: `v9ProjectsIdOrNameDomainsDomain`,
+        url: `/v9/projects/${idOrName}/domains/${domain}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Remove a domain from a project by passing the domain name and by specifying the project by either passing the project `id` or `name` in the URL.
  * @summary Remove a domain from a project
- * {@link v9ProjectsIdOrNameDomainsDomain}
+ * {@link /v9/projects/:idOrName/domains/:domain}
  */
-async function removeProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {}, }) {
+async function removeProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1738,38 +1878,38 @@ async function removeProjectDomain({ pathParams: { idOrName, domain }, queryPara
     }
     const data = await request({
         method: 'DELETE',
-        url: `v9ProjectsIdOrNameDomainsDomain`,
+        url: `/v9/projects/${idOrName}/domains/${domain}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Add a domain to the project by passing its domain name and by specifying the project by either passing the project `id` or `name` in the URL. If the domain is not yet verified to be used on this project, the request will return `verified = false`, and the domain will need to be verified according to the `verification` challenge via `POST /projects/:idOrName/domains/:domain/verify`. If the domain already exists on the project, the request will fail with a `400` status code.
  * @summary Add a domain to a project
- * {@link v10ProjectsIdOrNameDomains}
+ * {@link /v10/projects/:idOrName/domains}
  */
-async function addProjectDomain({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function addProjectDomain({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
     const data = await request({
         method: 'POST',
-        url: `v10ProjectsIdOrNameDomains`,
+        url: `/v10/projects/${idOrName}/domains`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Move one project's domain to another project. Also allows the move of all redirects pointed to that domain in the same project.
  * @summary Move a project domain
- * {@link v1ProjectsIdOrNameDomainsDomainMove}
+ * {@link /v1/projects/:idOrName/domains/:domain/move}
  */
-async function moveProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {}, }) {
+async function moveProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1779,19 +1919,19 @@ async function moveProjectDomain({ pathParams: { idOrName, domain }, queryParams
     }
     const data = await request({
         method: 'POST',
-        url: `v1ProjectsIdOrNameDomainsDomainMove`,
+        url: `/v1/projects/${idOrName}/domains/${domain}/move`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Attempts to verify a project domain with `verified = false` by checking the correctness of the project domain's `verification` challenge.
  * @summary Verify project domain
- * {@link v9ProjectsIdOrNameDomainsDomainVerify}
+ * {@link /v9/projects/:idOrName/domains/:domain/verify}
  */
-async function verifyProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {}, }) {
+async function verifyProjectDomain({ pathParams: { idOrName, domain }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1799,41 +1939,47 @@ async function verifyProjectDomain({ pathParams: { idOrName, domain }, queryPara
     if (!domain) {
         throw new Error(`Missing required path parameter: domain`);
     }
-    const data = await request({ method: 'POST', url: `v9ProjectsIdOrNameDomainsDomainVerify`, queryParams, ...requestConfig });
+    const data = await request({ method: 'POST', url: `/v9/projects/${idOrName}/domains/${domain}/verify`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieve the environment variables for a given project by passing either the project `id` or `name` in the URL.
  * @summary Retrieve the environment variables of a project by id or name
- * {@link v10ProjectsIdOrNameEnv}
+ * {@link /v10/projects/:idOrName/env}
  */
-async function filterProjectEnvs({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function filterProjectEnvs({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v10ProjectsIdOrNameEnv`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v10/projects/${idOrName}/env`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Create one or more environment variables for a project by passing its `key`, `value`, `type` and `target` and by specifying the project by either passing the project `id` or `name` in the URL. If you include `upsert=true` as a query parameter, a new environment variable will not be created if it already exists but, the existing variable's value will be updated.
  * @summary Create one or more environment variables
- * {@link v10ProjectsIdOrNameEnv}
+ * {@link /v10/projects/:idOrName/env}
  */
-async function createProjectEnv({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function createProjectEnv({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'POST', url: `v10ProjectsIdOrNameEnv`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v10/projects/${idOrName}/env`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Retrieve the environment variable for a given project.
  * @summary Retrieve the decrypted value of an environment variable of a project by id
- * {@link v1ProjectsIdOrNameEnvId}
+ * {@link /v1/projects/:idOrName/env/:id}
  */
-async function getProjectEnv({ pathParams: { idOrName, id }, queryParams, config = {}, }) {
+async function getProjectEnv({ pathParams: { idOrName, id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1841,15 +1987,15 @@ async function getProjectEnv({ pathParams: { idOrName, id }, queryParams, config
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'GET', url: `v1ProjectsIdOrNameEnvId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/projects/${idOrName}/env/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Delete a specific environment variable for a given project by passing the environment variable identifier and either passing the project `id` or `name` in the URL.
  * @summary Remove an environment variable
- * {@link v9ProjectsIdOrNameEnvId}
+ * {@link /v9/projects/:idOrName/env/:id}
  */
-async function removeProjectEnv({ pathParams: { idOrName, id }, queryParams, config = {}, }) {
+async function removeProjectEnv({ pathParams: { idOrName, id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1857,15 +2003,15 @@ async function removeProjectEnv({ pathParams: { idOrName, id }, queryParams, con
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'DELETE', url: `v9ProjectsIdOrNameEnvId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v9/projects/${idOrName}/env/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Edit a specific environment variable for a given project by passing the environment variable identifier and either passing the project `id` or `name` in the URL.
  * @summary Edit an environment variable
- * {@link v9ProjectsIdOrNameEnvId}
+ * {@link /v9/projects/:idOrName/env/:id}
  */
-async function editProjectEnv({ pathParams: { idOrName, id }, queryParams, config = {}, }) {
+async function editProjectEnv({ pathParams: { idOrName, id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
@@ -1875,179 +2021,179 @@ async function editProjectEnv({ pathParams: { idOrName, id }, queryParams, confi
     }
     const data = await request({
         method: 'PATCH',
-        url: `v9ProjectsIdOrNameEnvId`,
+        url: `/v9/projects/${idOrName}/env/${id}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Get the Rolling Releases billing status for a project. The team level billing status is used to determine if the project can be configured for rolling releases.
  * @summary Get rolling release billing status
- * {@link v1ProjectsIdOrNameRollingReleaseBilling}
+ * {@link /v1/projects/:idOrName/rolling-release/billing}
  */
-async function getRollingReleaseBillingStatus({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function getRollingReleaseBillingStatus({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v1ProjectsIdOrNameRollingReleaseBilling`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/projects/${idOrName}/rolling-release/billing`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Get the Rolling Releases configuration for a project. The project-level config is simply a template that will be used for any future rolling release, and not the configuration for any active rolling release.
  * @summary Get rolling release configuration
- * {@link v1ProjectsIdOrNameRollingReleaseConfig}
+ * {@link /v1/projects/:idOrName/rolling-release/config}
  */
-async function getRollingReleaseConfig({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function getRollingReleaseConfig({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v1ProjectsIdOrNameRollingReleaseConfig`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/projects/${idOrName}/rolling-release/config`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Disable Rolling Releases for a project means that future deployments will not undergo a rolling release. Changing the config never alters a rollout that's already in-flight—it only affects the next production deployment. If you want to also stop the current rollout, call this endpoint to disable the feature, and then call either the /complete or /abort endpoint.
  * @summary Delete rolling release configuration
- * {@link v1ProjectsIdOrNameRollingReleaseConfig}
+ * {@link /v1/projects/:idOrName/rolling-release/config}
  */
-async function deleteRollingReleaseConfig({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function deleteRollingReleaseConfig({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'DELETE', url: `v1ProjectsIdOrNameRollingReleaseConfig`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/projects/${idOrName}/rolling-release/config`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Update (or disable) Rolling Releases for a project. Changing the config never alters a rollout that's already in-flight. It only affects the next production deployment. This also applies to disabling Rolling Releases. If you want to also stop the current rollout, call this endpoint to disable the feature, and then call either the /complete or /abort endpoint. Note: Enabling Rolling Releases automatically enables skew protection on the project with the default value if it wasn't configured already.
  * @summary Update the rolling release settings for the project
- * {@link v1ProjectsIdOrNameRollingReleaseConfig}
+ * {@link /v1/projects/:idOrName/rolling-release/config}
  */
-async function updateRollingReleaseConfig({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function updateRollingReleaseConfig({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'PATCH', url: `v1ProjectsIdOrNameRollingReleaseConfig`, queryParams, ...requestConfig });
+    const data = await request({ method: 'PATCH', url: `/v1/projects/${idOrName}/rolling-release/config`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Return the Rolling Release for a project, regardless of whether the rollout is active, aborted, or completed. If the feature is enabled but no deployment has occurred yet, null will be returned.
  * @summary Get the active rolling release information for a project
- * {@link v1ProjectsIdOrNameRollingRelease}
+ * {@link /v1/projects/:idOrName/rolling-release}
  */
-async function getRollingRelease({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function getRollingRelease({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v1ProjectsIdOrNameRollingRelease`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/projects/${idOrName}/rolling-release`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Advance a rollout to the next stage. This is only needed when rolling releases is configured to require manual approval.
  * @summary Update the active rolling release to the next stage for a project
- * {@link v1ProjectsIdOrNameRollingReleaseApproveStage}
+ * {@link /v1/projects/:idOrName/rolling-release/approve-stage}
  */
-async function approveRollingReleaseStage({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function approveRollingReleaseStage({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1ProjectsIdOrNameRollingReleaseApproveStage`,
+        url: `/v1/projects/${idOrName}/rolling-release/approve-stage`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Force-complete a Rolling Release. The canary deployment will begin serving 100% of the traffic.
  * @summary Complete the rolling release for the project
- * {@link v1ProjectsIdOrNameRollingReleaseComplete}
+ * {@link /v1/projects/:idOrName/rolling-release/complete}
  */
-async function completeRollingRelease({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function completeRollingRelease({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
     const data = await request({
         method: 'POST',
-        url: `v1ProjectsIdOrNameRollingReleaseComplete`,
+        url: `/v1/projects/${idOrName}/rolling-release/complete`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Initiates a project transfer request from one team to another. <br/> Returns a `code` that remains valid for 24 hours and can be used to accept the transfer request by another team using the `PUT /projects/transfer-request/:code` endpoint. <br/> Users can also accept the project transfer request using the claim URL: `https://vercel.com/claim-deployment?code=<code>&returnUrl=<returnUrl>`. <br/> The `code` parameter specifies the project transfer request code generated using this endpoint. <br/> The `returnUrl` parameter redirects users to a specific page of the application if the claim URL is invalid or expired.
  * @summary Create project transfer request
- * {@link projectsIdOrNameTransferRequest}
+ * {@link /projects/:idOrName/transfer-request}
  */
-async function createProjectTransferRequest({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function createProjectTransferRequest({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
     const data = await request({
         method: 'POST',
-        url: `projectsIdOrNameTransferRequest`,
+        url: `/projects/${idOrName}/transfer-request`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Accept a project transfer request initated by another team. <br/> The `code` is generated using the `POST /projects/:idOrName/transfer-request` endpoint.
  * @summary Accept project transfer request
- * {@link projectsTransferRequestCode}
+ * {@link /projects/transfer-request/:code}
  */
-async function acceptProjectTransferRequest({ pathParams: { code }, queryParams, config = {}, }) {
+async function acceptProjectTransferRequest({ pathParams: { code }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!code) {
         throw new Error(`Missing required path parameter: code`);
     }
     const data = await request({
         method: 'PUT',
-        url: `projectsTransferRequestCode`,
+        url: `/projects/transfer-request/${code}`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Update the deployment protection automation bypass for a project
  * @summary Update Protection Bypass for Automation
- * {@link v1ProjectsIdOrNameProtectionBypass}
+ * {@link /v1/projects/:idOrName/protection-bypass}
  */
-async function updateProjectProtectionBypass({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function updateProjectProtectionBypass({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
     const data = await request({
         method: 'PATCH',
-        url: `v1ProjectsIdOrNameProtectionBypass`,
+        url: `/v1/projects/${idOrName}/protection-bypass`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Allows users to promote a deployment to production. Note: This does NOT rebuild the deployment. If you need that, then call create-deployments endpoint.
  * @summary Points all production domains for a project to the given deploy
- * {@link v10ProjectsProjectIdPromoteDeploymentId}
+ * {@link /v10/projects/:projectId/promote/:deploymentId}
  */
-async function requestPromote({ pathParams: { projectId, deploymentId }, queryParams, config = {}, }) {
+async function requestPromote({ pathParams: { projectId, deploymentId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!projectId) {
         throw new Error(`Missing required path parameter: projectId`);
@@ -2055,194 +2201,216 @@ async function requestPromote({ pathParams: { projectId, deploymentId }, queryPa
     if (!deploymentId) {
         throw new Error(`Missing required path parameter: deploymentId`);
     }
-    const data = await request({ method: 'POST', url: `v10ProjectsProjectIdPromoteDeploymentId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'POST', url: `/v10/projects/${projectId}/promote/${deploymentId}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Get a list of aliases related to the last promote request with their mapping status
  * @summary Gets a list of aliases with status for the current promote
- * {@link v1ProjectsProjectIdPromoteAliases}
+ * {@link /v1/projects/:projectId/promote/aliases}
  */
-async function listPromoteAliases({ pathParams: { projectId }, queryParams, config = {}, }) {
+async function listPromoteAliases({ pathParams: { projectId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!projectId) {
         throw new Error(`Missing required path parameter: projectId`);
     }
-    const data = await request({ method: 'GET', url: `v1ProjectsProjectIdPromoteAliases`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/projects/${projectId}/promote/aliases`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Pause a project by passing its project `id` in the URL. If the project does not exist given the id then the request will fail with 400 status code. If the project disables auto assigning custom production domains and blocks the active Production Deployment then the request will return with 200 status code.
  * @summary Pause a project
- * {@link v1ProjectsProjectIdPause}
+ * {@link /v1/projects/:projectId/pause}
  */
-async function pauseProject({ pathParams: { projectId }, queryParams, config = {}, }) {
+async function pauseProject({ pathParams: { projectId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!projectId) {
         throw new Error(`Missing required path parameter: projectId`);
     }
-    const data = await request({ method: 'POST', url: `v1ProjectsProjectIdPause`, queryParams, ...requestConfig });
+    const data = await request({ method: 'POST', url: `/v1/projects/${projectId}/pause`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Unpause a project by passing its project `id` in the URL. If the project does not exist given the id then the request will fail with 400 status code. If the project enables auto assigning custom production domains and unblocks the active Production Deployment then the request will return with 200 status code.
  * @summary Unpause a project
- * {@link v1ProjectsProjectIdUnpause}
+ * {@link /v1/projects/:projectId/unpause}
  */
-async function unpauseProject({ pathParams: { projectId }, queryParams, config = {}, }) {
+async function unpauseProject({ pathParams: { projectId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!projectId) {
         throw new Error(`Missing required path parameter: projectId`);
     }
-    const data = await request({ method: 'POST', url: `v1ProjectsProjectIdUnpause`, queryParams, ...requestConfig });
+    const data = await request({ method: 'POST', url: `/v1/projects/${projectId}/unpause`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Update the setting for determining if the project has Attack Challenge mode enabled.
  * @summary Update Attack Challenge mode
- * {@link v1SecurityAttackMode}
+ * {@link /v1/security/attack-mode}
  */
-async function updateAttackChallengeMode({ queryParams, config = {}, }) {
+async function updateAttackChallengeMode({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v1SecurityAttackMode`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/security/attack-mode`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Set the firewall configuration to provided rules and settings. Creates or overwrite the existing firewall configuration.
  * @summary Put Firewall Configuration
- * {@link v1SecurityFirewallConfig}
+ * {@link /v1/security/firewall/config}
  */
-async function putFirewallConfig({ queryParams, config = {}, }) {
+async function putFirewallConfig({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'PUT', url: `v1SecurityFirewallConfig`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'PUT',
+        url: `/v1/security/firewall/config`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Process updates to modify the existing firewall config for a project
  * @summary Update Firewall Configuration
- * {@link v1SecurityFirewallConfig}
+ * {@link /v1/security/firewall/config}
  */
-async function updateFirewallConfig({ queryParams, config = {}, }) {
+async function updateFirewallConfig({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     const data = await request({
         method: 'PATCH',
-        url: `v1SecurityFirewallConfig`,
+        url: `/v1/security/firewall/config`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Retrieve the specified firewall configuration for a project. The deployed configVersion will be `active`
  * @summary Read Firewall Configuration
- * {@link v1SecurityFirewallConfigConfigVersion}
+ * {@link /v1/security/firewall/config/:configVersion}
  */
-async function getFirewallConfig({ pathParams: { configVersion }, queryParams, config = {}, }) {
+async function getFirewallConfig({ pathParams: { configVersion }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!configVersion) {
         throw new Error(`Missing required path parameter: configVersion`);
     }
-    const data = await request({ method: 'GET', url: `v1SecurityFirewallConfigConfigVersion`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/security/firewall/config/${configVersion}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieve active attack data within the last 24h window
  * @summary Read active attack data
- * {@link v1SecurityFirewallAttackStatus}
+ * {@link /v1/security/firewall/attack-status}
  */
-async function getActiveAttackStatus({ queryParams, config = {}, }) {
+async function getActiveAttackStatus({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v1SecurityFirewallAttackStatus`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/security/firewall/attack-status`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieve the system bypass rules configured for the specified project
  * @summary Read System Bypass
- * {@link v1SecurityFirewallBypass}
+ * {@link /v1/security/firewall/bypass}
  */
-async function getBypassIp({ queryParams, config = {}, }) {
+async function getBypassIp({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v1SecurityFirewallBypass`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/security/firewall/bypass`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Create new system bypass rules
  * @summary Create System Bypass Rule
- * {@link v1SecurityFirewallBypass}
+ * {@link /v1/security/firewall/bypass}
  */
-async function addBypassIp({ queryParams, config = {}, }) {
+async function addBypassIp({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     const data = await request({
         method: 'POST',
-        url: `v1SecurityFirewallBypass`,
+        url: `/v1/security/firewall/bypass`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Remove system bypass rules
  * @summary Remove System Bypass Rule
- * {@link v1SecurityFirewallBypass}
+ * {@link /v1/security/firewall/bypass}
  */
-async function removeBypassIp({ queryParams, config = {}, }) {
+async function removeBypassIp({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     const data = await request({
         method: 'DELETE',
-        url: `v1SecurityFirewallBypass`,
+        url: `/v1/security/firewall/bypass`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Get a paginated list of team members for the provided team.
  * @summary List team members
- * {@link v3TeamsTeamIdMembers}
+ * {@link /v3/teams/:teamId/members}
  */
-async function getTeamMembers({ pathParams: { teamId }, queryParams, config = {}, }) {
+async function getTeamMembers({ pathParams: { teamId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'GET', url: `v3TeamsTeamIdMembers`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v3/teams/${teamId}/members`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Invite a user to join the team specified in the URL. The authenticated user needs to be an `OWNER` in order to successfully invoke this endpoint. The user can be specified with an email or an ID. If both email and ID are provided, ID will take priority.
  * @summary Invite a user
- * {@link v1TeamsTeamIdMembers}
+ * {@link /v1/teams/:teamId/members}
  */
-async function inviteUserToTeam({ pathParams: { teamId }, config = {}, }) {
+async function inviteUserToTeam({ pathParams: { teamId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'POST', url: `v1TeamsTeamIdMembers`, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/teams/${teamId}/members`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Request access to a team as a member. An owner has to approve the request. Only 10 users can request access to a team at the same time.
  * @summary Request access to a team
- * {@link v1TeamsTeamIdRequest}
+ * {@link /v1/teams/:teamId/request}
  */
-async function requestAccessToTeam({ pathParams: { teamId }, config = {}, }) {
+async function requestAccessToTeam({ pathParams: { teamId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'POST', url: `v1TeamsTeamIdRequest`, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/teams/${teamId}/request`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Check the status of a join request. It'll respond with a 404 if the request has been declined. If no `userId` path segment was provided, this endpoint will instead return the status of the authenticated user.
  * @summary Get access request status
- * {@link v1TeamsTeamIdRequestUserId}
+ * {@link /v1/teams/:teamId/request/:userId}
  */
-async function getTeamAccessRequest({ pathParams: { userId, teamId }, config = {}, }) {
+async function getTeamAccessRequest({ pathParams: { userId, teamId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!userId) {
         throw new Error(`Missing required path parameter: userId`);
@@ -2250,28 +2418,33 @@ async function getTeamAccessRequest({ pathParams: { userId, teamId }, config = {
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'GET', url: `v1TeamsTeamIdRequestUserId`, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/teams/${teamId}/request/${userId}`, ...requestConfig });
     return data;
 }
 /**
  * @description Join a team with a provided invite code or team ID.
  * @summary Join a team
- * {@link v1TeamsTeamIdMembersTeamsJoin}
+ * {@link /v1/teams/:teamId/members/teams/join}
  */
-async function joinTeam({ pathParams: { teamId }, config = {}, }) {
+async function joinTeam({ pathParams: { teamId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'POST', url: `v1TeamsTeamIdMembersTeamsJoin`, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/teams/${teamId}/members/teams/join`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Update the membership of a Team Member on the Team specified by `teamId`, such as changing the _role_ of the member, or confirming a request to join the Team for an unconfirmed member. The authenticated user must be an `OWNER` of the Team.
  * @summary Update a Team Member
- * {@link v1TeamsTeamIdMembersUid}
+ * {@link /v1/teams/:teamId/members/:uid}
  */
-async function updateTeamMember({ pathParams: { uid, teamId }, config = {}, }) {
+async function updateTeamMember({ pathParams: { uid, teamId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!uid) {
         throw new Error(`Missing required path parameter: uid`);
@@ -2279,15 +2452,20 @@ async function updateTeamMember({ pathParams: { uid, teamId }, config = {}, }) {
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'PATCH', url: `v1TeamsTeamIdMembersUid`, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'PATCH',
+        url: `/v1/teams/${teamId}/members/${uid}`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Remove a Team Member from the Team, or dismiss a user that requested access, or leave a team.
  * @summary Remove a Team Member
- * {@link v1TeamsTeamIdMembersUid}
+ * {@link /v1/teams/:teamId/members/:uid}
  */
-async function removeTeamMember({ pathParams: { uid, teamId }, queryParams, config = {}, }) {
+async function removeTeamMember({ pathParams: { uid, teamId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!uid) {
         throw new Error(`Missing required path parameter: uid`);
@@ -2295,74 +2473,91 @@ async function removeTeamMember({ pathParams: { uid, teamId }, queryParams, conf
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'DELETE', url: `v1TeamsTeamIdMembersUid`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/teams/${teamId}/members/${uid}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Get information for the Team specified by the `teamId` parameter.
  * @summary Get a Team
- * {@link v2TeamsTeamId}
+ * {@link /v2/teams/:teamId}
  */
-async function getTeam({ pathParams: { teamId }, queryParams, config = {}, }) {
+async function getTeam({ pathParams: { teamId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'GET', url: `v2TeamsTeamId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v2/teams/${teamId}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Update the information of a Team specified by the `teamId` parameter. The request body should contain the information that will be updated on the Team.
  * @summary Update a Team
- * {@link v2TeamsTeamId}
+ * {@link /v2/teams/:teamId}
  */
-async function patchTeam({ pathParams: { teamId }, queryParams, config = {}, }) {
+async function patchTeam({ pathParams: { teamId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'PATCH', url: `v2TeamsTeamId`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'PATCH',
+        url: `/v2/teams/${teamId}`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Get a paginated list of all the Teams the authenticated User is a member of.
  * @summary List all teams
- * {@link v2Teams}
+ * {@link /v2/teams}
  */
-async function getTeams({ queryParams, config = {}, }) {
+async function getTeams({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v2Teams`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v2/teams`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Create a new Team under your account. You need to send a POST request with the desired Team slug, and optionally the Team name.
  * @summary Create a Team
- * {@link v1Teams}
+ * {@link /v1/teams}
  */
 async function createTeam({ config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v1Teams`, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/teams`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Delete a team under your account. You need to send a `DELETE` request with the desired team `id`. An optional array of reasons for deletion may also be sent.
  * @summary Delete a Team
- * {@link v1TeamsTeamId}
+ * {@link /v1/teams/:teamId}
  */
-async function deleteTeam({ pathParams: { teamId }, queryParams, config = {}, }) {
+async function deleteTeam({ pathParams: { teamId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'DELETE', url: `v1TeamsTeamId`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'DELETE',
+        url: `/v1/teams/${teamId}`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Delete an active Team invite code.
  * @summary Delete a Team invite code
- * {@link v1TeamsTeamIdInvitesInviteId}
+ * {@link /v1/teams/:teamId/invites/:inviteId}
  */
-async function deleteTeamInviteCode({ pathParams: { inviteId, teamId }, config = {}, }) {
+async function deleteTeamInviteCode({ pathParams: { inviteId, teamId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!inviteId) {
         throw new Error(`Missing required path parameter: inviteId`);
@@ -2370,291 +2565,326 @@ async function deleteTeamInviteCode({ pathParams: { inviteId, teamId }, config =
     if (!teamId) {
         throw new Error(`Missing required path parameter: teamId`);
     }
-    const data = await request({ method: 'DELETE', url: `v1TeamsTeamIdInvitesInviteId`, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/teams/${teamId}/invites/${inviteId}`, ...requestConfig });
     return data;
 }
 /**
  * @description Before you create a deployment you need to upload the required files for that deployment. To do it, you need to first upload each file to this endpoint. Once that's completed, you can create a new deployment with the uploaded files. The file content must be placed inside the body of the request. In the case of a successful response you'll receive a status code 200 with an empty body.
  * @summary Upload Deployment Files
- * {@link v2Files}
+ * {@link /v2/files}
  */
-async function uploadFile({ queryParams, headers, config = {}, }) {
+async function uploadFile({ queryParams, headers, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     const data = await request({
         method: 'POST',
-        url: `v2Files`,
+        url: `/v2/files`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationOctetStream', ...headers, ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationOctetStream', ...headers, ...requestConfig.headers }
     });
     return data;
 }
 /**
  * @description Retrieve a list of the current User's authentication tokens.
  * @summary List Auth Tokens
- * {@link v5UserTokens}
+ * {@link /v5/user/tokens}
  */
 async function listAuthTokens({ config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v5UserTokens`, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v5/user/tokens`, ...requestConfig });
     return data;
 }
 /**
  * @description Creates and returns a new authentication token for the currently authenticated User. The `bearerToken` property is only provided once, in the response body, so be sure to save it on the client for use with API requests.
  * @summary Create an Auth Token
- * {@link v3UserTokens}
+ * {@link /v3/user/tokens}
  */
-async function createAuthToken({ queryParams, config = {}, }) {
+async function createAuthToken({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v3UserTokens`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v3/user/tokens`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Retrieve metadata about an authentication token belonging to the currently authenticated User.
  * @summary Get Auth Token Metadata
- * {@link v5UserTokensTokenId}
+ * {@link /v5/user/tokens/:tokenId}
  */
-async function getAuthToken({ pathParams: { tokenId }, config = {}, }) {
+async function getAuthToken({ pathParams: { tokenId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!tokenId) {
         throw new Error(`Missing required path parameter: tokenId`);
     }
-    const data = await request({ method: 'GET', url: `v5UserTokensTokenId`, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v5/user/tokens/${tokenId}`, ...requestConfig });
     return data;
 }
 /**
  * @description Invalidate an authentication token, such that it will no longer be valid for future HTTP requests.
  * @summary Delete an authentication token
- * {@link v3UserTokensTokenId}
+ * {@link /v3/user/tokens/:tokenId}
  */
-async function deleteAuthToken({ pathParams: { tokenId }, config = {}, }) {
+async function deleteAuthToken({ pathParams: { tokenId }, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!tokenId) {
         throw new Error(`Missing required path parameter: tokenId`);
     }
-    const data = await request({ method: 'DELETE', url: `v3UserTokensTokenId`, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v3/user/tokens/${tokenId}`, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieves information related to the currently authenticated User.
  * @summary Get the User
- * {@link v2User}
+ * {@link /v2/user}
  */
 async function getAuthUser({ config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v2User`, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v2/user`, ...requestConfig });
     return data;
 }
 /**
  * @description Initiates the deletion process for the currently authenticated User, by sending a deletion confirmation email. The email contains a link that the user needs to visit in order to proceed with the deletion process.
  * @summary Delete User Account
- * {@link v1User}
+ * {@link /v1/user}
  */
 async function requestDelete({ config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'DELETE', url: `v1User`, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'DELETE',
+        url: `/v1/user`,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Creates a webhook
  * @summary Creates a webhook
- * {@link v1Webhooks}
+ * {@link /v1/webhooks}
  */
-async function createWebhook({ queryParams, config = {}, }) {
+async function createWebhook({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v1Webhooks`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v1/webhooks`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Get a list of webhooks
  * @summary Get a list of webhooks
- * {@link v1Webhooks}
+ * {@link /v1/webhooks}
  */
-async function getWebhooks({ queryParams, config = {}, }) {
+async function getWebhooks({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v1Webhooks`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/webhooks`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Get a webhook
  * @summary Get a webhook
- * {@link v1WebhooksId}
+ * {@link /v1/webhooks/:id}
  */
-async function getWebhook({ pathParams: { id }, queryParams, config = {}, }) {
+async function getWebhook({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'GET', url: `v1WebhooksId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v1/webhooks/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Deletes a webhook
  * @summary Deletes a webhook
- * {@link v1WebhooksId}
+ * {@link /v1/webhooks/:id}
  */
-async function deleteWebhook({ pathParams: { id }, queryParams, config = {}, }) {
+async function deleteWebhook({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'DELETE', url: `v1WebhooksId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v1/webhooks/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieves all Aliases for the Deployment with the given ID. The authenticated user or team must own the deployment.
  * @summary List Deployment Aliases
- * {@link v2DeploymentsIdAliases}
+ * {@link /v2/deployments/:id/aliases}
  */
-async function listDeploymentAliases({ pathParams: { id }, queryParams, config = {}, }) {
+async function listDeploymentAliases({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'GET', url: `v2DeploymentsIdAliases`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v2/deployments/${id}/aliases`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Creates a new alias for the deployment with the given deployment ID. The authenticated user or team must own this deployment. If the desired alias is already assigned to another deployment, then it will be removed from the old deployment and assigned to the new one.
  * @summary Assign an Alias
- * {@link v2DeploymentsIdAliases}
+ * {@link /v2/deployments/:id/aliases}
  */
-async function assignAlias({ pathParams: { id }, queryParams, config = {}, }) {
+async function assignAlias({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'POST', url: `v2DeploymentsIdAliases`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v2/deployments/${id}/aliases`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Retrieves a list of aliases for the authenticated User or Team. When `domain` is provided, only aliases for that domain will be returned. When `projectId` is provided, it will only return the given project aliases.
  * @summary List aliases
- * {@link v4Aliases}
+ * {@link /v4/aliases}
  */
-async function listAliases({ queryParams, config = {}, }) {
+async function listAliases({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v4Aliases`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v4/aliases`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieves an Alias for the given host name or alias ID.
  * @summary Get an Alias
- * {@link v4AliasesIdOrAlias}
+ * {@link /v4/aliases/:idOrAlias}
  */
-async function getAlias({ pathParams: { idOrAlias }, queryParams, config = {}, }) {
+async function getAlias({ pathParams: { idOrAlias }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrAlias) {
         throw new Error(`Missing required path parameter: idOrAlias`);
     }
-    const data = await request({ method: 'GET', url: `v4AliasesIdOrAlias`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v4/aliases/${idOrAlias}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Delete an Alias with the specified ID.
  * @summary Delete an Alias
- * {@link v2AliasesAliasId}
+ * {@link /v2/aliases/:aliasId}
  */
-async function deleteAlias({ pathParams: { aliasId }, queryParams, config = {}, }) {
+async function deleteAlias({ pathParams: { aliasId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!aliasId) {
         throw new Error(`Missing required path parameter: aliasId`);
     }
-    const data = await request({ method: 'DELETE', url: `v2AliasesAliasId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v2/aliases/${aliasId}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Update the protection bypass for the alias or deployment URL (used for user access & comment access for deployments). Used as shareable links and user scoped access for Vercel Authentication and also to allow external (logged in) people to comment on previews for Preview Comments (next-live-mode).
  * @summary Update the protection bypass for a URL
- * {@link aliasesIdProtectionBypass}
+ * {@link /aliases/:id/protection-bypass}
  */
-async function patchUrlProtectionBypass({ pathParams: { id }, queryParams, config = {}, }) {
+async function patchUrlProtectionBypass({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
     const data = await request({
         method: 'PATCH',
-        url: `aliasesIdProtectionBypass`,
+        url: `/aliases/${id}/protection-bypass`,
         queryParams,
         ...requestConfig,
-        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers },
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
     });
     return data;
 }
 /**
- * {@link certs}
+ * {@link /certs}
  */
 async function listCerts({ config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `certs`, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/certs`, ...requestConfig });
     return data;
 }
 /**
  * @description Get cert by id
  * @summary Get cert by id
- * {@link v8CertsId}
+ * {@link /v8/certs/:id}
  */
-async function getCertById({ pathParams: { id }, queryParams, config = {}, }) {
+async function getCertById({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'GET', url: `v8CertsId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v8/certs/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Remove cert
  * @summary Remove cert
- * {@link v8CertsId}
+ * {@link /v8/certs/:id}
  */
-async function removeCert({ pathParams: { id }, queryParams, config = {}, }) {
+async function removeCert({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'DELETE', url: `v8CertsId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v8/certs/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Issue a new cert
  * @summary Issue a new cert
- * {@link v8Certs}
+ * {@link /v8/certs}
  */
-async function issueCert({ queryParams, config = {}, }) {
+async function issueCert({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'POST', url: `v8Certs`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v8/certs`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Upload a cert
  * @summary Upload a cert
- * {@link v8Certs}
+ * {@link /v8/certs}
  */
-async function uploadCert({ queryParams, config = {}, }) {
+async function uploadCert({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'PUT', url: `v8Certs`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'PUT',
+        url: `/v8/certs`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Allows to retrieve the file structure of the source code of a deployment by supplying the deployment unique identifier. If the deployment was created with the Vercel CLI or the API directly with the `files` key, it will have a file tree that can be retrievable.
  * @summary List Deployment Files
- * {@link v6DeploymentsIdFiles}
+ * {@link /v6/deployments/:id/files}
  */
-async function listDeploymentFiles({ pathParams: { id }, queryParams, config = {}, }) {
+async function listDeploymentFiles({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'GET', url: `v6DeploymentsIdFiles`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v6/deployments/${id}/files`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows to retrieve the content of a file by supplying the file identifier and the deployment unique identifier. The response body will contain a JSON response containing the contents of the file encoded as base64.
  * @summary Get Deployment File Contents
- * {@link v8DeploymentsIdFilesFileId}
+ * {@link /v8/deployments/:id/files/:fileId}
  */
-async function getDeploymentFileContents({ pathParams: { id, fileId }, queryParams, config = {}, }) {
+async function getDeploymentFileContents({ pathParams: { id, fileId }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
@@ -2662,273 +2892,285 @@ async function getDeploymentFileContents({ pathParams: { id, fileId }, queryPara
     if (!fileId) {
         throw new Error(`Missing required path parameter: fileId`);
     }
-    const data = await request({ method: 'GET', url: `v8DeploymentsIdFilesFileId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v8/deployments/${id}/files/${fileId}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description List deployments under the authenticated user or team. If a deployment hasn't finished uploading (is incomplete), the `url` property will have a value of `null`.
  * @summary List deployments
- * {@link v6Deployments}
+ * {@link /v6/deployments}
  */
-async function getDeployments({ queryParams, config = {}, }) {
+async function getDeployments({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v6Deployments`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v6/deployments`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description This API allows you to delete a deployment, either by supplying its `id` in the URL or the `url` of the deployment as a query parameter. You can obtain the ID, for example, by listing all deployments.
  * @summary Delete a Deployment
- * {@link v13DeploymentsId}
+ * {@link /v13/deployments/:id}
  */
-async function deleteDeployment({ pathParams: { id }, queryParams, config = {}, }) {
+async function deleteDeployment({ pathParams: { id }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!id) {
         throw new Error(`Missing required path parameter: id`);
     }
-    const data = await request({ method: 'DELETE', url: `v13DeploymentsId`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v13/deployments/${id}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Retrieves the active Vercel secrets for the authenticated user or team. By default it returns 20 secrets. The rest can be retrieved using the pagination options. The body will contain an entry for each secret.
  * @summary List secrets
- * {@link v3Secrets}
+ * {@link /v3/secrets}
  */
-async function getSecrets({ queryParams, config = {}, }) {
+async function getSecrets({ queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
-    const data = await request({ method: 'GET', url: `v3Secrets`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v3/secrets`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description Allows to create a new secret.
  * @summary Create a new secret
- * {@link v2SecretsName}
+ * {@link /v2/secrets/:name}
  */
-async function createSecret({ pathParams: { name }, queryParams, config = {}, }) {
+async function createSecret({ pathParams: { name }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!name) {
         throw new Error(`Missing required path parameter: name`);
     }
-    const data = await request({ method: 'POST', url: `v2SecretsName`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'POST',
+        url: `/v2/secrets/${name}`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Enables to edit the name of a secret. The name has to be unique to the user or team’s secrets.
  * @summary Change secret name
- * {@link v2SecretsName}
+ * {@link /v2/secrets/:name}
  */
-async function renameSecret({ pathParams: { name }, queryParams, config = {}, }) {
+async function renameSecret({ pathParams: { name }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!name) {
         throw new Error(`Missing required path parameter: name`);
     }
-    const data = await request({ method: 'PATCH', url: `v2SecretsName`, queryParams, ...requestConfig, headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers } });
+    const data = await request({
+        method: 'PATCH',
+        url: `/v2/secrets/${name}`,
+        queryParams,
+        ...requestConfig,
+        headers: { 'Content-Type': 'applicationJson', ...requestConfig.headers }
+    });
     return data;
 }
 /**
  * @description Retrieves the information for a specific secret by passing either the secret id or name in the URL.
  * @summary Get a single secret
- * {@link v3SecretsIdOrName}
+ * {@link /v3/secrets/:idOrName}
  */
-async function getSecret({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function getSecret({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'GET', url: `v3SecretsIdOrName`, queryParams, ...requestConfig });
+    const data = await request({ method: 'GET', url: `/v3/secrets/${idOrName}`, queryParams, ...requestConfig });
     return data;
 }
 /**
  * @description This deletes the user or team’s secret defined in the URL.
  * @summary Delete a secret
- * {@link v2SecretsIdOrName}
+ * {@link /v2/secrets/:idOrName}
  */
-async function deleteSecret({ pathParams: { idOrName }, queryParams, config = {}, }) {
+async function deleteSecret({ pathParams: { idOrName }, queryParams, config = {} }) {
     const { client: request = fetcher_1.default, ...requestConfig } = config;
     if (!idOrName) {
         throw new Error(`Missing required path parameter: idOrName`);
     }
-    const data = await request({ method: 'DELETE', url: `v2SecretsIdOrName`, queryParams, ...requestConfig });
+    const data = await request({ method: 'DELETE', url: `/v2/secrets/${idOrName}`, queryParams, ...requestConfig });
     return data;
 }
 exports.operationsByPath = {
-    'GET v1AccessGroupsIdOrName': readAccessGroup,
-    'POST v1AccessGroupsIdOrName': updateAccessGroup,
-    'DELETE v1AccessGroupsIdOrName': deleteAccessGroup,
-    'GET v1AccessGroupsIdOrNameMembers': listAccessGroupMembers,
-    'GET v1AccessGroups': listAccessGroups,
-    'POST v1AccessGroups': createAccessGroup,
-    'GET v1AccessGroupsIdOrNameProjects': listAccessGroupProjects,
-    'POST v1AccessGroupsAccessGroupIdOrNameProjects': createAccessGroupProject,
-    'GET v1AccessGroupsAccessGroupIdOrNameProjectsProjectId': readAccessGroupProject,
-    'PATCH v1AccessGroupsAccessGroupIdOrNameProjectsProjectId': updateAccessGroupProject,
-    'DELETE v1AccessGroupsAccessGroupIdOrNameProjectsProjectId': deleteAccessGroupProject,
-    'POST v8ArtifactsEvents': recordEvents,
-    'GET v8ArtifactsStatus': status,
-    'PUT v8ArtifactsHash': uploadArtifact,
-    'GET v8ArtifactsHash': downloadArtifact,
-    'POST v8Artifacts': artifactQuery,
-    'POST v1DeploymentsDeploymentIdChecks': createCheck,
-    'GET v1DeploymentsDeploymentIdChecks': getAllChecks,
-    'GET v1DeploymentsDeploymentIdChecksCheckId': getCheck,
-    'PATCH v1DeploymentsDeploymentIdChecksCheckId': updateCheck,
-    'POST v1DeploymentsDeploymentIdChecksCheckIdRerequest': rerequestCheck,
-    'DELETE dataCachePurgeAll': purgeAllDataCache,
-    'PATCH dataCacheBillingSettings': updateDataCacheBillingSettings,
-    'PATCH v1DataCacheProjectsProjectId': updateProjectDataCache,
-    'GET v3DeploymentsIdOrUrlEvents': getDeploymentEvents,
-    'PATCH v1DeploymentsDeploymentIdIntegrationsIntegrationConfigurationIdResourcesResourceIdActionsAction': updateIntegrationDeploymentAction,
-    'GET v13DeploymentsIdOrUrl': getDeployment,
-    'POST v13Deployments': createDeployment,
-    'PATCH v12DeploymentsIdCancel': cancelDeployment,
-    'POST v5DomainsBuy': buyDomain,
-    'GET v4DomainsPrice': checkDomainPrice,
-    'GET v4DomainsStatus': checkDomainStatus,
-    'GET v4DomainsDomainRecords': getRecords,
-    'POST v2DomainsDomainRecords': createRecord,
-    'PATCH v1DomainsRecordsRecordId': updateRecord,
-    'DELETE v2DomainsDomainRecordsRecordId': removeRecord,
-    'GET v1DomainsDomainRegistry': getDomainTransfer,
-    'GET v6DomainsDomainConfig': getDomainConfig,
-    'GET v5DomainsDomain': getDomain,
-    'GET v5Domains': getDomains,
-    'POST v7Domains': createOrTransferDomain,
-    'PATCH v3DomainsDomain': patchDomain,
-    'DELETE v6DomainsDomain': deleteDomain,
-    'GET v1EdgeConfig': getEdgeConfigs,
-    'POST v1EdgeConfig': createEdgeConfig,
-    'GET v1EdgeConfigEdgeConfigId': getEdgeConfig,
-    'PUT v1EdgeConfigEdgeConfigId': updateEdgeConfig,
-    'DELETE v1EdgeConfigEdgeConfigId': deleteEdgeConfig,
-    'GET v1EdgeConfigEdgeConfigIdItems': getEdgeConfigItems,
-    'PATCH v1EdgeConfigEdgeConfigIdItems': patchEdgeConfigItems,
-    'GET v1EdgeConfigEdgeConfigIdSchema': getEdgeConfigSchema,
-    'POST v1EdgeConfigEdgeConfigIdSchema': patchEdgeConfigSchema,
-    'DELETE v1EdgeConfigEdgeConfigIdSchema': deleteEdgeConfigSchema,
-    'GET v1EdgeConfigEdgeConfigIdItemEdgeConfigItemKey': getEdgeConfigItem,
-    'GET v1EdgeConfigEdgeConfigIdTokens': getEdgeConfigTokens,
-    'DELETE v1EdgeConfigEdgeConfigIdTokens': deleteEdgeConfigTokens,
-    'GET v1EdgeConfigEdgeConfigIdTokenToken': getEdgeConfigToken,
-    'POST v1EdgeConfigEdgeConfigIdToken': createEdgeConfigToken,
-    'GET v1EdgeConfigEdgeConfigIdBackupsEdgeConfigBackupVersionId': getEdgeConfigBackup,
-    'GET v1EdgeConfigEdgeConfigIdBackups': getEdgeConfigBackups,
-    'GET v3Events': listUserEvents,
-    'GET v1InstallationsIntegrationConfigurationIdAccount': getAccountInfo,
-    'GET v1InstallationsIntegrationConfigurationIdMemberMemberId': getMember,
-    'POST v1InstallationsIntegrationConfigurationIdEvents': createEvent,
-    'GET v1InstallationsIntegrationConfigurationIdResources': getIntegrationResources,
-    'GET v1InstallationsIntegrationConfigurationIdResourcesResourceId': getIntegrationResource,
-    'DELETE v1InstallationsIntegrationConfigurationIdResourcesResourceId': deleteIntegrationResource,
-    'PUT v1InstallationsIntegrationConfigurationIdResourcesResourceId': importResource,
-    'POST v1InstallationsIntegrationConfigurationIdBilling': submitBillingData,
-    'POST v1InstallationsIntegrationConfigurationIdBillingInvoices': submitInvoice,
-    'GET v1InstallationsIntegrationConfigurationIdBillingInvoicesInvoiceId': getInvoice,
-    'POST v1InstallationsIntegrationConfigurationIdBillingInvoicesInvoiceIdActions': updateInvoice,
-    'POST v1InstallationsIntegrationConfigurationIdBillingBalance': submitPrepaymentBalances,
-    'PUT v1InstallationsIntegrationConfigurationIdProductsIntegrationProductIdOrSlugResourcesResourceIdSecrets': updateResourceSecrets,
-    'PUT v1InstallationsIntegrationConfigurationIdResourcesResourceIdSecrets': updateResourceSecretsById,
-    'GET v1IntegrationsConfigurations': getConfigurations,
-    'GET v1IntegrationsConfigurationId': getConfiguration,
-    'DELETE v1IntegrationsConfigurationId': deleteConfiguration,
-    'POST v1IntegrationsSsoToken': exchangeSsoToken,
-    'GET v2IntegrationsLogDrains': getIntegrationLogDrains,
-    'POST v2IntegrationsLogDrains': createLogDrain,
-    'DELETE v1IntegrationsLogDrainsId': deleteIntegrationLogDrain,
-    'GET v1ProjectsProjectIdDeploymentsDeploymentIdRuntimeLogs': getRuntimeLogs,
-    'POST v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationItems': createExperimentationItem,
-    'PATCH v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationItemsItemId': updateExperimentationItem,
-    'DELETE v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationItemsItemId': deleteExperimentationItem,
-    'PUT v1InstallationsIntegrationConfigurationIdResourcesResourceIdExperimentationEdgeConfig': updateExperimentationEdgeConfig,
-    'GET v1ProjectsIdOrNameMembers': getProjectMembers,
-    'POST v1ProjectsIdOrNameMembers': addProjectMember,
-    'DELETE v1ProjectsIdOrNameMembersUid': removeProjectMember,
-    'GET v10Projects': getProjects,
-    'POST v11Projects': createProject,
-    'GET v9ProjectsIdOrName': getProject,
-    'PATCH v9ProjectsIdOrName': updateProject,
-    'DELETE v9ProjectsIdOrName': deleteProject,
-    'POST v9ProjectsIdOrNameCustomEnvironments': createCustomEnvironment,
-    'GET v9ProjectsIdOrNameCustomEnvironments': listCustomEnvironments,
-    'GET v9ProjectsIdOrNameCustomEnvironmentsEnvironmentSlugOrId': getCustomEnvironment,
-    'PATCH v9ProjectsIdOrNameCustomEnvironmentsEnvironmentSlugOrId': updateCustomEnvironment,
-    'DELETE v9ProjectsIdOrNameCustomEnvironmentsEnvironmentSlugOrId': removeCustomEnvironment,
-    'GET v9ProjectsIdOrNameDomains': getProjectDomains,
-    'GET v9ProjectsIdOrNameDomainsDomain': getProjectDomain,
-    'PATCH v9ProjectsIdOrNameDomainsDomain': updateProjectDomain,
-    'DELETE v9ProjectsIdOrNameDomainsDomain': removeProjectDomain,
-    'POST v10ProjectsIdOrNameDomains': addProjectDomain,
-    'POST v1ProjectsIdOrNameDomainsDomainMove': moveProjectDomain,
-    'POST v9ProjectsIdOrNameDomainsDomainVerify': verifyProjectDomain,
-    'GET v10ProjectsIdOrNameEnv': filterProjectEnvs,
-    'POST v10ProjectsIdOrNameEnv': createProjectEnv,
-    'GET v1ProjectsIdOrNameEnvId': getProjectEnv,
-    'DELETE v9ProjectsIdOrNameEnvId': removeProjectEnv,
-    'PATCH v9ProjectsIdOrNameEnvId': editProjectEnv,
-    'GET v1ProjectsIdOrNameRollingReleaseBilling': getRollingReleaseBillingStatus,
-    'GET v1ProjectsIdOrNameRollingReleaseConfig': getRollingReleaseConfig,
-    'DELETE v1ProjectsIdOrNameRollingReleaseConfig': deleteRollingReleaseConfig,
-    'PATCH v1ProjectsIdOrNameRollingReleaseConfig': updateRollingReleaseConfig,
-    'GET v1ProjectsIdOrNameRollingRelease': getRollingRelease,
-    'POST v1ProjectsIdOrNameRollingReleaseApproveStage': approveRollingReleaseStage,
-    'POST v1ProjectsIdOrNameRollingReleaseComplete': completeRollingRelease,
-    'POST projectsIdOrNameTransferRequest': createProjectTransferRequest,
-    'PUT projectsTransferRequestCode': acceptProjectTransferRequest,
-    'PATCH v1ProjectsIdOrNameProtectionBypass': updateProjectProtectionBypass,
-    'POST v10ProjectsProjectIdPromoteDeploymentId': requestPromote,
-    'GET v1ProjectsProjectIdPromoteAliases': listPromoteAliases,
-    'POST v1ProjectsProjectIdPause': pauseProject,
-    'POST v1ProjectsProjectIdUnpause': unpauseProject,
-    'POST v1SecurityAttackMode': updateAttackChallengeMode,
-    'PUT v1SecurityFirewallConfig': putFirewallConfig,
-    'PATCH v1SecurityFirewallConfig': updateFirewallConfig,
-    'GET v1SecurityFirewallConfigConfigVersion': getFirewallConfig,
-    'GET v1SecurityFirewallAttackStatus': getActiveAttackStatus,
-    'GET v1SecurityFirewallBypass': getBypassIp,
-    'POST v1SecurityFirewallBypass': addBypassIp,
-    'DELETE v1SecurityFirewallBypass': removeBypassIp,
-    'GET v3TeamsTeamIdMembers': getTeamMembers,
-    'POST v1TeamsTeamIdMembers': inviteUserToTeam,
-    'POST v1TeamsTeamIdRequest': requestAccessToTeam,
-    'GET v1TeamsTeamIdRequestUserId': getTeamAccessRequest,
-    'POST v1TeamsTeamIdMembersTeamsJoin': joinTeam,
-    'PATCH v1TeamsTeamIdMembersUid': updateTeamMember,
-    'DELETE v1TeamsTeamIdMembersUid': removeTeamMember,
-    'GET v2TeamsTeamId': getTeam,
-    'PATCH v2TeamsTeamId': patchTeam,
-    'GET v2Teams': getTeams,
-    'POST v1Teams': createTeam,
-    'DELETE v1TeamsTeamId': deleteTeam,
-    'DELETE v1TeamsTeamIdInvitesInviteId': deleteTeamInviteCode,
-    'POST v2Files': uploadFile,
-    'GET v5UserTokens': listAuthTokens,
-    'POST v3UserTokens': createAuthToken,
-    'GET v5UserTokensTokenId': getAuthToken,
-    'DELETE v3UserTokensTokenId': deleteAuthToken,
-    'GET v2User': getAuthUser,
-    'DELETE v1User': requestDelete,
-    'POST v1Webhooks': createWebhook,
-    'GET v1Webhooks': getWebhooks,
-    'GET v1WebhooksId': getWebhook,
-    'DELETE v1WebhooksId': deleteWebhook,
-    'GET v2DeploymentsIdAliases': listDeploymentAliases,
-    'POST v2DeploymentsIdAliases': assignAlias,
-    'GET v4Aliases': listAliases,
-    'GET v4AliasesIdOrAlias': getAlias,
-    'DELETE v2AliasesAliasId': deleteAlias,
-    'PATCH aliasesIdProtectionBypass': patchUrlProtectionBypass,
-    'GET certs': listCerts,
-    'GET v8CertsId': getCertById,
-    'DELETE v8CertsId': removeCert,
-    'POST v8Certs': issueCert,
-    'PUT v8Certs': uploadCert,
-    'GET v6DeploymentsIdFiles': listDeploymentFiles,
-    'GET v8DeploymentsIdFilesFileId': getDeploymentFileContents,
-    'GET v6Deployments': getDeployments,
-    'DELETE v13DeploymentsId': deleteDeployment,
-    'GET v3Secrets': getSecrets,
-    'POST v2SecretsName': createSecret,
-    'PATCH v2SecretsName': renameSecret,
-    'GET v3SecretsIdOrName': getSecret,
-    'DELETE v2SecretsIdOrName': deleteSecret,
+    '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
 };
 exports.operationsByTag = {
     accessGroups: {
@@ -2942,21 +3184,21 @@ exports.operationsByTag = {
         createAccessGroupProject,
         readAccessGroupProject,
         updateAccessGroupProject,
-        deleteAccessGroupProject,
+        deleteAccessGroupProject
     },
     artifacts: {
         recordEvents,
         status,
         uploadArtifact,
         downloadArtifact,
-        artifactQuery,
+        artifactQuery
     },
     checks: {
         createCheck,
         getAllChecks,
         getCheck,
         updateCheck,
-        rerequestCheck,
+        rerequestCheck
     },
     projects: {
         updateProjectDataCache,
@@ -2983,7 +3225,7 @@ exports.operationsByTag = {
         requestPromote,
         listPromoteAliases,
         pauseProject,
-        unpauseProject,
+        unpauseProject
     },
     deployments: {
         getDeploymentEvents,
@@ -2995,13 +3237,13 @@ exports.operationsByTag = {
         listDeploymentFiles,
         getDeploymentFileContents,
         getDeployments,
-        deleteDeployment,
+        deleteDeployment
     },
     integrations: {
         updateIntegrationDeploymentAction,
         getConfigurations,
         getConfiguration,
-        deleteConfiguration,
+        deleteConfiguration
     },
     domains: {
         buyDomain,
@@ -3013,13 +3255,13 @@ exports.operationsByTag = {
         getDomains,
         createOrTransferDomain,
         patchDomain,
-        deleteDomain,
+        deleteDomain
     },
     dns: {
         getRecords,
         createRecord,
         updateRecord,
-        removeRecord,
+        removeRecord
     },
     edgeConfig: {
         getEdgeConfigs,
@@ -3038,12 +3280,12 @@ exports.operationsByTag = {
         getEdgeConfigToken,
         createEdgeConfigToken,
         getEdgeConfigBackup,
-        getEdgeConfigBackups,
+        getEdgeConfigBackups
     },
     user: {
         listUserEvents,
         getAuthUser,
-        requestDelete,
+        requestDelete
     },
     marketplace: {
         getAccountInfo,
@@ -3064,34 +3306,34 @@ exports.operationsByTag = {
         createExperimentationItem,
         updateExperimentationItem,
         deleteExperimentationItem,
-        updateExperimentationEdgeConfig,
+        updateExperimentationEdgeConfig
     },
     authentication: {
         exchangeSsoToken,
         listAuthTokens,
         createAuthToken,
         getAuthToken,
-        deleteAuthToken,
+        deleteAuthToken
     },
     logdrains: {
         getIntegrationLogDrains,
         createLogDrain,
-        deleteIntegrationLogDrain,
+        deleteIntegrationLogDrain
     },
     logs: {
-        getRuntimeLogs,
+        getRuntimeLogs
     },
     projectmembers: {
         getProjectMembers,
         addProjectMember,
-        removeProjectMember,
+        removeProjectMember
     },
     environment: {
         createCustomEnvironment,
         listCustomEnvironments,
         getCustomEnvironment,
         updateCustomEnvironment,
-        removeCustomEnvironment,
+        removeCustomEnvironment
     },
     rollingRelease: {
         getRollingReleaseBillingStatus,
@@ -3100,7 +3342,7 @@ exports.operationsByTag = {
         updateRollingReleaseConfig,
         getRollingRelease,
         approveRollingReleaseStage,
-        completeRollingRelease,
+        completeRollingRelease
     },
     security: {
         updateAttackChallengeMode,
@@ -3110,7 +3352,7 @@ exports.operationsByTag = {
         getActiveAttackStatus,
         getBypassIp,
         addBypassIp,
-        removeBypassIp,
+        removeBypassIp
     },
     teams: {
         getTeamMembers,
@@ -3125,13 +3367,13 @@ exports.operationsByTag = {
         getTeams,
         createTeam,
         deleteTeam,
-        deleteTeamInviteCode,
+        deleteTeamInviteCode
     },
     webhooks: {
         createWebhook,
         getWebhooks,
         getWebhook,
-        deleteWebhook,
+        deleteWebhook
     },
     aliases: {
         listDeploymentAliases,
@@ -3139,42 +3381,62 @@ exports.operationsByTag = {
         listAliases,
         getAlias,
         deleteAlias,
-        patchUrlProtectionBypass,
+        patchUrlProtectionBypass
     },
     certs: {
         getCertById,
         removeCert,
         issueCert,
-        uploadCert,
+        uploadCert
     },
     secrets: {
         getSecrets,
         createSecret,
         renameSecret,
         getSecret,
-        deleteSecret,
-    },
+        deleteSecret
+    }
 };
 exports.tagDictionary = {
     accessGroups: {
-        GET: ['readAccessGroup', 'listAccessGroupMembers', 'listAccessGroups', 'listAccessGroupProjects', 'readAccessGroupProject'],
+        GET: [
+            'readAccessGroup',
+            'listAccessGroupMembers',
+            'listAccessGroups',
+            'listAccessGroupProjects',
+            'readAccessGroupProject'
+        ],
         POST: ['updateAccessGroup', 'createAccessGroup', 'createAccessGroupProject'],
         DELETE: ['deleteAccessGroup', 'deleteAccessGroupProject'],
-        PATCH: ['updateAccessGroupProject'],
+        PATCH: ['updateAccessGroupProject']
     },
     artifacts: {
         POST: ['recordEvents', 'artifactQuery'],
         GET: ['status', 'downloadArtifact'],
-        PUT: ['uploadArtifact'],
+        PUT: ['uploadArtifact']
     },
     checks: {
         POST: ['createCheck', 'rerequestCheck'],
         GET: ['getAllChecks', 'getCheck'],
-        PATCH: ['updateCheck'],
+        PATCH: ['updateCheck']
     },
     projects: {
-        PATCH: ['updateProjectDataCache', 'updateProject', 'updateProjectDomain', 'editProjectEnv', 'updateProjectProtectionBypass'],
-        GET: ['getProjects', 'getProject', 'getProjectDomains', 'getProjectDomain', 'filterProjectEnvs', 'getProjectEnv', 'listPromoteAliases'],
+        PATCH: [
+            'updateProjectDataCache',
+            'updateProject',
+            'updateProjectDomain',
+            'editProjectEnv',
+            'updateProjectProtectionBypass'
+        ],
+        GET: [
+            'getProjects',
+            'getProject',
+            'getProjectDomains',
+            'getProjectDomain',
+            'filterProjectEnvs',
+            'getProjectEnv',
+            'listPromoteAliases'
+        ],
         POST: [
             'createProject',
             'addProjectDomain',
@@ -3184,33 +3446,33 @@ exports.tagDictionary = {
             'createProjectTransferRequest',
             'requestPromote',
             'pauseProject',
-            'unpauseProject',
+            'unpauseProject'
         ],
         DELETE: ['deleteProject', 'removeProjectDomain', 'removeProjectEnv'],
-        PUT: ['acceptProjectTransferRequest'],
+        PUT: ['acceptProjectTransferRequest']
     },
     deployments: {
         GET: ['getDeploymentEvents', 'getDeployment', 'listDeploymentFiles', 'getDeploymentFileContents', 'getDeployments'],
         PATCH: ['updateIntegrationDeploymentAction', 'cancelDeployment'],
         POST: ['createDeployment', 'uploadFile'],
-        DELETE: ['deleteDeployment'],
+        DELETE: ['deleteDeployment']
     },
     integrations: {
         PATCH: ['updateIntegrationDeploymentAction'],
         GET: ['getConfigurations', 'getConfiguration'],
-        DELETE: ['deleteConfiguration'],
+        DELETE: ['deleteConfiguration']
     },
     domains: {
         POST: ['buyDomain', 'createOrTransferDomain'],
         GET: ['checkDomainPrice', 'checkDomainStatus', 'getDomainTransfer', 'getDomainConfig', 'getDomain', 'getDomains'],
         PATCH: ['patchDomain'],
-        DELETE: ['deleteDomain'],
+        DELETE: ['deleteDomain']
     },
     dns: {
         GET: ['getRecords'],
         POST: ['createRecord'],
         PATCH: ['updateRecord'],
-        DELETE: ['removeRecord'],
+        DELETE: ['removeRecord']
     },
     edgeConfig: {
         GET: [
@@ -3222,88 +3484,96 @@ exports.tagDictionary = {
             'getEdgeConfigTokens',
             'getEdgeConfigToken',
             'getEdgeConfigBackup',
-            'getEdgeConfigBackups',
+            'getEdgeConfigBackups'
         ],
         POST: ['createEdgeConfig', 'patchEdgeConfigSchema', 'createEdgeConfigToken'],
         PUT: ['updateEdgeConfig'],
         DELETE: ['deleteEdgeConfig', 'deleteEdgeConfigSchema', 'deleteEdgeConfigTokens'],
-        PATCH: ['patchEdgeConfigItems'],
+        PATCH: ['patchEdgeConfigItems']
     },
     user: {
         GET: ['listUserEvents', 'getAuthUser'],
-        DELETE: ['requestDelete'],
+        DELETE: ['requestDelete']
     },
     marketplace: {
         GET: ['getAccountInfo', 'getMember', 'getIntegrationResources', 'getIntegrationResource', 'getInvoice'],
-        POST: ['createEvent', 'submitBillingData', 'submitInvoice', 'updateInvoice', 'submitPrepaymentBalances', 'exchangeSsoToken', 'createExperimentationItem'],
+        POST: [
+            'createEvent',
+            'submitBillingData',
+            'submitInvoice',
+            'updateInvoice',
+            'submitPrepaymentBalances',
+            'exchangeSsoToken',
+            'createExperimentationItem'
+        ],
         DELETE: ['deleteIntegrationResource', 'deleteExperimentationItem'],
         PUT: ['importResource', 'updateResourceSecrets', 'updateResourceSecretsById', 'updateExperimentationEdgeConfig'],
-        PATCH: ['updateExperimentationItem'],
+        PATCH: ['updateExperimentationItem']
     },
     authentication: {
         POST: ['exchangeSsoToken', 'createAuthToken'],
         GET: ['listAuthTokens', 'getAuthToken'],
-        DELETE: ['deleteAuthToken'],
+        DELETE: ['deleteAuthToken']
     },
     logdrains: {
         GET: ['getIntegrationLogDrains'],
         POST: ['createLogDrain'],
-        DELETE: ['deleteIntegrationLogDrain'],
+        DELETE: ['deleteIntegrationLogDrain']
     },
     logs: {
-        GET: ['getRuntimeLogs'],
+        GET: ['getRuntimeLogs']
     },
     projectmembers: {
         GET: ['getProjectMembers'],
         POST: ['addProjectMember'],
-        DELETE: ['removeProjectMember'],
+        DELETE: ['removeProjectMember']
     },
     environment: {
         POST: ['createCustomEnvironment'],
         GET: ['listCustomEnvironments', 'getCustomEnvironment'],
         PATCH: ['updateCustomEnvironment'],
-        DELETE: ['removeCustomEnvironment'],
+        DELETE: ['removeCustomEnvironment']
     },
     rollingRelease: {
         GET: ['getRollingReleaseBillingStatus', 'getRollingReleaseConfig', 'getRollingRelease'],
         DELETE: ['deleteRollingReleaseConfig'],
         PATCH: ['updateRollingReleaseConfig'],
-        POST: ['approveRollingReleaseStage', 'completeRollingRelease'],
+        POST: ['approveRollingReleaseStage', 'completeRollingRelease']
     },
     security: {
         POST: ['updateAttackChallengeMode', 'addBypassIp'],
         PUT: ['putFirewallConfig'],
         PATCH: ['updateFirewallConfig'],
         GET: ['getFirewallConfig', 'getActiveAttackStatus', 'getBypassIp'],
-        DELETE: ['removeBypassIp'],
+        DELETE: ['removeBypassIp']
     },
     teams: {
         GET: ['getTeamMembers', 'getTeamAccessRequest', 'getTeam', 'getTeams'],
         POST: ['inviteUserToTeam', 'requestAccessToTeam', 'joinTeam', 'createTeam'],
         PATCH: ['updateTeamMember', 'patchTeam'],
-        DELETE: ['removeTeamMember', 'deleteTeam', 'deleteTeamInviteCode'],
+        DELETE: ['removeTeamMember', 'deleteTeam', 'deleteTeamInviteCode']
     },
     webhooks: {
         POST: ['createWebhook'],
         GET: ['getWebhooks', 'getWebhook'],
-        DELETE: ['deleteWebhook'],
+        DELETE: ['deleteWebhook']
     },
     aliases: {
         GET: ['listDeploymentAliases', 'listAliases', 'getAlias'],
         POST: ['assignAlias'],
         DELETE: ['deleteAlias'],
-        PATCH: ['patchUrlProtectionBypass'],
+        PATCH: ['patchUrlProtectionBypass']
     },
     certs: {
         GET: ['getCertById'],
         DELETE: ['removeCert'],
         POST: ['issueCert'],
-        PUT: ['uploadCert'],
+        PUT: ['uploadCert']
     },
     secrets: {
         GET: ['getSecrets', 'getSecret'],
         POST: ['createSecret'],
         PATCH: ['renameSecret'],
-        DELETE: ['deleteSecret'],
-    },
+        DELETE: ['deleteSecret']
+    }
 };