@envsync-cloud/envsync-ts-sdk 0.11.0 → 0.20.2

package/dist/index.js

@@ -32,8 +32,21 @@ __export(src_exports, {
   CertificatesService: () => CertificatesService,
   ChangeRequestResponse: () => ChangeRequestResponse,
   ChangeRequestsService: () => ChangeRequestsService,
+  CreateDynamicSecretEngineRequest: () => CreateDynamicSecretEngineRequest,
+  CreateIntegrationBindingRequest: () => CreateIntegrationBindingRequest,
+  CreateLogForwardingRequest: () => CreateLogForwardingRequest,
+  CreateManualSyncRunRequest: () => CreateManualSyncRunRequest,
+  CreateOidcProviderRequest: () => CreateOidcProviderRequest,
+  CreateProviderConnectionRequest: () => CreateProviderConnectionRequest,
+  CreateRotationPolicyRequest: () => CreateRotationPolicyRequest,
+  CreateSamlProviderRequest: () => CreateSamlProviderRequest,
   CreateWebhookRequest: () => CreateWebhookRequest,
+  DynamicSecretEngineResponse: () => DynamicSecretEngineResponse,
+  DynamicSecretsService: () => DynamicSecretsService,
   EffectiveAccessEntry: () => EffectiveAccessEntry,
+  EnterpriseCmkService: () => EnterpriseCmkService,
+  EnterpriseProviderProfile: () => EnterpriseProviderProfile,
+  EnterpriseService: () => EnterpriseService,
   EnvSyncAPISDK: () => EnvSyncAPISDK,
   EnvironmentTypesService: () => EnvironmentTypesService,
   EnvironmentVariablesPointInTimeService: () => EnvironmentVariablesPointInTimeService,
@@ -45,29 +58,53 @@ __export(src_exports, {
   GpgKeysService: () => GpgKeysService,
   GrantAccessRequest: () => GrantAccessRequest,
   GrantEntry: () => GrantEntry,
+  IntegrationBinding: () => IntegrationBinding,
+  LicenseService: () => LicenseService,
   LicenseState: () => LicenseState,
+  LogForwardingResponse: () => LogForwardingResponse,
+  LogForwardingService: () => LogForwardingService,
+  OidcProviderResponse: () => OidcProviderResponse,
+  OidcProvidersService: () => OidcProvidersService,
   OnboardingService: () => OnboardingService,
   OpenAPI: () => OpenAPI,
+  OrgFeaturesService: () => OrgFeaturesService,
+  OrgKmsConfigResponse: () => OrgKmsConfigResponse,
+  OrgKmsJobResponse: () => OrgKmsJobResponse,
+  OrgKmsVerifyResponse: () => OrgKmsVerifyResponse,
   OrganizationsService: () => OrganizationsService,
   PermissionsService: () => PermissionsService,
+  ProviderConnection: () => ProviderConnection,
+  PutOrgFeatureGrantRequest: () => PutOrgFeatureGrantRequest,
   RevokeAccessRequest: () => RevokeAccessRequest,
   RolesService: () => RolesService,
   RotateGpgKeyRequest: () => RotateGpgKeyRequest,
+  RotationPolicyResponse: () => RotationPolicyResponse,
+  RotationService: () => RotationService,
+  SamlProviderResponse: () => SamlProviderResponse,
+  SamlProvidersService: () => SamlProvidersService,
+  SamlSsoService: () => SamlSsoService,
   SecretVariableRollbackResponse: () => SecretVariableRollbackResponse,
   SecretsPointInTimeService: () => SecretsPointInTimeService,
   SecretsRollbackService: () => SecretsRollbackService,
   SecretsService: () => SecretsService,
   ServiceTokensService: () => ServiceTokensService,
+  SetupService: () => SetupService,
+  SetupStatusResponse: () => SetupStatusResponse,
   SignDataRequest: () => SignDataRequest,
+  SyncAuditEvent: () => SyncAuditEvent,
+  SyncRun: () => SyncRun,
   SystemService: () => SystemService,
   SystemStatusState: () => SystemStatusState,
   TeamsService: () => TeamsService,
+  UpdateOrgKmsConfigRequest: () => UpdateOrgKmsConfigRequest,
+  UpdateProviderConnectionRequest: () => UpdateProviderConnectionRequest,
   UpdateTrustLevelRequest: () => UpdateTrustLevelRequest,
   UpdateWebhookRequest: () => UpdateWebhookRequest,
   UsersService: () => UsersService,
   VariableRollbackResponse: () => VariableRollbackResponse,
   WebhookResponse: () => WebhookResponse,
-  WebhooksService: () => WebhooksService
+  WebhooksService: () => WebhooksService,
+  WhoAmIResponse: () => WhoAmIResponse
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -825,23 +862,23 @@ var AuthenticationService = class {
     });
   }
   /**
-   * Create Workspace
-   * Create a new workspace for the current enterprise web session and switch into it
+   * Create Organization
+   * Create a new organization for the current hosted web session and switch into it. Hosted only; self-host always 403.
    * @param requestBody
-   * @returns WhoAmIResponse Workspace created successfully
+   * @returns WhoAmIResponse Organization created successfully
    * @throws ApiError
    */
-  createWorkspace(requestBody) {
+  createOrganization(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/auth/create-workspace",
+      url: "/api/auth/create-organization",
       body: requestBody,
       mediaType: "application/json",
       errors: {
         400: `Invalid request`,
         401: `Cookie session required`,
-        403: `Enterprise edition required`,
-        409: `Workspace slug conflict`
+        403: `Not allowed on this deployment (e.g. self-host)`,
+        409: `Organization slug conflict or org limit reached`
       }
     });
   }
@@ -1217,274 +1254,269 @@ var ChangeRequestsService = class {
   }
 };
 
-// src/services/EnvironmentTypesService.ts
-var EnvironmentTypesService = class {
+// src/services/DynamicSecretsService.ts
+var DynamicSecretsService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
   /**
-   * Get Environment Types
-   * Retrieve all environment types for the organization
-   * @returns EnvTypesResponse Environment types retrieved successfully
+   * Create Dynamic Secret Engine
+   * Create a new dynamic secret engine for short-lived credential generation
+   * @param requestBody
+   * @returns DynamicSecretEngineResponse Engine created successfully
    * @throws ApiError
    */
-  getEnvTypes() {
+  createDynamicSecretEngine(requestBody) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/env_type",
+      method: "POST",
+      url: "/api/v1/manage/dynamic_secret/engines",
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
+        400: `Validation error`,
+        409: `Engine name conflict`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Create Environment Type
-   * Create a new environment type
-   * @param requestBody
-   * @returns EnvTypeResponse Environment type created successfully
+   * Get All Dynamic Secret Engines
+   * Retrieve all dynamic secret engines for the organization
+   * @returns DynamicSecretEnginesResponse Engines retrieved successfully
    * @throws ApiError
    */
-  createEnvType(requestBody) {
+  getAllDynamicSecretEngines() {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env_type",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/dynamic_secret/engines",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Get Environment Type
-   * Retrieve a specific environment type
+   * Get Dynamic Secret Engine
+   * Retrieve a specific dynamic secret engine by ID
    * @param id
-   * @returns EnvTypeResponse Environment type retrieved successfully
+   * @returns DynamicSecretEngineResponse Engine retrieved successfully
    * @throws ApiError
    */
-  getEnvType(id) {
+  getDynamicSecretEngine(id) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/env_type/{id}",
+      url: "/api/v1/manage/dynamic_secret/engines/{id}",
       path: {
         "id": id
       },
       errors: {
+        404: `Engine not found`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Update Environment Type
-   * Update an existing environment type
+   * Update Dynamic Secret Engine
+   * Update an existing dynamic secret engine
    * @param id
    * @param requestBody
-   * @returns EnvTypeResponse Environment type updated successfully
+   * @returns DynamicSecretEngineResponse Engine updated successfully
    * @throws ApiError
    */
-  updateEnvType(id, requestBody) {
+  updateDynamicSecretEngine(id, requestBody) {
     return this.httpRequest.request({
       method: "PATCH",
-      url: "/api/env_type/{id}",
+      url: "/api/v1/manage/dynamic_secret/engines/{id}",
       path: {
         "id": id
       },
       body: requestBody,
       mediaType: "application/json",
       errors: {
+        404: `Engine not found`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Delete Environment Type
-   * Delete an existing environment type
+   * Delete Dynamic Secret Engine
+   * Delete a dynamic secret engine (must have no active leases)
    * @param id
-   * @returns DeleteEnvTypeRequest Environment type deleted successfully
+   * @returns ErrorResponse Engine deleted successfully
    * @throws ApiError
    */
-  deleteEnvType(id) {
+  deleteDynamicSecretEngine(id) {
     return this.httpRequest.request({
       method: "DELETE",
-      url: "/api/env_type/{id}",
+      url: "/api/v1/manage/dynamic_secret/engines/{id}",
       path: {
         "id": id
       },
       errors: {
+        404: `Engine not found`,
+        409: `Engine has active leases`,
         500: `Internal server error`
       }
     });
   }
-};
-
-// src/services/EnvironmentVariablesService.ts
-var EnvironmentVariablesService = class {
-  constructor(httpRequest) {
-    this.httpRequest = httpRequest;
-  }
   /**
-   * Export Environment
-   * Export environment variables and optionally secrets for an application environment in a single payload.
+   * Create Dynamic Secret Lease
+   * Generate short-lived credentials by creating a lease on an engine
+   * @param id
    * @param requestBody
-   * @returns ExportEnvResponse Environment exported successfully
+   * @returns DynamicSecretLeaseResponse Lease created successfully
    * @throws ApiError
    */
-  exportEnvironment(requestBody) {
+  createDynamicSecretLease(id, requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/env/export",
+      url: "/api/v1/manage/dynamic_secret/engines/{id}/leases",
+      path: {
+        "id": id
+      },
       body: requestBody,
       mediaType: "application/json",
       errors: {
-        400: `Invalid export request`
+        400: `Validation error`,
+        404: `Engine not found`,
+        500: `Internal server error`
       }
     });
   }
   /**
-   * Get Environment Variables
-   * Retrieve all environment variables for an application and environment type
-   * @param requestBody
-   * @returns EnvsResponse Environment variables retrieved successfully
+   * Get Leases for Engine
+   * Retrieve all leases for a specific dynamic secret engine
+   * @param id
+   * @returns DynamicSecretLeasesResponse Leases retrieved successfully
    * @throws ApiError
    */
-  getEnvs(requestBody) {
+  getDynamicSecretLeases(id) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/dynamic_secret/engines/{id}/leases",
+      path: {
+        "id": id
+      },
       errors: {
+        404: `Engine not found`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Delete Environment Variable
-   * Delete an existing environment variable
-   * @param requestBody
-   * @returns DeleteEnvRequest Environment variable deleted successfully
+   * Get Dynamic Secret Lease
+   * Retrieve a specific lease by ID
+   * @param leaseId
+   * @returns DynamicSecretLeaseResponse Lease retrieved successfully
    * @throws ApiError
    */
-  deleteEnv(requestBody) {
+  getDynamicSecretLease(leaseId) {
     return this.httpRequest.request({
-      method: "DELETE",
-      url: "/api/env",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/dynamic_secret/leases/{leaseId}",
+      path: {
+        "leaseId": leaseId
+      },
       errors: {
+        404: `Lease not found`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Get Single Environment Variable
-   * Retrieve a specific environment variable
-   * @param key
-   * @param requestBody
-   * @returns EnvResponse Environment variable retrieved successfully
+   * Revoke Dynamic Secret Lease
+   * Revoke a lease and its associated credentials
+   * @param leaseId
+   * @returns RevokeLeaseResponse Lease revoked successfully
    * @throws ApiError
    */
-  getEnv(key, requestBody) {
+  revokeDynamicSecretLease(leaseId) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/env/i/{key}",
+      url: "/api/v1/manage/dynamic_secret/leases/{leaseId}/revoke",
       path: {
-        "key": key
+        "leaseId": leaseId
       },
-      body: requestBody,
-      mediaType: "application/json",
       errors: {
+        404: `Lease not found`,
+        409: `Lease already revoked`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Update Environment Variable
-   * Update an existing environment variable
-   * @param key
-   * @param requestBody
-   * @returns EnvResponse Environment variable updated successfully
+   * Cleanup Expired Leases
+   * Mark all expired leases as revoked (admin operation)
+   * @returns CleanupResponse Cleanup completed
    * @throws ApiError
    */
-  updateEnv(key, requestBody) {
+  cleanupExpiredLeases() {
     return this.httpRequest.request({
-      method: "PATCH",
-      url: "/api/env/i/{key}",
-      path: {
-        "key": key
-      },
-      body: requestBody,
-      mediaType: "application/json",
+      method: "POST",
+      url: "/api/v1/manage/dynamic_secret/leases/cleanup",
       errors: {
         500: `Internal server error`
       }
     });
   }
+};
+
+// src/services/EnterpriseService.ts
+var EnterpriseService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
   /**
-   * Create Environment Variable
-   * Create a new environment variable
-   * @param requestBody
-   * @returns EnvResponse Environment variable created successfully
+   * List Enterprise Providers
+   * @returns EnterpriseProvidersResponse Enterprise provider catalog
    * @throws ApiError
    */
-  createEnv(requestBody) {
+  listEnterpriseProviders() {
     return this.httpRequest.request({
-      method: "PUT",
-      url: "/api/env/single",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/enterprise/providers",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Batch Create Environment Variables
-   * Create multiple environment variables in a single request
-   * @param requestBody
-   * @returns BatchEnvsResponse Environment variables created successfully
+   * Get Enterprise Org Secret Model
+   * @returns OrgSecretModelResponse Org secret model
    * @throws ApiError
    */
-  batchCreateEnvs(requestBody) {
+  getEnterpriseOrgSecretModel() {
     return this.httpRequest.request({
-      method: "PUT",
-      url: "/api/env/batch",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/enterprise/org-secrets/model",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Batch Update Environment Variables
-   * Update multiple environment variables in a single request
-   * @param requestBody
-   * @returns BatchEnvsResponse Environment variables updated successfully
+   * List Enterprise Provider Connections
+   * @returns ProviderConnectionsResponse Provider connections
    * @throws ApiError
    */
-  batchUpdateEnvs(requestBody) {
+  listEnterpriseProviderConnections() {
     return this.httpRequest.request({
-      method: "PATCH",
-      url: "/api/env/batch",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/enterprise/provider-connections",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Batch Delete Environment Variables
-   * Delete multiple environment variables in a single request
+   * Create Enterprise Provider Connection
    * @param requestBody
-   * @returns BatchEnvsResponse Environment variables deleted successfully
+   * @returns ProviderConnection Provider connection created
    * @throws ApiError
    */
-  deleteBatchEnv(requestBody) {
+  createEnterpriseProviderConnection(requestBody) {
     return this.httpRequest.request({
-      method: "DELETE",
-      url: "/api/env/batch",
+      method: "POST",
+      url: "/api/v1/manage/enterprise/provider-connections",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1492,24 +1524,20 @@ var EnvironmentVariablesService = class {
       }
     });
   }
-};
-
-// src/services/EnvironmentVariablesPointInTimeService.ts
-var EnvironmentVariablesPointInTimeService = class {
-  constructor(httpRequest) {
-    this.httpRequest = httpRequest;
-  }
   /**
-   * Get Environment Variables History
-   * Retrieve paginated history of environment variable changes
+   * Update Enterprise Provider Connection
+   * @param id
    * @param requestBody
-   * @returns EnvHistoryResponse Environment variables history retrieved successfully
+   * @returns ProviderConnection Provider connection updated
    * @throws ApiError
    */
-  getEnvHistory(requestBody) {
+  updateEnterpriseProviderConnection(id, requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env/history",
+      method: "PATCH",
+      url: "/api/v1/manage/enterprise/provider-connections/{id}",
+      path: {
+        "id": id
+      },
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1518,34 +1546,29 @@ var EnvironmentVariablesPointInTimeService = class {
     });
   }
   /**
-   * Get Environment Variables at Point in Time
-   * Retrieve environment variables state at a specific point in time
-   * @param requestBody
-   * @returns EnvPitStateResponse Environment variables at point in time retrieved successfully
+   * List Enterprise Org Secrets
+   * @returns OrgSecretsResponse Org secrets
    * @throws ApiError
    */
-  getEnvsAtPointInTime(requestBody) {
+  listEnterpriseOrgSecrets() {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env/pit",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/enterprise/org-secrets",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Get Environment Variables at Timestamp
-   * Retrieve environment variables state at a specific timestamp
+   * Create Enterprise Org Secret
    * @param requestBody
-   * @returns EnvPitStateResponse Environment variables at timestamp retrieved successfully
+   * @returns OrgSecret Org secret created
    * @throws ApiError
    */
-  getEnvsAtTimestamp(requestBody) {
+  createEnterpriseOrgSecret(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/env/timestamp",
+      url: "/api/v1/manage/enterprise/org-secrets",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1554,16 +1577,19 @@ var EnvironmentVariablesPointInTimeService = class {
     });
   }
   /**
-   * Get Environment Variables Diff
-   * Compare environment variables between two points in time
+   * Update Enterprise Org Secret
+   * @param id
    * @param requestBody
-   * @returns EnvDiffResponse Environment variables diff retrieved successfully
+   * @returns OrgSecret Org secret updated
    * @throws ApiError
    */
-  getEnvDiff(requestBody) {
+  updateEnterpriseOrgSecret(id, requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env/diff",
+      method: "PATCH",
+      url: "/api/v1/manage/enterprise/org-secrets/{id}",
+      path: {
+        "id": id
+      },
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1572,37 +1598,36 @@ var EnvironmentVariablesPointInTimeService = class {
     });
   }
   /**
-   * Get Environment Variables Diff By Timestamp Range
-   * Compare environment variables between two timestamps
-   * @param requestBody
-   * @returns EnvDiffResponse Environment variables timestamp-range diff retrieved successfully
+   * List Enterprise Integration Bindings
+   * @param appId
+   * @returns IntegrationBindingsResponse Integration bindings
    * @throws ApiError
    */
-  getEnvDiffByTimestampRange(requestBody) {
+  listEnterpriseIntegrationBindings(appId) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env/diff/timestamp-range",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/enterprise/apps/{app_id}/bindings",
+      path: {
+        "app_id": appId
+      },
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Get Variable Timeline
-   * Get timeline of changes for a specific environment variable
-   * @param key
+   * Create Enterprise Integration Binding
+   * @param appId
    * @param requestBody
-   * @returns VariableTimelineResponse Variable timeline retrieved successfully
+   * @returns IntegrationBinding Integration binding created
    * @throws ApiError
    */
-  getVariableTimeline(key, requestBody) {
+  createEnterpriseIntegrationBinding(appId, requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/env/timeline/{key}",
+      url: "/api/v1/manage/enterprise/apps/{app_id}/bindings",
       path: {
-        "key": key
+        "app_id": appId
       },
       body: requestBody,
       mediaType: "application/json",
@@ -1611,24 +1636,22 @@ var EnvironmentVariablesPointInTimeService = class {
       }
     });
   }
-};
-
-// src/services/EnvironmentVariablesRollbackService.ts
-var EnvironmentVariablesRollbackService = class {
-  constructor(httpRequest) {
-    this.httpRequest = httpRequest;
-  }
   /**
-   * Rollback Environment Variables to Point in Time
-   * Rollback all environment variables to a specific point in time
+   * Update Enterprise Integration Binding
+   * @param appId
+   * @param id
    * @param requestBody
-   * @returns RollbackResponse Environment variables rolled back successfully
+   * @returns IntegrationBinding Integration binding updated
    * @throws ApiError
    */
-  rollbackEnvsToPitId(requestBody) {
+  updateEnterpriseIntegrationBinding(appId, id, requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env/rollback/pit",
+      method: "PATCH",
+      url: "/api/v1/manage/enterprise/apps/{app_id}/bindings/{id}",
+      path: {
+        "app_id": appId,
+        "id": id
+      },
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1637,37 +1660,36 @@ var EnvironmentVariablesRollbackService = class {
     });
   }
   /**
-   * Rollback Environment Variables to Timestamp
-   * Rollback all environment variables to a specific timestamp
-   * @param requestBody
-   * @returns RollbackResponse Environment variables rolled back successfully
+   * List Enterprise Env-Type Mappings
+   * @param appId
+   * @returns EnvTypeMappingsResponse Env-type mappings
    * @throws ApiError
    */
-  rollbackEnvsToTimestamp(requestBody) {
+  listEnterpriseEnvTypeMappings(appId) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env/rollback/timestamp",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/enterprise/apps/{app_id}/env-type-mappings",
+      path: {
+        "app_id": appId
+      },
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Rollback Single Variable to Point in Time
-   * Rollback a specific environment variable to a point in time
-   * @param key
+   * Create Enterprise Env-Type Mapping
+   * @param appId
    * @param requestBody
-   * @returns VariableRollbackResponse Variable rolled back successfully
+   * @returns EnvTypeMapping Env-type mapping created
    * @throws ApiError
    */
-  rollbackVariableToPitId(key, requestBody) {
+  createEnterpriseEnvTypeMapping(appId, requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/env/rollback/variable/{key}/pit",
+      url: "/api/v1/manage/enterprise/apps/{app_id}/env-type-mappings",
       path: {
-        "key": key
+        "app_id": appId
       },
       body: requestBody,
       mediaType: "application/json",
@@ -1677,19 +1699,20 @@ var EnvironmentVariablesRollbackService = class {
     });
   }
   /**
-   * Rollback Single Variable to Timestamp
-   * Rollback a specific environment variable to a timestamp
-   * @param key
+   * Update Enterprise Env-Type Mapping
+   * @param appId
+   * @param id
    * @param requestBody
-   * @returns VariableRollbackResponse Variable rolled back successfully
+   * @returns EnvTypeMapping Env-type mapping updated
    * @throws ApiError
    */
-  rollbackVariableToTimestamp(key, requestBody) {
+  updateEnterpriseEnvTypeMapping(appId, id, requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env/rollback/variable/{key}/timestamp",
+      method: "PATCH",
+      url: "/api/v1/manage/enterprise/apps/{app_id}/env-type-mappings/{id}",
       path: {
-        "key": key
+        "app_id": appId,
+        "id": id
       },
       body: requestBody,
       mediaType: "application/json",
@@ -1698,26 +1721,50 @@ var EnvironmentVariablesRollbackService = class {
       }
     });
   }
-};
-
-// src/services/FileUploadService.ts
-var FileUploadService = class {
-  constructor(httpRequest) {
-    this.httpRequest = httpRequest;
+  /**
+   * List Enterprise Sync Runs
+   * @returns SyncRunsResponse Sync runs
+   * @throws ApiError
+   */
+  listEnterpriseSyncRuns() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/enterprise/sync-runs",
+      errors: {
+        500: `Internal server error`
+      }
+    });
   }
   /**
-   * Upload File
-   * Upload a file to the server. The file should be less than 5MB in size.
-   * @param formData
-   * @returns UploadFileResponse File uploaded successfully
+   * Create Enterprise Manual Sync Run
+   * @param requestBody
+   * @returns SyncRun Sync run created
    * @throws ApiError
    */
-  uploadFile(formData) {
+  createEnterpriseManualSyncRun(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/upload/file",
-      formData,
-      mediaType: "multipart/form-data",
+      url: "/api/v1/manage/enterprise/sync-runs/manual",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List Enterprise Sync Audit Events
+   * @param syncRunId
+   * @returns SyncAuditEventsResponse Sync audit events
+   * @throws ApiError
+   */
+  listEnterpriseSyncAuditEvents(syncRunId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/enterprise/sync-runs/{sync_run_id}/events",
+      path: {
+        "sync_run_id": syncRunId
+      },
       errors: {
         500: `Internal server error`
       }
@@ -1725,58 +1772,82 @@ var FileUploadService = class {
   }
 };
 
-// src/services/GpgKeysService.ts
-var GpgKeysService = class {
+// src/services/EnterpriseCmkService.ts
+var EnterpriseCmkService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
   /**
-   * Generate GPG Key
-   * Generate a new GPG key pair for the organization
-   * @param requestBody
-   * @returns GpgKeyResponse GPG key generated successfully
+   * Break-glass detach organization CMK
+   * Hosted platform API. Enqueues detach-to-managed even if the org lost the kms grant or status is unavailable. Does not call ensureTenantKek.
+   * @param xEnvSyncPlatformToken
+   * @param orgId
+   * @returns OrgKmsJobResponse Already on managed wrapping
    * @throws ApiError
    */
-  generateGpgKey(requestBody) {
+  breakGlassDetachOrgKms(xEnvSyncPlatformToken, orgId) {
     return this.httpRequest.request({
-      method: "PUT",
-      url: "/api/gpg_key/generate",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "POST",
+      url: "/api/v1/manage/kms/{orgId}/break-glass-detach",
+      path: {
+        "orgId": orgId
+      },
+      headers: {
+        "X-EnvSync-Platform-Token": xEnvSyncPlatformToken
+      },
       errors: {
+        401: `Invalid platform token`,
+        403: `Not hosted`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Import GPG Key
-   * Import an existing GPG key into the organization
+   * Get organization KMS config
+   * Returns implicit managed/active when no org_kms_config row exists. Never returns key material.
+   * @returns OrgKmsConfigResponse Organization KMS config
+   * @throws ApiError
+   */
+  getOrgKmsConfig() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/kms",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update organization KMS config
+   * Self-host cloud sources return 403 CMK_HOSTED_ONLY. Hosted persists cloud source as pending until attach.
    * @param requestBody
-   * @returns GpgKeyResponse GPG key imported successfully
+   * @returns OrgKmsConfigResponse Organization KMS config updated
    * @throws ApiError
    */
-  importGpgKey(requestBody) {
+  updateOrgKmsConfig(requestBody) {
     return this.httpRequest.request({
       method: "PUT",
-      url: "/api/gpg_key/import",
+      url: "/api/v1/manage/kms",
       body: requestBody,
       mediaType: "application/json",
       errors: {
+        403: `Cloud CMK is Hosted-only`,
+        409: `A rewrap job is already running`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Sign Data
-   * Sign data using a GPG key
+   * Create a purpose=kms org secret
+   * Encrypts the value under scope __kms_config__ before insert. Does not require the integrations feature.
    * @param requestBody
-   * @returns SignatureResponse Data signed successfully
+   * @returns OrgKmsCredentialResponse Credential created (value redacted)
    * @throws ApiError
    */
-  signDataWithGpgKey(requestBody) {
+  createOrgKmsCredential(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/gpg_key/sign",
+      url: "/api/v1/manage/kms/credentials",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1785,110 +1856,137 @@ var GpgKeysService = class {
     });
   }
   /**
-   * Verify Signature
-   * Verify a GPG signature
-   * @param requestBody
-   * @returns VerifyResponse Verification result
+   * Verify organization KMS
+   * Managed source succeeds immediately. Cloud verify unwraps or first-wraps the tenant KEK.
+   * @returns OrgKmsVerifyResponse Verify result
    * @throws ApiError
    */
-  verifyGpgSignature(requestBody) {
+  verifyOrgKms() {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/gpg_key/verify",
-      body: requestBody,
-      mediaType: "application/json",
+      url: "/api/v1/manage/kms/verify",
+      errors: {
+        500: `Internal server error`,
+        503: `CMK unavailable`
+      }
+    });
+  }
+  /**
+   * Rotate organization KEK
+   * Re-wraps wrapped_kek under the current key_ref. Hosted cloud-only; does not rewrap DEKs.
+   * @returns OrgKmsConfigResponse KEK rotated
+   * @throws ApiError
+   */
+  rotateOrgKmsKek() {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/kms/rotate-kek",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * List GPG Keys
-   * List all GPG keys for the organization
-   * @returns GpgKeysResponse GPG keys retrieved successfully
+   * Attach organization CMK
+   * Enqueues DEK rewrap under the tenant KEK with allow_root_unwrap during the attach window. Hosted only.
+   * @returns OrgKmsJobResponse Attach job enqueued
    * @throws ApiError
    */
-  listGpgKeys() {
+  attachOrgKms() {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/gpg_key",
+      method: "POST",
+      url: "/api/v1/manage/kms/attach",
       errors: {
+        403: `Cloud CMK is Hosted-only`,
+        409: `A rewrap job is already running`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Get GPG Key
-   * Retrieve a specific GPG key
-   * @param id
-   * @returns GpgKeyDetailResponse GPG key retrieved successfully
+   * Detach organization CMK to managed
+   * Enqueues detach_managed. Does not call ensureTenantKek when status is unavailable.
+   * @returns OrgKmsJobResponse Detach job enqueued
    * @throws ApiError
    */
-  getGpgKey(id) {
+  detachOrgKms() {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/gpg_key/{id}",
-      path: {
-        "id": id
-      },
+      method: "POST",
+      url: "/api/v1/manage/kms/detach",
       errors: {
+        409: `A rewrap job is already running`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Delete GPG Key
-   * Delete a GPG key from the organization
+   * Get organization KMS job
    * @param id
-   * @returns GpgKeyResponse GPG key deleted successfully
+   * @returns OrgKmsJobResponse KMS job
    * @throws ApiError
    */
-  deleteGpgKey(id) {
+  getOrgKmsJob(id) {
     return this.httpRequest.request({
-      method: "DELETE",
-      url: "/api/gpg_key/{id}",
+      method: "GET",
+      url: "/api/v1/manage/kms/jobs/{id}",
       path: {
         "id": id
       },
       errors: {
+        404: `Job not found`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Export GPG Public Key
-   * Export the ASCII-armored public key
-   * @param id
-   * @returns ExportKeyResponse Public key exported successfully
+   * List per-app KMS key info
+   * Calls GetKeyInfo per app. Never returns key material.
+   * @returns OrgKmsAppsResponse Per-app key metadata
    * @throws ApiError
    */
-  exportGpgPublicKey(id) {
+  listOrgKmsApps() {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/gpg_key/{id}/export",
-      path: {
-        "id": id
-      },
+      url: "/api/v1/manage/kms/apps",
+      errors: {
+        500: `Internal server error`,
+        503: `CMK unavailable`
+      }
+    });
+  }
+};
+
+// src/services/EnvironmentTypesService.ts
+var EnvironmentTypesService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Environment Types
+   * Retrieve all environment types for the organization
+   * @returns EnvTypesResponse Environment types retrieved successfully
+   * @throws ApiError
+   */
+  getEnvTypes() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/env_type",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Revoke GPG Key
-   * Revoke a GPG key (keeps data but marks as revoked)
-   * @param id
+   * Create Environment Type
+   * Create a new environment type
    * @param requestBody
-   * @returns GpgKeyDetailResponse GPG key revoked successfully
+   * @returns EnvTypeResponse Environment type created successfully
    * @throws ApiError
    */
-  revokeGpgKey(id, requestBody) {
+  createEnvType(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/gpg_key/{id}/revoke",
-      path: {
-        "id": id
-      },
+      url: "/api/env_type",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1897,39 +1995,36 @@ var GpgKeysService = class {
     });
   }
   /**
-   * Rotate GPG Key
-   * Create a replacement GPG key, optionally promote it to default, and supersede the original key.
+   * Get Environment Type
+   * Retrieve a specific environment type
    * @param id
-   * @param requestBody
-   * @returns GpgKeyDetailResponse GPG key rotated successfully
+   * @returns EnvTypeResponse Environment type retrieved successfully
    * @throws ApiError
    */
-  rotateGpgKey(id, requestBody) {
+  getEnvType(id) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/gpg_key/{id}/rotate",
+      method: "GET",
+      url: "/api/env_type/{id}",
       path: {
         "id": id
       },
-      body: requestBody,
-      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Extend GPG Key Expiry
-   * Extend the expiry date of an active GPG key without rotating it.
+   * Update Environment Type
+   * Update an existing environment type
    * @param id
    * @param requestBody
-   * @returns GpgKeyDetailResponse GPG key expiry extended successfully
+   * @returns EnvTypeResponse Environment type updated successfully
    * @throws ApiError
    */
-  extendGpgKeyExpiry(id, requestBody) {
+  updateEnvType(id, requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/gpg_key/{id}/extend-expiry",
+      method: "PATCH",
+      url: "/api/env_type/{id}",
       path: {
         "id": id
       },
@@ -1941,22 +2036,19 @@ var GpgKeysService = class {
     });
   }
   /**
-   * Update Trust Level
-   * Update the trust level of a GPG key
+   * Delete Environment Type
+   * Delete an existing environment type
    * @param id
-   * @param requestBody
-   * @returns GpgKeyDetailResponse Trust level updated successfully
+   * @returns DeleteEnvTypeRequest Environment type deleted successfully
    * @throws ApiError
    */
-  updateGpgKeyTrustLevel(id, requestBody) {
+  deleteEnvType(id) {
     return this.httpRequest.request({
-      method: "PATCH",
-      url: "/api/gpg_key/{id}/trust",
+      method: "DELETE",
+      url: "/api/env_type/{id}",
       path: {
         "id": id
       },
-      body: requestBody,
-      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
@@ -1964,63 +2056,58 @@ var GpgKeysService = class {
   }
 };
 
-// src/services/OnboardingService.ts
-var OnboardingService = class {
+// src/services/EnvironmentVariablesService.ts
+var EnvironmentVariablesService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
   /**
-   * Create Organization Invite
-   * Create an organization invite
+   * Export Environment
+   * Export environment variables and optionally secrets for an application environment in a single payload.
    * @param requestBody
-   * @returns CreateOrgInviteResponse Successful greeting response
+   * @returns ExportEnvResponse Environment exported successfully
    * @throws ApiError
    */
-  createOrgInvite(requestBody) {
+  exportEnvironment(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/onboarding/org",
+      url: "/api/env/export",
       body: requestBody,
       mediaType: "application/json",
       errors: {
-        500: `Internal server error`
+        400: `Invalid export request`
       }
     });
   }
   /**
-   * Get Organization Invite by Code
-   * Get organization invite by code
-   * @param inviteCode
-   * @returns GetOrgInviteByCodeResponse Organization invite retrieved successfully
+   * Get Environment Variables
+   * Retrieve all environment variables for an application and environment type
+   * @param requestBody
+   * @returns EnvsResponse Environment variables retrieved successfully
    * @throws ApiError
    */
-  getOrgInviteByCode(inviteCode) {
+  getEnvs(requestBody) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/onboarding/org/{invite_code}",
-      path: {
-        "invite_code": inviteCode
-      },
+      method: "POST",
+      url: "/api/env",
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Accept Organization Invite
-   * Accept organization invite
-   * @param inviteCode
+   * Delete Environment Variable
+   * Delete an existing environment variable
    * @param requestBody
-   * @returns AcceptOrgInviteResponse Organization invite accepted successfully
+   * @returns DeleteEnvRequest Environment variable deleted successfully
    * @throws ApiError
    */
-  acceptOrgInvite(inviteCode, requestBody) {
+  deleteEnv(requestBody) {
     return this.httpRequest.request({
-      method: "PUT",
-      url: "/api/onboarding/org/{invite_code}/accept",
-      path: {
-        "invite_code": inviteCode
-      },
+      method: "DELETE",
+      url: "/api/env",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -2029,38 +2116,41 @@ var OnboardingService = class {
     });
   }
   /**
-   * Get User Invite by Code
-   * Get user invite by code
-   * @param inviteCode
-   * @returns GetUserInviteByTokenResponse User invite retrieved successfully
+   * Get Single Environment Variable
+   * Retrieve a specific environment variable
+   * @param key
+   * @param requestBody
+   * @returns EnvResponse Environment variable retrieved successfully
    * @throws ApiError
    */
-  getUserInviteByCode(inviteCode) {
+  getEnv(key, requestBody) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/onboarding/user/{invite_code}",
+      method: "POST",
+      url: "/api/env/i/{key}",
       path: {
-        "invite_code": inviteCode
+        "key": key
       },
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Update User Invite
-   * Update user invite
-   * @param inviteCode
+   * Update Environment Variable
+   * Update an existing environment variable
+   * @param key
    * @param requestBody
-   * @returns UpdateUserInviteResponse User invite updated successfully
+   * @returns EnvResponse Environment variable updated successfully
    * @throws ApiError
    */
-  updateUserInvite(inviteCode, requestBody) {
+  updateEnv(key, requestBody) {
     return this.httpRequest.request({
       method: "PATCH",
-      url: "/api/onboarding/user/{invite_code}",
+      url: "/api/env/i/{key}",
       path: {
-        "invite_code": inviteCode
+        "key": key
       },
       body: requestBody,
       mediaType: "application/json",
@@ -2070,20 +2160,16 @@ var OnboardingService = class {
     });
   }
   /**
-   * Accept User Invite
-   * Accept user invite
-   * @param inviteCode
+   * Create Environment Variable
+   * Create a new environment variable
    * @param requestBody
-   * @returns AcceptUserInviteResponse User invite accepted successfully
+   * @returns EnvResponse Environment variable created successfully
    * @throws ApiError
    */
-  acceptUserInvite(inviteCode, requestBody) {
+  createEnv(requestBody) {
     return this.httpRequest.request({
       method: "PUT",
-      url: "/api/onboarding/user/{invite_code}/accept",
-      path: {
-        "invite_code": inviteCode
-      },
+      url: "/api/env/single",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -2092,16 +2178,16 @@ var OnboardingService = class {
     });
   }
   /**
-   * Create User Invite
-   * Create a user invite
+   * Batch Create Environment Variables
+   * Create multiple environment variables in a single request
    * @param requestBody
-   * @returns CreateUserInviteResponse User invite created successfully
+   * @returns BatchEnvsResponse Environment variables created successfully
    * @throws ApiError
    */
-  createUserInvite(requestBody) {
+  batchCreateEnvs(requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/onboarding/user",
+      method: "PUT",
+      url: "/api/env/batch",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -2110,34 +2196,36 @@ var OnboardingService = class {
     });
   }
   /**
-   * Get All User Invites
-   * Get all user invites
-   * @returns GetUserInviteByTokenResponse User invites retrieved successfully
+   * Batch Update Environment Variables
+   * Update multiple environment variables in a single request
+   * @param requestBody
+   * @returns BatchEnvsResponse Environment variables updated successfully
    * @throws ApiError
    */
-  getAllUserInvites() {
+  batchUpdateEnvs(requestBody) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/onboarding/user",
+      method: "PATCH",
+      url: "/api/env/batch",
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Delete User Invite
-   * Delete user invite
-   * @param inviteId
-   * @returns DeleteUserInviteResponse User invite deleted successfully
+   * Batch Delete Environment Variables
+   * Delete multiple environment variables in a single request
+   * @param requestBody
+   * @returns BatchEnvsResponse Environment variables deleted successfully
    * @throws ApiError
    */
-  deleteUserInvite(inviteId) {
+  deleteBatchEnv(requestBody) {
     return this.httpRequest.request({
       method: "DELETE",
-      url: "/api/onboarding/user/{invite_id}",
-      path: {
-        "invite_id": inviteId
-      },
+      url: "/api/env/batch",
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
@@ -2145,37 +2233,40 @@ var OnboardingService = class {
   }
 };
 
-// src/services/OrganizationsService.ts
-var OrganizationsService = class {
+// src/services/EnvironmentVariablesPointInTimeService.ts
+var EnvironmentVariablesPointInTimeService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
   /**
-   * Get Organization
-   * Retrieve the current organization's details
-   * @returns OrgResponse Organization retrieved successfully
+   * Get Environment Variables History
+   * Retrieve paginated history of environment variable changes
+   * @param requestBody
+   * @returns EnvHistoryResponse Environment variables history retrieved successfully
    * @throws ApiError
    */
-  getOrg() {
+  getEnvHistory(requestBody) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/org",
+      method: "POST",
+      url: "/api/env/history",
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Update Organization
-   * Update the current organization's details
+   * Get Environment Variables at Point in Time
+   * Retrieve environment variables state at a specific point in time
    * @param requestBody
-   * @returns OrgResponse Organization updated successfully
+   * @returns EnvPitStateResponse Environment variables at point in time retrieved successfully
    * @throws ApiError
    */
-  updateOrg(requestBody) {
+  getEnvsAtPointInTime(requestBody) {
     return this.httpRequest.request({
-      method: "PATCH",
-      url: "/api/org",
+      method: "POST",
+      url: "/api/env/pit",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -2184,16 +2275,16 @@ var OrganizationsService = class {
     });
   }
   /**
-   * Delete Organization
-   * Permanently delete the current organization
+   * Get Environment Variables at Timestamp
+   * Retrieve environment variables state at a specific timestamp
    * @param requestBody
-   * @returns DeleteOrgResponse Organization deleted successfully
+   * @returns EnvPitStateResponse Environment variables at timestamp retrieved successfully
    * @throws ApiError
    */
-  deleteOrg(requestBody) {
+  getEnvsAtTimestamp(requestBody) {
     return this.httpRequest.request({
-      method: "DELETE",
-      url: "/api/org",
+      method: "POST",
+      url: "/api/env/timestamp",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -2202,19 +2293,58 @@ var OrganizationsService = class {
     });
   }
   /**
-   * Check Slug Availability
-   * Check if an organization slug is available
-   * @param slug
-   * @returns CheckSlugResponse Slug availability checked successfully
+   * Get Environment Variables Diff
+   * Compare environment variables between two points in time
+   * @param requestBody
+   * @returns EnvDiffResponse Environment variables diff retrieved successfully
    * @throws ApiError
    */
-  checkIfSlugExists(slug) {
+  getEnvDiff(requestBody) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/org/check-slug",
-      query: {
-        "slug": slug
+      method: "POST",
+      url: "/api/env/diff",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Environment Variables Diff By Timestamp Range
+   * Compare environment variables between two timestamps
+   * @param requestBody
+   * @returns EnvDiffResponse Environment variables timestamp-range diff retrieved successfully
+   * @throws ApiError
+   */
+  getEnvDiffByTimestampRange(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/diff/timestamp-range",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Variable Timeline
+   * Get timeline of changes for a specific environment variable
+   * @param key
+   * @param requestBody
+   * @returns VariableTimelineResponse Variable timeline retrieved successfully
+   * @throws ApiError
+   */
+  getVariableTimeline(key, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/timeline/{key}",
+      path: {
+        "key": key
       },
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
@@ -2222,63 +2352,1564 @@ var OrganizationsService = class {
   }
 };
 
-// src/services/PermissionsService.ts
-var PermissionsService = class {
+// src/services/EnvironmentVariablesRollbackService.ts
+var EnvironmentVariablesRollbackService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
   /**
-   * Get My Permissions
-   * Get the current user's effective permissions in the organization
-   * @returns EffectivePermissionsResponse Permissions retrieved successfully
+   * Rollback Environment Variables to Point in Time
+   * Rollback all environment variables to a specific point in time
+   * @param requestBody
+   * @returns RollbackResponse Environment variables rolled back successfully
+   * @throws ApiError
+   */
+  rollbackEnvsToPitId(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/rollback/pit",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Rollback Environment Variables to Timestamp
+   * Rollback all environment variables to a specific timestamp
+   * @param requestBody
+   * @returns RollbackResponse Environment variables rolled back successfully
+   * @throws ApiError
+   */
+  rollbackEnvsToTimestamp(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/rollback/timestamp",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Rollback Single Variable to Point in Time
+   * Rollback a specific environment variable to a point in time
+   * @param key
+   * @param requestBody
+   * @returns VariableRollbackResponse Variable rolled back successfully
+   * @throws ApiError
+   */
+  rollbackVariableToPitId(key, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/rollback/variable/{key}/pit",
+      path: {
+        "key": key
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Rollback Single Variable to Timestamp
+   * Rollback a specific environment variable to a timestamp
+   * @param key
+   * @param requestBody
+   * @returns VariableRollbackResponse Variable rolled back successfully
+   * @throws ApiError
+   */
+  rollbackVariableToTimestamp(key, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/rollback/variable/{key}/timestamp",
+      path: {
+        "key": key
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/FileUploadService.ts
+var FileUploadService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Upload File
+   * Upload a file to the server. The file should be less than 5MB in size.
+   * @param formData
+   * @returns UploadFileResponse File uploaded successfully
+   * @throws ApiError
+   */
+  uploadFile(formData) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/upload/file",
+      formData,
+      mediaType: "multipart/form-data",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/GpgKeysService.ts
+var GpgKeysService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Generate GPG Key
+   * Generate a new GPG key pair for the organization
+   * @param requestBody
+   * @returns GpgKeyResponse GPG key generated successfully
+   * @throws ApiError
+   */
+  generateGpgKey(requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/gpg_key/generate",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Import GPG Key
+   * Import an existing GPG key into the organization
+   * @param requestBody
+   * @returns GpgKeyResponse GPG key imported successfully
+   * @throws ApiError
+   */
+  importGpgKey(requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/gpg_key/import",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Sign Data
+   * Sign data using a GPG key
+   * @param requestBody
+   * @returns SignatureResponse Data signed successfully
+   * @throws ApiError
+   */
+  signDataWithGpgKey(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/gpg_key/sign",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Verify Signature
+   * Verify a GPG signature
+   * @param requestBody
+   * @returns VerifyResponse Verification result
+   * @throws ApiError
+   */
+  verifyGpgSignature(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/gpg_key/verify",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List GPG Keys
+   * List all GPG keys for the organization
+   * @returns GpgKeysResponse GPG keys retrieved successfully
+   * @throws ApiError
+   */
+  listGpgKeys() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/gpg_key",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get GPG Key
+   * Retrieve a specific GPG key
+   * @param id
+   * @returns GpgKeyDetailResponse GPG key retrieved successfully
+   * @throws ApiError
+   */
+  getGpgKey(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/gpg_key/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete GPG Key
+   * Delete a GPG key from the organization
+   * @param id
+   * @returns GpgKeyResponse GPG key deleted successfully
+   * @throws ApiError
+   */
+  deleteGpgKey(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/gpg_key/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Export GPG Public Key
+   * Export the ASCII-armored public key
+   * @param id
+   * @returns ExportKeyResponse Public key exported successfully
+   * @throws ApiError
+   */
+  exportGpgPublicKey(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/gpg_key/{id}/export",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Revoke GPG Key
+   * Revoke a GPG key (keeps data but marks as revoked)
+   * @param id
+   * @param requestBody
+   * @returns GpgKeyDetailResponse GPG key revoked successfully
+   * @throws ApiError
+   */
+  revokeGpgKey(id, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/gpg_key/{id}/revoke",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Rotate GPG Key
+   * Create a replacement GPG key, optionally promote it to default, and supersede the original key.
+   * @param id
+   * @param requestBody
+   * @returns GpgKeyDetailResponse GPG key rotated successfully
+   * @throws ApiError
+   */
+  rotateGpgKey(id, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/gpg_key/{id}/rotate",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Extend GPG Key Expiry
+   * Extend the expiry date of an active GPG key without rotating it.
+   * @param id
+   * @param requestBody
+   * @returns GpgKeyDetailResponse GPG key expiry extended successfully
+   * @throws ApiError
+   */
+  extendGpgKeyExpiry(id, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/gpg_key/{id}/extend-expiry",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Trust Level
+   * Update the trust level of a GPG key
+   * @param id
+   * @param requestBody
+   * @returns GpgKeyDetailResponse Trust level updated successfully
+   * @throws ApiError
+   */
+  updateGpgKeyTrustLevel(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/gpg_key/{id}/trust",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/LicenseService.ts
+var LicenseService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Management License Status
+   * @returns LicenseStatusResponse Current license status
+   * @throws ApiError
+   */
+  getManagementLicenseStatus() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/license/status",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Activate Management License
+   * @returns LicenseActionResponse License activated
+   * @throws ApiError
+   */
+  activateManagementLicense() {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/license/activate",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Verify Management License
+   * @returns LicenseActionResponse License verified
+   * @throws ApiError
+   */
+  verifyManagementLicense() {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/license/verify",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/LogForwardingService.ts
+var LogForwardingService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Create Log Forwarding Config
+   * Create a new log forwarding configuration for the organization
+   * @param requestBody
+   * @returns LogForwardingResponse Log forwarding config created successfully
+   * @throws ApiError
+   */
+  createLogForwardingConfig(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/log_forwarding",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get All Log Forwarding Configs
+   * Retrieve all log forwarding configurations for the organization
+   * @returns LogForwardingsResponse Log forwarding configs retrieved successfully
+   * @throws ApiError
+   */
+  getLogForwardingConfigs() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/log_forwarding",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Log Forwarding Config
+   * Retrieve a specific log forwarding configuration
+   * @param id
+   * @returns LogForwardingResponse Log forwarding config retrieved successfully
+   * @throws ApiError
+   */
+  getLogForwardingConfig(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/log_forwarding/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        404: `Config not found`,
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Log Forwarding Config
+   * Delete a log forwarding configuration
+   * @param id
+   * @returns ErrorResponse Log forwarding config deleted successfully
+   * @throws ApiError
+   */
+  deleteLogForwardingConfig(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/v1/manage/log_forwarding/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/OidcProvidersService.ts
+var OidcProvidersService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Register OIDC Provider
+   * Register a new OIDC provider for CI/CD machine authentication
+   * @param requestBody
+   * @returns OidcProviderResponse OIDC provider created successfully
+   * @throws ApiError
+   */
+  createOidcProvider(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/oidc",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get All OIDC Providers
+   * Retrieve all OIDC providers for the organization
+   * @returns OidcProvidersResponse OIDC providers retrieved successfully
+   * @throws ApiError
+   */
+  getAllOidcProviders() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/oidc",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get OIDC Provider
+   * Retrieve a specific OIDC provider
+   * @param id
+   * @returns OidcProviderResponse OIDC provider retrieved successfully
+   * @throws ApiError
+   */
+  getOidcProvider(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/oidc/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update OIDC Provider
+   * Update an existing OIDC provider
+   * @param id
+   * @param requestBody
+   * @returns ErrorResponse OIDC provider updated successfully
+   * @throws ApiError
+   */
+  updateOidcProvider(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/v1/manage/oidc/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete OIDC Provider
+   * Delete an existing OIDC provider
+   * @param id
+   * @returns ErrorResponse OIDC provider deleted successfully
+   * @throws ApiError
+   */
+  deleteOidcProvider(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/v1/manage/oidc/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/OnboardingService.ts
+var OnboardingService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Create Organization Invite
+   * Create an organization invite
+   * @param requestBody
+   * @returns CreateOrgInviteResponse Successful greeting response
+   * @throws ApiError
+   */
+  createOrgInvite(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/onboarding/org",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Organization Invite by Code
+   * Get organization invite by code
+   * @param inviteCode
+   * @returns GetOrgInviteByCodeResponse Organization invite retrieved successfully
+   * @throws ApiError
+   */
+  getOrgInviteByCode(inviteCode) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/onboarding/org/{invite_code}",
+      path: {
+        "invite_code": inviteCode
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Accept Organization Invite
+   * Accept organization invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns AcceptOrgInviteResponse Organization invite accepted successfully
+   * @throws ApiError
+   */
+  acceptOrgInvite(inviteCode, requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/onboarding/org/{invite_code}/accept",
+      path: {
+        "invite_code": inviteCode
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get User Invite by Code
+   * Get user invite by code
+   * @param inviteCode
+   * @returns GetUserInviteByTokenResponse User invite retrieved successfully
+   * @throws ApiError
+   */
+  getUserInviteByCode(inviteCode) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/onboarding/user/{invite_code}",
+      path: {
+        "invite_code": inviteCode
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update User Invite
+   * Update user invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns UpdateUserInviteResponse User invite updated successfully
+   * @throws ApiError
+   */
+  updateUserInvite(inviteCode, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/onboarding/user/{invite_code}",
+      path: {
+        "invite_code": inviteCode
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Accept User Invite
+   * Accept user invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns AcceptUserInviteResponse User invite accepted successfully
+   * @throws ApiError
+   */
+  acceptUserInvite(inviteCode, requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/onboarding/user/{invite_code}/accept",
+      path: {
+        "invite_code": inviteCode
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create User Invite
+   * Create a user invite
+   * @param requestBody
+   * @returns CreateUserInviteResponse User invite created successfully
+   * @throws ApiError
+   */
+  createUserInvite(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/onboarding/user",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get All User Invites
+   * Get all user invites
+   * @returns GetUserInviteByTokenResponse User invites retrieved successfully
+   * @throws ApiError
+   */
+  getAllUserInvites() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/onboarding/user",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete User Invite
+   * Delete user invite
+   * @param inviteId
+   * @returns DeleteUserInviteResponse User invite deleted successfully
+   * @throws ApiError
+   */
+  deleteUserInvite(inviteId) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/onboarding/user/{invite_id}",
+      path: {
+        "invite_id": inviteId
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Organization Invite
+   * Create an organization invite
+   * @param requestBody
+   * @returns CreateOrgInviteResponse Successful greeting response
+   * @throws ApiError
+   */
+  manageCreateOrgInvite(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/onboarding/org",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Organization Invite by Code
+   * Get organization invite by code
+   * @param inviteCode
+   * @returns GetOrgInviteByCodeResponse Organization invite retrieved successfully
+   * @throws ApiError
+   */
+  manageGetOrgInviteByCode(inviteCode) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/onboarding/org/{invite_code}",
+      path: {
+        "invite_code": inviteCode
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Accept Organization Invite
+   * Accept organization invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns AcceptOrgInviteResponse Organization invite accepted successfully
+   * @throws ApiError
+   */
+  manageAcceptOrgInvite(inviteCode, requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/v1/manage/onboarding/org/{invite_code}/accept",
+      path: {
+        "invite_code": inviteCode
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get User Invite by Code
+   * Get user invite by code
+   * @param inviteCode
+   * @returns GetUserInviteByTokenResponse User invite retrieved successfully
+   * @throws ApiError
+   */
+  manageGetUserInviteByCode(inviteCode) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/onboarding/user/{invite_code}",
+      path: {
+        "invite_code": inviteCode
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update User Invite
+   * Update user invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns UpdateUserInviteResponse User invite updated successfully
+   * @throws ApiError
+   */
+  manageUpdateUserInvite(inviteCode, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/v1/manage/onboarding/user/{invite_code}",
+      path: {
+        "invite_code": inviteCode
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Accept User Invite
+   * Accept user invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns AcceptUserInviteResponse User invite accepted successfully
+   * @throws ApiError
+   */
+  manageAcceptUserInvite(inviteCode, requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/v1/manage/onboarding/user/{invite_code}/accept",
+      path: {
+        "invite_code": inviteCode
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create User Invite
+   * Create a user invite
+   * @param requestBody
+   * @returns CreateUserInviteResponse User invite created successfully
+   * @throws ApiError
+   */
+  manageCreateUserInvite(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/onboarding/user",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get All User Invites
+   * Get all user invites
+   * @returns GetUserInviteByTokenResponse User invites retrieved successfully
+   * @throws ApiError
+   */
+  manageGetAllUserInvites() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/onboarding/user",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete User Invite
+   * Delete user invite
+   * @param inviteId
+   * @returns DeleteUserInviteResponse User invite deleted successfully
+   * @throws ApiError
+   */
+  manageDeleteUserInvite(inviteId) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/v1/manage/onboarding/user/{invite_id}",
+      path: {
+        "invite_id": inviteId
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/OrganizationsService.ts
+var OrganizationsService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Organization
+   * Retrieve the current organization's details
+   * @returns OrgResponse Organization retrieved successfully
+   * @throws ApiError
+   */
+  getOrg() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/org",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Organization
+   * Update the current organization's details
+   * @param requestBody
+   * @returns OrgResponse Organization updated successfully
+   * @throws ApiError
+   */
+  updateOrg(requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/org",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Organization
+   * Permanently delete the current organization
+   * @param requestBody
+   * @returns DeleteOrgResponse Organization deleted successfully
+   * @throws ApiError
+   */
+  deleteOrg(requestBody) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/org",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Check Slug Availability
+   * Check if an organization slug is available
+   * @param slug
+   * @returns CheckSlugResponse Slug availability checked successfully
+   * @throws ApiError
+   */
+  checkIfSlugExists(slug) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/org/check-slug",
+      query: {
+        "slug": slug
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/OrgFeaturesService.ts
+var OrgFeaturesService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Organization Feature Grant
+   * Hosted platform API. No row means unrestricted (full catalog).
+   * @param xEnvSyncPlatformToken
+   * @param orgId
+   * @returns OrgFeatureGrantResponse Organization feature grant
+   * @throws ApiError
+   */
+  getOrgFeatureGrant(xEnvSyncPlatformToken, orgId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/org-features/{orgId}",
+      path: {
+        "orgId": orgId
+      },
+      headers: {
+        "X-EnvSync-Platform-Token": xEnvSyncPlatformToken
+      },
+      errors: {
+        401: `Invalid platform token`,
+        403: `Not hosted`,
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Replace Organization Feature Grant
+   * Full replace. Empty features[] denies every EE feature. Unknown catalog keys are dropped.
+   * @param xEnvSyncPlatformToken
+   * @param orgId
+   * @param requestBody
+   * @returns OrgFeatureGrantResponse Organization feature grant replaced
+   * @throws ApiError
+   */
+  putOrgFeatureGrant(xEnvSyncPlatformToken, orgId, requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/v1/manage/org-features/{orgId}",
+      path: {
+        "orgId": orgId
+      },
+      headers: {
+        "X-EnvSync-Platform-Token": xEnvSyncPlatformToken
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Invalid platform token`,
+        403: `Not hosted`,
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Organization Feature Grant
+   * Drops the grant row so the organization is unrestricted.
+   * @param xEnvSyncPlatformToken
+   * @param orgId
+   * @returns OrgFeatureGrantResponse Grant deleted; organization unrestricted
+   * @throws ApiError
+   */
+  deleteOrgFeatureGrant(xEnvSyncPlatformToken, orgId) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/v1/manage/org-features/{orgId}",
+      path: {
+        "orgId": orgId
+      },
+      headers: {
+        "X-EnvSync-Platform-Token": xEnvSyncPlatformToken
+      },
+      errors: {
+        401: `Invalid platform token`,
+        403: `Not hosted`,
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/PermissionsService.ts
+var PermissionsService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get My Permissions
+   * Get the current user's effective permissions in the organization
+   * @returns EffectivePermissionsResponse Permissions retrieved successfully
+   * @throws ApiError
+   */
+  getMyPermissions() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/permission/me",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Grant App Access
+   * Grant a user or team access to an app
+   * @param appId
+   * @param requestBody
+   * @returns PermissionMessageResponse Access granted successfully
+   * @throws ApiError
+   */
+  grantAppAccess(appId, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/permission/app/{app_id}/grant",
+      path: {
+        "app_id": appId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Revoke App Access
+   * Revoke a user or team's access to an app
+   * @param appId
+   * @param requestBody
+   * @returns PermissionMessageResponse Access revoked successfully
+   * @throws ApiError
+   */
+  revokeAppAccess(appId, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/permission/app/{app_id}/revoke",
+      path: {
+        "app_id": appId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List App Grants
+   * List direct user and team grants on an app
+   * @param appId
+   * @returns GrantsListResponse App grants listed successfully
+   * @throws ApiError
+   */
+  listAppGrants(appId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/permission/app/{app_id}/grants",
+      path: {
+        "app_id": appId
+      }
+    });
+  }
+  /**
+   * Get App Effective Access
+   * List user effective access for an app including team inheritance
+   * @param appId
+   * @returns EffectiveAccessResponse Effective app access returned successfully
+   * @throws ApiError
+   */
+  getAppEffectiveAccess(appId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/permission/app/{app_id}/effective-access",
+      path: {
+        "app_id": appId
+      }
+    });
+  }
+  /**
+   * Grant Env Type Access
+   * Grant a user or team access to an environment type
+   * @param id
+   * @param requestBody
+   * @returns PermissionMessageResponse Access granted successfully
+   * @throws ApiError
+   */
+  grantEnvTypeAccess(id, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/permission/env_type/{id}/grant",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Revoke Env Type Access
+   * Revoke a user or team's access to an environment type
+   * @param id
+   * @param requestBody
+   * @returns PermissionMessageResponse Access revoked successfully
+   * @throws ApiError
+   */
+  revokeEnvTypeAccess(id, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/permission/env_type/{id}/revoke",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * List Env Type Grants
+   * List direct user and team grants on an environment type
+   * @param id
+   * @returns GrantsListResponse Env type grants listed successfully
+   * @throws ApiError
+   */
+  listEnvTypeGrants(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/permission/env_type/{id}/grants",
+      path: {
+        "id": id
+      }
+    });
+  }
+};
+
+// src/services/RolesService.ts
+var RolesService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get All Roles
+   * Retrieve all roles in the organization
+   * @returns RolesResponse Roles retrieved successfully
+   * @throws ApiError
+   */
+  getAllRoles() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/role",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Role
+   * Create a new role in the organization
+   * @param requestBody
+   * @returns RoleResponse Role created successfully
+   * @throws ApiError
+   */
+  createRole(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/role",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Role Statistics
+   * Retrieve statistics about roles in the organization
+   * @returns RoleStatsResponse Role statistics retrieved successfully
+   * @throws ApiError
+   */
+  getRoleStats() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/role/stats",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Role
+   * Retrieve a specific role by ID
+   * @param id
+   * @returns RoleResponse Role retrieved successfully
+   * @throws ApiError
+   */
+  getRole(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/role/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Role
+   * Update an existing role
+   * @param id
+   * @param requestBody
+   * @returns RoleResponse Role updated successfully
+   * @throws ApiError
+   */
+  updateRole(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/role/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Role
+   * Delete an existing role (non-master roles only)
+   * @param id
+   * @returns RoleResponse Role deleted successfully
+   * @throws ApiError
+   */
+  deleteRole(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/role/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/RotationService.ts
+var RotationService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Create Rotation Policy
+   * Create a new secret rotation policy for a variable
+   * @param requestBody
+   * @returns RotationPolicyResponse Rotation policy created successfully
+   * @throws ApiError
+   */
+  createRotationPolicy(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/rotation",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad request`,
+        403: `Forbidden`,
+        409: `Conflict - policy already exists`,
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Rotation Policies
+   * List all rotation policies for the organization
+   * @param appId
+   * @param envTypeId
+   * @param enabled
+   * @returns RotationPoliciesResponse Rotation policies retrieved successfully
+   * @throws ApiError
+   */
+  getRotationPolicies(appId, envTypeId, enabled) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/rotation",
+      query: {
+        "app_id": appId,
+        "env_type_id": envTypeId,
+        "enabled": enabled
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Rotation Policy
+   * Get a specific rotation policy by ID
+   * @param id
+   * @returns RotationPolicyResponse Rotation policy retrieved successfully
+   * @throws ApiError
+   */
+  getRotationPolicy(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/rotation/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        404: `Not found`,
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Rotation Policy
+   * Update an existing rotation policy
+   * @param id
+   * @param requestBody
+   * @returns RotationPolicyResponse Rotation policy updated successfully
+   * @throws ApiError
+   */
+  updateRotationPolicy(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/v1/manage/rotation/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        403: `Forbidden`,
+        404: `Not found`,
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Rotation Policy
+   * Delete a rotation policy
+   * @param id
+   * @returns ErrorResponse Rotation policy deleted successfully
+   * @throws ApiError
+   */
+  deleteRotationPolicy(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/v1/manage/rotation/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        403: `Forbidden`,
+        404: `Not found`,
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Trigger Rotation
+   * Manually trigger a secret rotation for a policy
+   * @param id
+   * @returns TriggerRotationResponse Rotation executed successfully
+   * @throws ApiError
+   */
+  triggerRotation(id) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/rotation/{id}/rotate",
+      path: {
+        "id": id
+      },
+      errors: {
+        403: `Forbidden`,
+        404: `Not found`,
+        409: `Conflict - policy disabled`,
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Rotation States
+   * Get the rotation state history for a policy
+   * @param id
+   * @returns RotationStatesResponse Rotation states retrieved successfully
    * @throws ApiError
    */
-  getMyPermissions() {
+  getRotationStates(id) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/permission/me",
+      url: "/api/v1/manage/rotation/{id}/states",
+      path: {
+        "id": id
+      },
       errors: {
+        404: `Not found`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Grant App Access
-   * Grant a user or team access to an app
-   * @param appId
-   * @param requestBody
-   * @returns PermissionMessageResponse Access granted successfully
+   * Revoke Expired Credentials
+   * Revoke old credentials that have passed their dual-credential window
+   * @returns RevokeOldCredentialResponse Expired credentials revoked successfully
    * @throws ApiError
    */
-  grantAppAccess(appId, requestBody) {
+  revokeExpiredCredentials() {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/permission/app/{app_id}/grant",
-      path: {
-        "app_id": appId
-      },
-      body: requestBody,
-      mediaType: "application/json",
+      url: "/api/v1/manage/rotation/revoke-expired",
       errors: {
         500: `Internal server error`
       }
     });
   }
+};
+
+// src/services/SamlProvidersService.ts
+var SamlProvidersService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
   /**
-   * Revoke App Access
-   * Revoke a user or team's access to an app
-   * @param appId
+   * Register SAML Provider
+   * Register a new SAML identity provider for SSO authentication
    * @param requestBody
-   * @returns PermissionMessageResponse Access revoked successfully
+   * @returns SamlProviderResponse SAML provider created successfully
    * @throws ApiError
    */
-  revokeAppAccess(appId, requestBody) {
+  createSamlProvider(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/permission/app/{app_id}/revoke",
-      path: {
-        "app_id": appId
-      },
+      url: "/api/v1/manage/saml",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -2287,49 +3918,51 @@ var PermissionsService = class {
     });
   }
   /**
-   * List App Grants
-   * List direct user and team grants on an app
-   * @param appId
-   * @returns GrantsListResponse App grants listed successfully
+   * Get All SAML Providers
+   * Retrieve all SAML providers for the organization
+   * @returns SamlProvidersResponse SAML providers retrieved successfully
    * @throws ApiError
    */
-  listAppGrants(appId) {
+  getAllSamlProviders() {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/permission/app/{app_id}/grants",
-      path: {
-        "app_id": appId
+      url: "/api/v1/manage/saml",
+      errors: {
+        500: `Internal server error`
       }
     });
   }
   /**
-   * Get App Effective Access
-   * List user effective access for an app including team inheritance
-   * @param appId
-   * @returns EffectiveAccessResponse Effective app access returned successfully
+   * Get SAML Provider
+   * Retrieve a specific SAML provider. Certificate PEM is omitted unless include=certificate.
+   * @param id
+   * @returns SamlProviderResponse SAML provider retrieved successfully
    * @throws ApiError
    */
-  getAppEffectiveAccess(appId) {
+  getSamlProvider(id) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/permission/app/{app_id}/effective-access",
+      url: "/api/v1/manage/saml/{id}",
       path: {
-        "app_id": appId
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
       }
     });
   }
   /**
-   * Grant Env Type Access
-   * Grant a user or team access to an environment type
+   * Update SAML Provider
+   * Update an existing SAML provider
    * @param id
    * @param requestBody
-   * @returns PermissionMessageResponse Access granted successfully
+   * @returns ErrorResponse SAML provider updated successfully
    * @throws ApiError
    */
-  grantEnvTypeAccess(id, requestBody) {
+  updateSamlProvider(id, requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/permission/env_type/{id}/grant",
+      method: "PUT",
+      url: "/api/v1/manage/saml/{id}",
       path: {
         "id": id
       },
@@ -2341,155 +3974,127 @@ var PermissionsService = class {
     });
   }
   /**
-   * Revoke Env Type Access
-   * Revoke a user or team's access to an environment type
+   * Delete SAML Provider
+   * Delete an existing SAML provider
    * @param id
-   * @param requestBody
-   * @returns PermissionMessageResponse Access revoked successfully
+   * @returns ErrorResponse SAML provider deleted successfully
    * @throws ApiError
    */
-  revokeEnvTypeAccess(id, requestBody) {
+  deleteSamlProvider(id) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/permission/env_type/{id}/revoke",
+      method: "DELETE",
+      url: "/api/v1/manage/saml/{id}",
       path: {
         "id": id
       },
-      body: requestBody,
-      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * List Env Type Grants
-   * List direct user and team grants on an environment type
+   * Get SAML SP Metadata
+   * Redirects to the public SP metadata URL for this organization
    * @param id
-   * @returns GrantsListResponse Env type grants listed successfully
+   * @returns void
    * @throws ApiError
    */
-  listEnvTypeGrants(id) {
+  getSamlMetadata(id) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/permission/env_type/{id}/grants",
+      url: "/api/v1/manage/saml/{id}/metadata",
       path: {
         "id": id
+      },
+      errors: {
+        302: `Redirect to /api/saml/metadata/{orgId}`
       }
     });
   }
 };
 
-// src/services/RolesService.ts
-var RolesService = class {
+// src/services/SamlSsoService.ts
+var SamlSsoService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
   /**
-   * Get All Roles
-   * Retrieve all roles in the organization
-   * @returns RolesResponse Roles retrieved successfully
+   * Get public SAML SP metadata
+   * Unauthenticated SP metadata XML for the organization
+   * @param orgId
+   * @returns string SP metadata XML
    * @throws ApiError
    */
-  getAllRoles() {
+  getPublicSamlMetadata(orgId) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/role",
+      url: "/api/saml/metadata/{orgId}",
+      path: {
+        "orgId": orgId
+      },
       errors: {
-        500: `Internal server error`
+        404: `SSO is not available`
       }
     });
   }
   /**
-   * Create Role
-   * Create a new role in the organization
-   * @param requestBody
-   * @returns RoleResponse Role created successfully
+   * SAML Assertion Consumer Service
+   * Receive and validate a SAML Response from the identity provider
+   * @param orgId
+   * @returns void
    * @throws ApiError
    */
-  createRole(requestBody) {
+  handlePublicSamlAcs(orgId) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/role",
-      body: requestBody,
-      mediaType: "application/json",
-      errors: {
-        500: `Internal server error`
-      }
-    });
-  }
-  /**
-   * Get Role Statistics
-   * Retrieve statistics about roles in the organization
-   * @returns RoleStatsResponse Role statistics retrieved successfully
-   * @throws ApiError
-   */
-  getRoleStats() {
-    return this.httpRequest.request({
-      method: "GET",
-      url: "/api/role/stats",
-      errors: {
-        500: `Internal server error`
-      }
-    });
-  }
-  /**
-   * Get Role
-   * Retrieve a specific role by ID
-   * @param id
-   * @returns RoleResponse Role retrieved successfully
-   * @throws ApiError
-   */
-  getRole(id) {
-    return this.httpRequest.request({
-      method: "GET",
-      url: "/api/role/{id}",
+      url: "/api/saml/acs/{orgId}",
       path: {
-        "id": id
+        "orgId": orgId
       },
       errors: {
-        500: `Internal server error`
+        302: `Authentication successful`,
+        401: `Authentication failed`
       }
     });
   }
   /**
-   * Update Role
-   * Update an existing role
-   * @param id
+   * Start SAML SSO
+   * Unauthenticated SP-initiated start. Returns a redirect URL for the login page or CLI.
+   * @param orgSlug
    * @param requestBody
-   * @returns RoleResponse Role updated successfully
+   * @returns SamlSsoResponse Redirect URL generated
    * @throws ApiError
    */
-  updateRole(id, requestBody) {
+  startPublicSamlSso(orgSlug, requestBody) {
     return this.httpRequest.request({
-      method: "PATCH",
-      url: "/api/role/{id}",
+      method: "POST",
+      url: "/api/saml/sso/{orgSlug}",
       path: {
-        "id": id
+        "orgSlug": orgSlug
       },
       body: requestBody,
       mediaType: "application/json",
       errors: {
-        500: `Internal server error`
+        404: `SSO is not available`
       }
     });
   }
   /**
-   * Delete Role
-   * Delete an existing role (non-master roles only)
-   * @param id
-   * @returns RoleResponse Role deleted successfully
+   * Bookmark SAML SSO start
+   * Success redirects to the IdP. Any error redirects to the dashboard login page.
+   * @param orgSlug
+   * @returns void
    * @throws ApiError
    */
-  deleteRole(id) {
+  startPublicSamlSsoRedirect(orgSlug) {
     return this.httpRequest.request({
-      method: "DELETE",
-      url: "/api/role/{id}",
+      method: "GET",
+      url: "/api/saml/sso/{orgSlug}",
       path: {
-        "id": id
+        "orgSlug": orgSlug
       },
       errors: {
-        500: `Internal server error`
+        302: `Redirect to the IdP or /login?sso=failed`
       }
     });
   }
@@ -2956,6 +4561,46 @@ var ServiceTokensService = class {
   }
 };
 
+// src/services/SetupService.ts
+var SetupService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Operator setup status (self-host)
+   * @returns SetupStatusResponse Setup status
+   * @throws ApiError
+   */
+  getSetupStatus() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/setup/status",
+      errors: {
+        401: `Invalid setup token`
+      }
+    });
+  }
+  /**
+   * Create organization via operator setup token (self-host only)
+   * @param requestBody
+   * @returns any Organization created
+   * @throws ApiError
+   */
+  createSetupOrganization(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/setup/org",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Invalid request`,
+        401: `Invalid setup token`,
+        403: `Channel forbidden`
+      }
+    });
+  }
+};
+
 // src/services/SystemService.ts
 var SystemService = class {
   constructor(httpRequest) {
@@ -2975,6 +4620,20 @@ var SystemService = class {
       }
     });
   }
+  /**
+   * Get Management System Status
+   * @returns SystemStatusResponse Management system status
+   * @throws ApiError
+   */
+  manageGetManagementSystemStatus() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/system/status",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
 };
 
 // src/services/TeamsService.ts
@@ -3265,7 +4924,7 @@ var UsersService = class {
    * @returns UserResponse User role updated successfully
    * @throws ApiError
    */
-  updateRole(id, requestBody) {
+  updateUserRole(id, requestBody) {
     return this.httpRequest.request({
       method: "PATCH",
       url: "/api/user/role/{id}",
@@ -3409,20 +5068,31 @@ var EnvSyncAPISDK = class {
   authentication;
   certificates;
   changeRequests;
+  dynamicSecrets;
+  enterprise;
+  enterpriseCmk;
   environmentTypes;
   environmentVariables;
   environmentVariablesPointInTime;
   environmentVariablesRollback;
   fileUpload;
   gpgKeys;
+  license;
+  logForwarding;
+  oidcProviders;
   onboarding;
   organizations;
+  orgFeatures;
   permissions;
   roles;
+  rotation;
+  samlProviders;
+  samlSso;
   secrets;
   secretsPointInTime;
   secretsRollback;
   serviceTokens;
+  setup;
   system;
   teams;
   users;
@@ -3430,8 +5100,8 @@ var EnvSyncAPISDK = class {
   request;
   constructor(config, HttpRequest = FetchHttpRequest) {
     this.request = new HttpRequest({
-      BASE: config?.BASE ?? "http://localhost:4000",
-      VERSION: config?.VERSION ?? "0.10.0",
+      BASE: config?.BASE ?? "http://localhost:0",
+      VERSION: config?.VERSION ?? "0.20.1",
       WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
       CREDENTIALS: config?.CREDENTIALS ?? "include",
       TOKEN: config?.TOKEN,
@@ -3447,20 +5117,31 @@ var EnvSyncAPISDK = class {
     this.authentication = new AuthenticationService(this.request);
     this.certificates = new CertificatesService(this.request);
     this.changeRequests = new ChangeRequestsService(this.request);
+    this.dynamicSecrets = new DynamicSecretsService(this.request);
+    this.enterprise = new EnterpriseService(this.request);
+    this.enterpriseCmk = new EnterpriseCmkService(this.request);
     this.environmentTypes = new EnvironmentTypesService(this.request);
     this.environmentVariables = new EnvironmentVariablesService(this.request);
     this.environmentVariablesPointInTime = new EnvironmentVariablesPointInTimeService(this.request);
     this.environmentVariablesRollback = new EnvironmentVariablesRollbackService(this.request);
     this.fileUpload = new FileUploadService(this.request);
     this.gpgKeys = new GpgKeysService(this.request);
+    this.license = new LicenseService(this.request);
+    this.logForwarding = new LogForwardingService(this.request);
+    this.oidcProviders = new OidcProvidersService(this.request);
     this.onboarding = new OnboardingService(this.request);
     this.organizations = new OrganizationsService(this.request);
+    this.orgFeatures = new OrgFeaturesService(this.request);
     this.permissions = new PermissionsService(this.request);
     this.roles = new RolesService(this.request);
+    this.rotation = new RotationService(this.request);
+    this.samlProviders = new SamlProvidersService(this.request);
+    this.samlSso = new SamlSsoService(this.request);
     this.secrets = new SecretsService(this.request);
     this.secretsPointInTime = new SecretsPointInTimeService(this.request);
     this.secretsRollback = new SecretsRollbackService(this.request);
     this.serviceTokens = new ServiceTokensService(this.request);
+    this.setup = new SetupService(this.request);
     this.system = new SystemService(this.request);
     this.teams = new TeamsService(this.request);
     this.users = new UsersService(this.request);
@@ -3470,8 +5151,8 @@ var EnvSyncAPISDK = class {
 
 // src/core/OpenAPI.ts
 var OpenAPI = {
-  BASE: "http://localhost:4000",
-  VERSION: "0.10.0",
+  BASE: "http://localhost:0",
+  VERSION: "0.20.1",
   WITH_CREDENTIALS: false,
   CREDENTIALS: "include",
   TOKEN: void 0,
@@ -3498,6 +5179,118 @@ var ChangeRequestResponse;
   })(status = ChangeRequestResponse2.status || (ChangeRequestResponse2.status = {}));
 })(ChangeRequestResponse || (ChangeRequestResponse = {}));
 
+// src/models/CreateDynamicSecretEngineRequest.ts
+var CreateDynamicSecretEngineRequest;
+((CreateDynamicSecretEngineRequest2) => {
+  let engine_type;
+  ((engine_type2) => {
+    engine_type2["POSTGRES"] = "postgres";
+    engine_type2["MYSQL"] = "mysql";
+    engine_type2["AWS_IAM"] = "aws-iam";
+    engine_type2["AZURE_SP"] = "azure-sp";
+  })(engine_type = CreateDynamicSecretEngineRequest2.engine_type || (CreateDynamicSecretEngineRequest2.engine_type = {}));
+})(CreateDynamicSecretEngineRequest || (CreateDynamicSecretEngineRequest = {}));
+
+// src/models/CreateIntegrationBindingRequest.ts
+var CreateIntegrationBindingRequest;
+((CreateIntegrationBindingRequest2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = CreateIntegrationBindingRequest2.provider_type || (CreateIntegrationBindingRequest2.provider_type = {}));
+})(CreateIntegrationBindingRequest || (CreateIntegrationBindingRequest = {}));
+
+// src/models/CreateLogForwardingRequest.ts
+var CreateLogForwardingRequest;
+((CreateLogForwardingRequest2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["DATADOG"] = "datadog";
+    provider_type2["SPLUNK"] = "splunk";
+    provider_type2["SUMO_LOGIC"] = "sumo-logic";
+  })(provider_type = CreateLogForwardingRequest2.provider_type || (CreateLogForwardingRequest2.provider_type = {}));
+})(CreateLogForwardingRequest || (CreateLogForwardingRequest = {}));
+
+// src/models/CreateManualSyncRunRequest.ts
+var CreateManualSyncRunRequest;
+((CreateManualSyncRunRequest2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = CreateManualSyncRunRequest2.provider_type || (CreateManualSyncRunRequest2.provider_type = {}));
+})(CreateManualSyncRunRequest || (CreateManualSyncRunRequest = {}));
+
+// src/models/CreateOidcProviderRequest.ts
+var CreateOidcProviderRequest;
+((CreateOidcProviderRequest2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB_ACTIONS"] = "github_actions";
+    provider_type2["GITLAB_CI"] = "gitlab_ci";
+    provider_type2["KUBERNETES"] = "kubernetes";
+    provider_type2["GENERIC"] = "generic";
+  })(provider_type = CreateOidcProviderRequest2.provider_type || (CreateOidcProviderRequest2.provider_type = {}));
+})(CreateOidcProviderRequest || (CreateOidcProviderRequest = {}));
+
+// src/models/CreateProviderConnectionRequest.ts
+var CreateProviderConnectionRequest;
+((CreateProviderConnectionRequest2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = CreateProviderConnectionRequest2.provider_type || (CreateProviderConnectionRequest2.provider_type = {}));
+  let status;
+  ((status2) => {
+    status2["ACTIVE"] = "active";
+    status2["INACTIVE"] = "inactive";
+    status2["ERROR"] = "error";
+  })(status = CreateProviderConnectionRequest2.status || (CreateProviderConnectionRequest2.status = {}));
+})(CreateProviderConnectionRequest || (CreateProviderConnectionRequest = {}));
+
+// src/models/CreateRotationPolicyRequest.ts
+var CreateRotationPolicyRequest;
+((CreateRotationPolicyRequest2) => {
+  let engine_type;
+  ((engine_type2) => {
+    engine_type2["POSTGRES"] = "postgres";
+    engine_type2["MYSQL"] = "mysql";
+    engine_type2["AWS_IAM"] = "aws-iam";
+    engine_type2["AZURE_SP"] = "azure-sp";
+    engine_type2["GCP_SERVICE_ACCOUNT"] = "gcp-service-account";
+    engine_type2["CLOUDFLARE_PAGES"] = "cloudflare-pages";
+    engine_type2["SENDGRID"] = "sendgrid";
+    engine_type2["TWILIO"] = "twilio";
+  })(engine_type = CreateRotationPolicyRequest2.engine_type || (CreateRotationPolicyRequest2.engine_type = {}));
+})(CreateRotationPolicyRequest || (CreateRotationPolicyRequest = {}));
+
+// src/models/CreateSamlProviderRequest.ts
+var CreateSamlProviderRequest;
+((CreateSamlProviderRequest2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["OKTA"] = "okta";
+    provider_type2["ONELOGIN"] = "onelogin";
+    provider_type2["AZURE_AD"] = "azure-ad";
+    provider_type2["GOOGLE_WORKSPACE"] = "google-workspace";
+    provider_type2["DUO"] = "duo";
+    provider_type2["RIPPLING"] = "rippling";
+    provider_type2["ORACLE"] = "oracle";
+    provider_type2["PING_IDENTITY"] = "ping-identity";
+  })(provider_type = CreateSamlProviderRequest2.provider_type || (CreateSamlProviderRequest2.provider_type = {}));
+})(CreateSamlProviderRequest || (CreateSamlProviderRequest = {}));
+
 // src/models/CreateWebhookRequest.ts
 var CreateWebhookRequest;
 ((CreateWebhookRequest2) => {
@@ -3521,6 +5314,18 @@ var CreateWebhookRequest;
   })(linked_to = CreateWebhookRequest2.linked_to || (CreateWebhookRequest2.linked_to = {}));
 })(CreateWebhookRequest || (CreateWebhookRequest = {}));
 
+// src/models/DynamicSecretEngineResponse.ts
+var DynamicSecretEngineResponse;
+((DynamicSecretEngineResponse2) => {
+  let engine_type;
+  ((engine_type2) => {
+    engine_type2["POSTGRES"] = "postgres";
+    engine_type2["MYSQL"] = "mysql";
+    engine_type2["AWS_IAM"] = "aws-iam";
+    engine_type2["AZURE_SP"] = "azure-sp";
+  })(engine_type = DynamicSecretEngineResponse2.engine_type || (DynamicSecretEngineResponse2.engine_type = {}));
+})(DynamicSecretEngineResponse || (DynamicSecretEngineResponse = {}));
+
 // src/models/EffectiveAccessEntry.ts
 var EffectiveAccessEntry;
 ((EffectiveAccessEntry2) => {
@@ -3550,6 +5355,19 @@ var EffectiveAccessEntry;
   })(team_relation = EffectiveAccessEntry2.team_relation || (EffectiveAccessEntry2.team_relation = {}));
 })(EffectiveAccessEntry || (EffectiveAccessEntry = {}));
 
+// src/models/EnterpriseProviderProfile.ts
+var EnterpriseProviderProfile;
+((EnterpriseProviderProfile2) => {
+  let id;
+  ((id2) => {
+    id2["GITHUB"] = "github";
+    id2["GITLAB"] = "gitlab";
+    id2["AWS_SSM"] = "aws-ssm";
+    id2["VERCEL"] = "vercel";
+    id2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(id = EnterpriseProviderProfile2.id || (EnterpriseProviderProfile2.id = {}));
+})(EnterpriseProviderProfile || (EnterpriseProviderProfile = {}));
+
 // src/models/ExportEnvRequest.ts
 var ExportEnvRequest;
 ((ExportEnvRequest2) => {
@@ -3611,6 +5429,19 @@ var GrantEntry;
   })(relation = GrantEntry2.relation || (GrantEntry2.relation = {}));
 })(GrantEntry || (GrantEntry = {}));
 
+// src/models/IntegrationBinding.ts
+var IntegrationBinding;
+((IntegrationBinding2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = IntegrationBinding2.provider_type || (IntegrationBinding2.provider_type = {}));
+})(IntegrationBinding || (IntegrationBinding = {}));
+
 // src/models/LicenseState.ts
 var LicenseState;
 ((LicenseState2) => {
@@ -3631,6 +5462,117 @@ var LicenseState;
   })(validation_mode = LicenseState2.validation_mode || (LicenseState2.validation_mode = {}));
 })(LicenseState || (LicenseState = {}));
 
+// src/models/LogForwardingResponse.ts
+var LogForwardingResponse;
+((LogForwardingResponse2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["DATADOG"] = "datadog";
+    provider_type2["SPLUNK"] = "splunk";
+    provider_type2["SUMO_LOGIC"] = "sumo-logic";
+  })(provider_type = LogForwardingResponse2.provider_type || (LogForwardingResponse2.provider_type = {}));
+})(LogForwardingResponse || (LogForwardingResponse = {}));
+
+// src/models/OidcProviderResponse.ts
+var OidcProviderResponse;
+((OidcProviderResponse2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB_ACTIONS"] = "github_actions";
+    provider_type2["GITLAB_CI"] = "gitlab_ci";
+    provider_type2["KUBERNETES"] = "kubernetes";
+    provider_type2["GENERIC"] = "generic";
+  })(provider_type = OidcProviderResponse2.provider_type || (OidcProviderResponse2.provider_type = {}));
+})(OidcProviderResponse || (OidcProviderResponse = {}));
+
+// src/models/OrgKmsConfigResponse.ts
+var OrgKmsConfigResponse;
+((OrgKmsConfigResponse2) => {
+  let source;
+  ((source2) => {
+    source2["MANAGED"] = "managed";
+    source2["AWS_KMS"] = "aws-kms";
+    source2["GCP_KMS"] = "gcp-kms";
+    source2["AZURE_KV"] = "azure-kv";
+  })(source = OrgKmsConfigResponse2.source || (OrgKmsConfigResponse2.source = {}));
+  let status;
+  ((status2) => {
+    status2["ACTIVE"] = "active";
+    status2["PENDING"] = "pending";
+    status2["ROTATING"] = "rotating";
+    status2["UNAVAILABLE"] = "unavailable";
+    status2["DISABLED"] = "disabled";
+  })(status = OrgKmsConfigResponse2.status || (OrgKmsConfigResponse2.status = {}));
+})(OrgKmsConfigResponse || (OrgKmsConfigResponse = {}));
+
+// src/models/OrgKmsJobResponse.ts
+var OrgKmsJobResponse;
+((OrgKmsJobResponse2) => {
+  let kind;
+  ((kind2) => {
+    kind2["KEK_REWRAP"] = "kek_rewrap";
+    kind2["DEK_REWRAP"] = "dek_rewrap";
+    kind2["DETACH_MANAGED"] = "detach_managed";
+  })(kind = OrgKmsJobResponse2.kind || (OrgKmsJobResponse2.kind = {}));
+  let status;
+  ((status2) => {
+    status2["PENDING"] = "pending";
+    status2["RUNNING"] = "running";
+    status2["SUCCEEDED"] = "succeeded";
+    status2["FAILED"] = "failed";
+  })(status = OrgKmsJobResponse2.status || (OrgKmsJobResponse2.status = {}));
+})(OrgKmsJobResponse || (OrgKmsJobResponse = {}));
+
+// src/models/OrgKmsVerifyResponse.ts
+var OrgKmsVerifyResponse;
+((OrgKmsVerifyResponse2) => {
+  let source;
+  ((source2) => {
+    source2["MANAGED"] = "managed";
+    source2["AWS_KMS"] = "aws-kms";
+    source2["GCP_KMS"] = "gcp-kms";
+    source2["AZURE_KV"] = "azure-kv";
+  })(source = OrgKmsVerifyResponse2.source || (OrgKmsVerifyResponse2.source = {}));
+  let status;
+  ((status2) => {
+    status2["ACTIVE"] = "active";
+    status2["PENDING"] = "pending";
+    status2["ROTATING"] = "rotating";
+    status2["UNAVAILABLE"] = "unavailable";
+    status2["DISABLED"] = "disabled";
+  })(status = OrgKmsVerifyResponse2.status || (OrgKmsVerifyResponse2.status = {}));
+})(OrgKmsVerifyResponse || (OrgKmsVerifyResponse = {}));
+
+// src/models/ProviderConnection.ts
+var ProviderConnection;
+((ProviderConnection2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = ProviderConnection2.provider_type || (ProviderConnection2.provider_type = {}));
+  let status;
+  ((status2) => {
+    status2["ACTIVE"] = "active";
+    status2["INACTIVE"] = "inactive";
+    status2["ERROR"] = "error";
+  })(status = ProviderConnection2.status || (ProviderConnection2.status = {}));
+})(ProviderConnection || (ProviderConnection = {}));
+
+// src/models/PutOrgFeatureGrantRequest.ts
+var PutOrgFeatureGrantRequest;
+((PutOrgFeatureGrantRequest2) => {
+  let source;
+  ((source2) => {
+    source2["BILLING"] = "billing";
+    source2["SUPPORT"] = "support";
+    source2["SEED"] = "seed";
+  })(source = PutOrgFeatureGrantRequest2.source || (PutOrgFeatureGrantRequest2.source = {}));
+})(PutOrgFeatureGrantRequest || (PutOrgFeatureGrantRequest = {}));
+
 // src/models/RevokeAccessRequest.ts
 var RevokeAccessRequest;
 ((RevokeAccessRequest2) => {
@@ -3659,6 +5601,38 @@ var RotateGpgKeyRequest;
   })(algorithm = RotateGpgKeyRequest2.algorithm || (RotateGpgKeyRequest2.algorithm = {}));
 })(RotateGpgKeyRequest || (RotateGpgKeyRequest = {}));
 
+// src/models/RotationPolicyResponse.ts
+var RotationPolicyResponse;
+((RotationPolicyResponse2) => {
+  let engine_type;
+  ((engine_type2) => {
+    engine_type2["POSTGRES"] = "postgres";
+    engine_type2["MYSQL"] = "mysql";
+    engine_type2["AWS_IAM"] = "aws-iam";
+    engine_type2["AZURE_SP"] = "azure-sp";
+    engine_type2["GCP_SERVICE_ACCOUNT"] = "gcp-service-account";
+    engine_type2["CLOUDFLARE_PAGES"] = "cloudflare-pages";
+    engine_type2["SENDGRID"] = "sendgrid";
+    engine_type2["TWILIO"] = "twilio";
+  })(engine_type = RotationPolicyResponse2.engine_type || (RotationPolicyResponse2.engine_type = {}));
+})(RotationPolicyResponse || (RotationPolicyResponse = {}));
+
+// src/models/SamlProviderResponse.ts
+var SamlProviderResponse;
+((SamlProviderResponse2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["OKTA"] = "okta";
+    provider_type2["ONELOGIN"] = "onelogin";
+    provider_type2["AZURE_AD"] = "azure-ad";
+    provider_type2["GOOGLE_WORKSPACE"] = "google-workspace";
+    provider_type2["DUO"] = "duo";
+    provider_type2["RIPPLING"] = "rippling";
+    provider_type2["ORACLE"] = "oracle";
+    provider_type2["PING_IDENTITY"] = "ping-identity";
+  })(provider_type = SamlProviderResponse2.provider_type || (SamlProviderResponse2.provider_type = {}));
+})(SamlProviderResponse || (SamlProviderResponse = {}));
+
 // src/models/SecretVariableRollbackResponse.ts
 var SecretVariableRollbackResponse;
 ((SecretVariableRollbackResponse2) => {
@@ -3670,6 +5644,21 @@ var SecretVariableRollbackResponse;
   })(operation = SecretVariableRollbackResponse2.operation || (SecretVariableRollbackResponse2.operation = {}));
 })(SecretVariableRollbackResponse || (SecretVariableRollbackResponse = {}));
 
+// src/models/SetupStatusResponse.ts
+var SetupStatusResponse;
+((SetupStatusResponse2) => {
+  let deployment_mode;
+  ((deployment_mode2) => {
+    deployment_mode2["HOSTED"] = "hosted";
+    deployment_mode2["SELFHOSTED"] = "selfhosted";
+  })(deployment_mode = SetupStatusResponse2.deployment_mode || (SetupStatusResponse2.deployment_mode = {}));
+  let edition;
+  ((edition2) => {
+    edition2["OSS"] = "oss";
+    edition2["ENTERPRISE"] = "enterprise";
+  })(edition = SetupStatusResponse2.edition || (SetupStatusResponse2.edition = {}));
+})(SetupStatusResponse || (SetupStatusResponse = {}));
+
 // src/models/SignDataRequest.ts
 var SignDataRequest;
 ((SignDataRequest2) => {
@@ -3681,6 +5670,45 @@ var SignDataRequest;
   })(mode = SignDataRequest2.mode || (SignDataRequest2.mode = {}));
 })(SignDataRequest || (SignDataRequest = {}));
 
+// src/models/SyncAuditEvent.ts
+var SyncAuditEvent;
+((SyncAuditEvent2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = SyncAuditEvent2.provider_type || (SyncAuditEvent2.provider_type = {}));
+  let result;
+  ((result2) => {
+    result2["INFO"] = "info";
+    result2["SUCCESS"] = "success";
+    result2["ERROR"] = "error";
+  })(result = SyncAuditEvent2.result || (SyncAuditEvent2.result = {}));
+})(SyncAuditEvent || (SyncAuditEvent = {}));
+
+// src/models/SyncRun.ts
+var SyncRun;
+((SyncRun2) => {
+  let provider_type;
+  ((provider_type2) => {
+    provider_type2["GITHUB"] = "github";
+    provider_type2["GITLAB"] = "gitlab";
+    provider_type2["AWS_SSM"] = "aws-ssm";
+    provider_type2["VERCEL"] = "vercel";
+    provider_type2["GOOGLE_SECRET_MANAGER"] = "google-secret-manager";
+  })(provider_type = SyncRun2.provider_type || (SyncRun2.provider_type = {}));
+  let status;
+  ((status2) => {
+    status2["PENDING"] = "pending";
+    status2["RUNNING"] = "running";
+    status2["SUCCEEDED"] = "succeeded";
+    status2["FAILED"] = "failed";
+  })(status = SyncRun2.status || (SyncRun2.status = {}));
+})(SyncRun || (SyncRun = {}));
+
 // src/models/SystemStatusState.ts
 var SystemStatusState;
 ((SystemStatusState2) => {
@@ -3689,8 +5717,36 @@ var SystemStatusState;
     edition2["OSS"] = "oss";
     edition2["ENTERPRISE"] = "enterprise";
   })(edition = SystemStatusState2.edition || (SystemStatusState2.edition = {}));
+  let deployment_mode;
+  ((deployment_mode2) => {
+    deployment_mode2["HOSTED"] = "hosted";
+    deployment_mode2["SELFHOSTED"] = "selfhosted";
+  })(deployment_mode = SystemStatusState2.deployment_mode || (SystemStatusState2.deployment_mode = {}));
 })(SystemStatusState || (SystemStatusState = {}));
 
+// src/models/UpdateOrgKmsConfigRequest.ts
+var UpdateOrgKmsConfigRequest;
+((UpdateOrgKmsConfigRequest2) => {
+  let source;
+  ((source2) => {
+    source2["MANAGED"] = "managed";
+    source2["AWS_KMS"] = "aws-kms";
+    source2["GCP_KMS"] = "gcp-kms";
+    source2["AZURE_KV"] = "azure-kv";
+  })(source = UpdateOrgKmsConfigRequest2.source || (UpdateOrgKmsConfigRequest2.source = {}));
+})(UpdateOrgKmsConfigRequest || (UpdateOrgKmsConfigRequest = {}));
+
+// src/models/UpdateProviderConnectionRequest.ts
+var UpdateProviderConnectionRequest;
+((UpdateProviderConnectionRequest2) => {
+  let status;
+  ((status2) => {
+    status2["ACTIVE"] = "active";
+    status2["INACTIVE"] = "inactive";
+    status2["ERROR"] = "error";
+  })(status = UpdateProviderConnectionRequest2.status || (UpdateProviderConnectionRequest2.status = {}));
+})(UpdateProviderConnectionRequest || (UpdateProviderConnectionRequest = {}));
+
 // src/models/UpdateTrustLevelRequest.ts
 var UpdateTrustLevelRequest;
 ((UpdateTrustLevelRequest2) => {
@@ -3760,6 +5816,18 @@ var WebhookResponse;
     linked_to2["APP"] = "app";
   })(linked_to = WebhookResponse2.linked_to || (WebhookResponse2.linked_to = {}));
 })(WebhookResponse || (WebhookResponse = {}));
+
+// src/models/WhoAmIResponse.ts
+var WhoAmIResponse;
+((WhoAmIResponse2) => {
+  let auth_type;
+  ((auth_type2) => {
+    auth_type2["JWT"] = "jwt";
+    auth_type2["SAML"] = "saml";
+    auth_type2["OIDC"] = "oidc";
+    auth_type2["API_KEY"] = "api_key";
+  })(auth_type = WhoAmIResponse2.auth_type || (WhoAmIResponse2.auth_type = {}));
+})(WhoAmIResponse || (WhoAmIResponse = {}));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AccessService,
@@ -3774,8 +5842,21 @@ var WebhookResponse;
   CertificatesService,
   ChangeRequestResponse,
   ChangeRequestsService,
+  CreateDynamicSecretEngineRequest,
+  CreateIntegrationBindingRequest,
+  CreateLogForwardingRequest,
+  CreateManualSyncRunRequest,
+  CreateOidcProviderRequest,
+  CreateProviderConnectionRequest,
+  CreateRotationPolicyRequest,
+  CreateSamlProviderRequest,
   CreateWebhookRequest,
+  DynamicSecretEngineResponse,
+  DynamicSecretsService,
   EffectiveAccessEntry,
+  EnterpriseCmkService,
+  EnterpriseProviderProfile,
+  EnterpriseService,
   EnvSyncAPISDK,
   EnvironmentTypesService,
   EnvironmentVariablesPointInTimeService,
@@ -3787,28 +5868,52 @@ var WebhookResponse;
   GpgKeysService,
   GrantAccessRequest,
   GrantEntry,
+  IntegrationBinding,
+  LicenseService,
   LicenseState,
+  LogForwardingResponse,
+  LogForwardingService,
+  OidcProviderResponse,
+  OidcProvidersService,
   OnboardingService,
   OpenAPI,
+  OrgFeaturesService,
+  OrgKmsConfigResponse,
+  OrgKmsJobResponse,
+  OrgKmsVerifyResponse,
   OrganizationsService,
   PermissionsService,
+  ProviderConnection,
+  PutOrgFeatureGrantRequest,
   RevokeAccessRequest,
   RolesService,
   RotateGpgKeyRequest,
+  RotationPolicyResponse,
+  RotationService,
+  SamlProviderResponse,
+  SamlProvidersService,
+  SamlSsoService,
   SecretVariableRollbackResponse,
   SecretsPointInTimeService,
   SecretsRollbackService,
   SecretsService,
   ServiceTokensService,
+  SetupService,
+  SetupStatusResponse,
   SignDataRequest,
+  SyncAuditEvent,
+  SyncRun,
   SystemService,
   SystemStatusState,
   TeamsService,
+  UpdateOrgKmsConfigRequest,
+  UpdateProviderConnectionRequest,
   UpdateTrustLevelRequest,
   UpdateWebhookRequest,
   UsersService,
   VariableRollbackResponse,
   WebhookResponse,
-  WebhooksService
+  WebhooksService,
+  WhoAmIResponse
 });
 //# sourceMappingURL=index.js.map