@envsync-cloud/envsync-ts-sdk 0.10.4 → 0.20.0

package/dist/index.js

@@ -32,8 +32,20 @@ __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,
+  EnterpriseProviderProfile: () => EnterpriseProviderProfile,
+  EnterpriseService: () => EnterpriseService,
   EnvSyncAPISDK: () => EnvSyncAPISDK,
   EnvironmentTypesService: () => EnvironmentTypesService,
   EnvironmentVariablesPointInTimeService: () => EnvironmentVariablesPointInTimeService,
@@ -45,23 +57,40 @@ __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,
   OrganizationsService: () => OrganizationsService,
   PermissionsService: () => PermissionsService,
+  ProviderConnection: () => ProviderConnection,
   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,
+  UpdateProviderConnectionRequest: () => UpdateProviderConnectionRequest,
   UpdateTrustLevelRequest: () => UpdateTrustLevelRequest,
   UpdateWebhookRequest: () => UpdateWebhookRequest,
   UsersService: () => UsersService,
@@ -825,23 +854,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 +1246,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 +1516,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 +1538,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 +1569,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 +1590,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 +1628,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 +1652,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,47 +1691,947 @@ var EnvironmentVariablesRollbackService = class {
     });
   }
   /**
-   * Rollback Single Variable to Timestamp
-   * Rollback a specific environment variable to a timestamp
+   * Update Enterprise Env-Type Mapping
+   * @param appId
+   * @param id
+   * @param requestBody
+   * @returns EnvTypeMapping Env-type mapping updated
+   * @throws ApiError
+   */
+  updateEnterpriseEnvTypeMapping(appId, id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/v1/manage/enterprise/apps/{app_id}/env-type-mappings/{id}",
+      path: {
+        "app_id": appId,
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * 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`
+      }
+    });
+  }
+  /**
+   * Create Enterprise Manual Sync Run
+   * @param requestBody
+   * @returns SyncRun Sync run created
+   * @throws ApiError
+   */
+  createEnterpriseManualSyncRun(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      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`
+      }
+    });
+  }
+};
+
+// 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`
+      }
+    });
+  }
+  /**
+   * Create Environment Type
+   * Create a new environment type
+   * @param requestBody
+   * @returns EnvTypeResponse Environment type created successfully
+   * @throws ApiError
+   */
+  createEnvType(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env_type",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Environment Type
+   * Retrieve a specific environment type
+   * @param id
+   * @returns EnvTypeResponse Environment type retrieved successfully
+   * @throws ApiError
+   */
+  getEnvType(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/env_type/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Environment Type
+   * Update an existing environment type
+   * @param id
+   * @param requestBody
+   * @returns EnvTypeResponse Environment type updated successfully
+   * @throws ApiError
+   */
+  updateEnvType(id, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/env_type/{id}",
+      path: {
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Environment Type
+   * Delete an existing environment type
+   * @param id
+   * @returns DeleteEnvTypeRequest Environment type deleted successfully
+   * @throws ApiError
+   */
+  deleteEnvType(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/env_type/{id}",
+      path: {
+        "id": id
+      },
+      errors: {
+        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.
+   * @param requestBody
+   * @returns ExportEnvResponse Environment exported successfully
+   * @throws ApiError
+   */
+  exportEnvironment(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/export",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Invalid export request`
+      }
+    });
+  }
+  /**
+   * Get Environment Variables
+   * Retrieve all environment variables for an application and environment type
+   * @param requestBody
+   * @returns EnvsResponse Environment variables retrieved successfully
+   * @throws ApiError
+   */
+  getEnvs(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Delete Environment Variable
+   * Delete an existing environment variable
+   * @param requestBody
+   * @returns DeleteEnvRequest Environment variable deleted successfully
+   * @throws ApiError
+   */
+  deleteEnv(requestBody) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/env",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Single Environment Variable
+   * Retrieve a specific environment variable
    * @param key
    * @param requestBody
-   * @returns VariableRollbackResponse Variable rolled back successfully
+   * @returns EnvResponse Environment variable retrieved successfully
+   * @throws ApiError
+   */
+  getEnv(key, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/i/{key}",
+      path: {
+        "key": key
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Update Environment Variable
+   * Update an existing environment variable
+   * @param key
+   * @param requestBody
+   * @returns EnvResponse Environment variable updated successfully
+   * @throws ApiError
+   */
+  updateEnv(key, requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/env/i/{key}",
+      path: {
+        "key": key
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Create Environment Variable
+   * Create a new environment variable
+   * @param requestBody
+   * @returns EnvResponse Environment variable created successfully
+   * @throws ApiError
+   */
+  createEnv(requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/env/single",
+      body: requestBody,
+      mediaType: "application/json",
+      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
+   * @throws ApiError
+   */
+  batchCreateEnvs(requestBody) {
+    return this.httpRequest.request({
+      method: "PUT",
+      url: "/api/env/batch",
+      body: requestBody,
+      mediaType: "application/json",
+      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
+   * @throws ApiError
+   */
+  batchUpdateEnvs(requestBody) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/api/env/batch",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Batch Delete Environment Variables
+   * Delete multiple environment variables in a single request
+   * @param requestBody
+   * @returns BatchEnvsResponse Environment variables deleted successfully
+   * @throws ApiError
+   */
+  deleteBatchEnv(requestBody) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/api/env/batch",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+};
+
+// src/services/EnvironmentVariablesPointInTimeService.ts
+var EnvironmentVariablesPointInTimeService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get Environment Variables History
+   * Retrieve paginated history of environment variable changes
+   * @param requestBody
+   * @returns EnvHistoryResponse Environment variables history retrieved successfully
+   * @throws ApiError
+   */
+  getEnvHistory(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/history",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * 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
+   * @throws ApiError
+   */
+  getEnvsAtPointInTime(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/pit",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Environment Variables at Timestamp
+   * Retrieve environment variables state at a specific timestamp
+   * @param requestBody
+   * @returns EnvPitStateResponse Environment variables at timestamp retrieved successfully
+   * @throws ApiError
+   */
+  getEnvsAtTimestamp(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/env/timestamp",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * Get Environment Variables Diff
+   * Compare environment variables between two points in time
+   * @param requestBody
+   * @returns EnvDiffResponse Environment variables diff retrieved successfully
+   * @throws ApiError
+   */
+  getEnvDiff(requestBody) {
+    return this.httpRequest.request({
+      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`
+      }
+    });
+  }
+};
+
+// 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
+   * @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
    */
-  rollbackVariableToTimestamp(key, requestBody) {
+  getLogForwardingConfig(id) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/env/rollback/variable/{key}/timestamp",
+      method: "GET",
+      url: "/api/v1/manage/log_forwarding/{id}",
       path: {
-        "key": key
+        "id": id
       },
-      body: requestBody,
-      mediaType: "application/json",
       errors: {
+        404: `Config not found`,
         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
+   * Delete Log Forwarding Config
+   * Delete a log forwarding configuration
+   * @param id
+   * @returns ErrorResponse Log forwarding config deleted successfully
    * @throws ApiError
    */
-  uploadFile(formData) {
+  deleteLogForwardingConfig(id) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/upload/file",
-      formData,
-      mediaType: "multipart/form-data",
+      method: "DELETE",
+      url: "/api/v1/manage/log_forwarding/{id}",
+      path: {
+        "id": id
+      },
       errors: {
         500: `Internal server error`
       }
@@ -1725,22 +2639,22 @@ var FileUploadService = class {
   }
 };
 
-// src/services/GpgKeysService.ts
-var GpgKeysService = class {
+// src/services/OidcProvidersService.ts
+var OidcProvidersService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
   }
   /**
-   * Generate GPG Key
-   * Generate a new GPG key pair for the organization
+   * Register OIDC Provider
+   * Register a new OIDC provider for CI/CD machine authentication
    * @param requestBody
-   * @returns GpgKeyResponse GPG key generated successfully
+   * @returns OidcProviderResponse OIDC provider created successfully
    * @throws ApiError
    */
-  generateGpgKey(requestBody) {
+  createOidcProvider(requestBody) {
     return this.httpRequest.request({
-      method: "PUT",
-      url: "/api/gpg_key/generate",
+      method: "POST",
+      url: "/api/v1/manage/oidc",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1749,52 +2663,54 @@ var GpgKeysService = class {
     });
   }
   /**
-   * Import GPG Key
-   * Import an existing GPG key into the organization
-   * @param requestBody
-   * @returns GpgKeyResponse GPG key imported successfully
+   * Get All OIDC Providers
+   * Retrieve all OIDC providers for the organization
+   * @returns OidcProvidersResponse OIDC providers retrieved successfully
    * @throws ApiError
    */
-  importGpgKey(requestBody) {
+  getAllOidcProviders() {
     return this.httpRequest.request({
-      method: "PUT",
-      url: "/api/gpg_key/import",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/oidc",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Sign Data
-   * Sign data using a GPG key
-   * @param requestBody
-   * @returns SignatureResponse Data signed successfully
+   * Get OIDC Provider
+   * Retrieve a specific OIDC provider
+   * @param id
+   * @returns OidcProviderResponse OIDC provider retrieved successfully
    * @throws ApiError
    */
-  signDataWithGpgKey(requestBody) {
+  getOidcProvider(id) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/gpg_key/sign",
-      body: requestBody,
-      mediaType: "application/json",
+      method: "GET",
+      url: "/api/v1/manage/oidc/{id}",
+      path: {
+        "id": id
+      },
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Verify Signature
-   * Verify a GPG signature
+   * Update OIDC Provider
+   * Update an existing OIDC provider
+   * @param id
    * @param requestBody
-   * @returns VerifyResponse Verification result
+   * @returns ErrorResponse OIDC provider updated successfully
    * @throws ApiError
    */
-  verifyGpgSignature(requestBody) {
+  updateOidcProvider(id, requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/gpg_key/verify",
+      method: "PUT",
+      url: "/api/v1/manage/oidc/{id}",
+      path: {
+        "id": id
+      },
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1803,33 +2719,62 @@ var GpgKeysService = class {
     });
   }
   /**
-   * List GPG Keys
-   * List all GPG keys for the organization
-   * @returns GpgKeysResponse GPG keys retrieved successfully
+   * Delete OIDC Provider
+   * Delete an existing OIDC provider
+   * @param id
+   * @returns ErrorResponse OIDC provider deleted successfully
    * @throws ApiError
    */
-  listGpgKeys() {
+  deleteOidcProvider(id) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/gpg_key",
+      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 GPG Key
-   * Retrieve a specific GPG key
-   * @param id
-   * @returns GpgKeyDetailResponse GPG key retrieved successfully
+   * Get Organization Invite by Code
+   * Get organization invite by code
+   * @param inviteCode
+   * @returns GetOrgInviteByCodeResponse Organization invite retrieved successfully
    * @throws ApiError
    */
-  getGpgKey(id) {
+  getOrgInviteByCode(inviteCode) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/gpg_key/{id}",
+      url: "/api/onboarding/org/{invite_code}",
       path: {
-        "id": id
+        "invite_code": inviteCode
       },
       errors: {
         500: `Internal server error`
@@ -1837,37 +2782,40 @@ var GpgKeysService = class {
     });
   }
   /**
-   * Delete GPG Key
-   * Delete a GPG key from the organization
-   * @param id
-   * @returns GpgKeyResponse GPG key deleted successfully
+   * Accept Organization Invite
+   * Accept organization invite
+   * @param inviteCode
+   * @param requestBody
+   * @returns AcceptOrgInviteResponse Organization invite accepted successfully
    * @throws ApiError
    */
-  deleteGpgKey(id) {
+  acceptOrgInvite(inviteCode, requestBody) {
     return this.httpRequest.request({
-      method: "DELETE",
-      url: "/api/gpg_key/{id}",
+      method: "PUT",
+      url: "/api/onboarding/org/{invite_code}/accept",
       path: {
-        "id": id
+        "invite_code": inviteCode
       },
+      body: requestBody,
+      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Export GPG Public Key
-   * Export the ASCII-armored public key
-   * @param id
-   * @returns ExportKeyResponse Public key exported successfully
+   * Get User Invite by Code
+   * Get user invite by code
+   * @param inviteCode
+   * @returns GetUserInviteByTokenResponse User invite retrieved successfully
    * @throws ApiError
    */
-  exportGpgPublicKey(id) {
+  getUserInviteByCode(inviteCode) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/gpg_key/{id}/export",
+      url: "/api/onboarding/user/{invite_code}",
       path: {
-        "id": id
+        "invite_code": inviteCode
       },
       errors: {
         500: `Internal server error`
@@ -1875,19 +2823,19 @@ var GpgKeysService = class {
     });
   }
   /**
-   * Revoke GPG Key
-   * Revoke a GPG key (keeps data but marks as revoked)
-   * @param id
+   * Update User Invite
+   * Update user invite
+   * @param inviteCode
    * @param requestBody
-   * @returns GpgKeyDetailResponse GPG key revoked successfully
+   * @returns UpdateUserInviteResponse User invite updated successfully
    * @throws ApiError
    */
-  revokeGpgKey(id, requestBody) {
+  updateUserInvite(inviteCode, requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/gpg_key/{id}/revoke",
+      method: "PATCH",
+      url: "/api/onboarding/user/{invite_code}",
       path: {
-        "id": id
+        "invite_code": inviteCode
       },
       body: requestBody,
       mediaType: "application/json",
@@ -1897,19 +2845,19 @@ var GpgKeysService = class {
     });
   }
   /**
-   * Rotate GPG Key
-   * Create a replacement GPG key, optionally promote it to default, and supersede the original key.
-   * @param id
+   * Accept User Invite
+   * Accept user invite
+   * @param inviteCode
    * @param requestBody
-   * @returns GpgKeyDetailResponse GPG key rotated successfully
+   * @returns AcceptUserInviteResponse User invite accepted successfully
    * @throws ApiError
    */
-  rotateGpgKey(id, requestBody) {
+  acceptUserInvite(inviteCode, requestBody) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/gpg_key/{id}/rotate",
+      method: "PUT",
+      url: "/api/onboarding/user/{invite_code}/accept",
       path: {
-        "id": id
+        "invite_code": inviteCode
       },
       body: requestBody,
       mediaType: "application/json",
@@ -1919,20 +2867,16 @@ var GpgKeysService = class {
     });
   }
   /**
-   * Extend GPG Key Expiry
-   * Extend the expiry date of an active GPG key without rotating it.
-   * @param id
+   * Create User Invite
+   * Create a user invite
    * @param requestBody
-   * @returns GpgKeyDetailResponse GPG key expiry extended successfully
+   * @returns CreateUserInviteResponse User invite created successfully
    * @throws ApiError
    */
-  extendGpgKeyExpiry(id, requestBody) {
+  createUserInvite(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/gpg_key/{id}/extend-expiry",
-      path: {
-        "id": id
-      },
+      url: "/api/onboarding/user",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1941,34 +2885,39 @@ var GpgKeysService = class {
     });
   }
   /**
-   * Update Trust Level
-   * Update the trust level of a GPG key
-   * @param id
-   * @param requestBody
-   * @returns GpgKeyDetailResponse Trust level updated successfully
+   * Get All User Invites
+   * Get all user invites
+   * @returns GetUserInviteByTokenResponse User invites retrieved successfully
    * @throws ApiError
    */
-  updateGpgKeyTrustLevel(id, requestBody) {
+  getAllUserInvites() {
     return this.httpRequest.request({
-      method: "PATCH",
-      url: "/api/gpg_key/{id}/trust",
+      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: {
-        "id": id
+        "invite_id": inviteId
       },
-      body: requestBody,
-      mediaType: "application/json",
       errors: {
         500: `Internal server error`
       }
     });
   }
-};
-
-// src/services/OnboardingService.ts
-var OnboardingService = class {
-  constructor(httpRequest) {
-    this.httpRequest = httpRequest;
-  }
   /**
    * Create Organization Invite
    * Create an organization invite
@@ -1976,10 +2925,10 @@ var OnboardingService = class {
    * @returns CreateOrgInviteResponse Successful greeting response
    * @throws ApiError
    */
-  createOrgInvite(requestBody) {
+  manageCreateOrgInvite(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/onboarding/org",
+      url: "/api/v1/manage/onboarding/org",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -1994,10 +2943,10 @@ var OnboardingService = class {
    * @returns GetOrgInviteByCodeResponse Organization invite retrieved successfully
    * @throws ApiError
    */
-  getOrgInviteByCode(inviteCode) {
+  manageGetOrgInviteByCode(inviteCode) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/onboarding/org/{invite_code}",
+      url: "/api/v1/manage/onboarding/org/{invite_code}",
       path: {
         "invite_code": inviteCode
       },
@@ -2014,10 +2963,10 @@ var OnboardingService = class {
    * @returns AcceptOrgInviteResponse Organization invite accepted successfully
    * @throws ApiError
    */
-  acceptOrgInvite(inviteCode, requestBody) {
+  manageAcceptOrgInvite(inviteCode, requestBody) {
     return this.httpRequest.request({
       method: "PUT",
-      url: "/api/onboarding/org/{invite_code}/accept",
+      url: "/api/v1/manage/onboarding/org/{invite_code}/accept",
       path: {
         "invite_code": inviteCode
       },
@@ -2035,10 +2984,10 @@ var OnboardingService = class {
    * @returns GetUserInviteByTokenResponse User invite retrieved successfully
    * @throws ApiError
    */
-  getUserInviteByCode(inviteCode) {
+  manageGetUserInviteByCode(inviteCode) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/onboarding/user/{invite_code}",
+      url: "/api/v1/manage/onboarding/user/{invite_code}",
       path: {
         "invite_code": inviteCode
       },
@@ -2055,10 +3004,10 @@ var OnboardingService = class {
    * @returns UpdateUserInviteResponse User invite updated successfully
    * @throws ApiError
    */
-  updateUserInvite(inviteCode, requestBody) {
+  manageUpdateUserInvite(inviteCode, requestBody) {
     return this.httpRequest.request({
       method: "PATCH",
-      url: "/api/onboarding/user/{invite_code}",
+      url: "/api/v1/manage/onboarding/user/{invite_code}",
       path: {
         "invite_code": inviteCode
       },
@@ -2077,10 +3026,10 @@ var OnboardingService = class {
    * @returns AcceptUserInviteResponse User invite accepted successfully
    * @throws ApiError
    */
-  acceptUserInvite(inviteCode, requestBody) {
+  manageAcceptUserInvite(inviteCode, requestBody) {
     return this.httpRequest.request({
       method: "PUT",
-      url: "/api/onboarding/user/{invite_code}/accept",
+      url: "/api/v1/manage/onboarding/user/{invite_code}/accept",
       path: {
         "invite_code": inviteCode
       },
@@ -2098,10 +3047,10 @@ var OnboardingService = class {
    * @returns CreateUserInviteResponse User invite created successfully
    * @throws ApiError
    */
-  createUserInvite(requestBody) {
+  manageCreateUserInvite(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/onboarding/user",
+      url: "/api/v1/manage/onboarding/user",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -2115,10 +3064,10 @@ var OnboardingService = class {
    * @returns GetUserInviteByTokenResponse User invites retrieved successfully
    * @throws ApiError
    */
-  getAllUserInvites() {
+  manageGetAllUserInvites() {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/onboarding/user",
+      url: "/api/v1/manage/onboarding/user",
       errors: {
         500: `Internal server error`
       }
@@ -2131,10 +3080,10 @@ var OnboardingService = class {
    * @returns DeleteUserInviteResponse User invite deleted successfully
    * @throws ApiError
    */
-  deleteUserInvite(inviteId) {
+  manageDeleteUserInvite(inviteId) {
     return this.httpRequest.request({
       method: "DELETE",
-      url: "/api/onboarding/user/{invite_id}",
+      url: "/api/v1/manage/onboarding/user/{invite_id}",
       path: {
         "invite_id": inviteId
       },
@@ -2243,174 +3192,447 @@ var PermissionsService = class {
     });
   }
   /**
-   * Grant App Access
-   * Grant a user or team access to an app
-   * @param appId
+   * 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 PermissionMessageResponse Access granted successfully
+   * @returns RotationPolicyResponse Rotation policy created successfully
    * @throws ApiError
    */
-  grantAppAccess(appId, requestBody) {
+  createRotationPolicy(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/permission/app/{app_id}/grant",
-      path: {
-        "app_id": appId
-      },
+      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`
       }
     });
   }
   /**
-   * Revoke App Access
-   * Revoke a user or team's access to an app
+   * Get Rotation Policies
+   * List all rotation policies for the organization
    * @param appId
-   * @param requestBody
-   * @returns PermissionMessageResponse Access revoked successfully
+   * @param envTypeId
+   * @param enabled
+   * @returns RotationPoliciesResponse Rotation policies retrieved successfully
    * @throws ApiError
    */
-  revokeAppAccess(appId, requestBody) {
+  getRotationPolicies(appId, envTypeId, enabled) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/permission/app/{app_id}/revoke",
-      path: {
-        "app_id": appId
+      method: "GET",
+      url: "/api/v1/manage/rotation",
+      query: {
+        "app_id": appId,
+        "env_type_id": envTypeId,
+        "enabled": enabled
       },
-      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
+   * Get Rotation Policy
+   * Get a specific rotation policy by ID
+   * @param id
+   * @returns RotationPolicyResponse Rotation policy retrieved successfully
    * @throws ApiError
    */
-  listAppGrants(appId) {
+  getRotationPolicy(id) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/permission/app/{app_id}/grants",
+      url: "/api/v1/manage/rotation/{id}",
       path: {
-        "app_id": appId
+        "id": id
+      },
+      errors: {
+        404: `Not found`,
+        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
+   * Update Rotation Policy
+   * Update an existing rotation policy
+   * @param id
+   * @param requestBody
+   * @returns RotationPolicyResponse Rotation policy updated successfully
    * @throws ApiError
    */
-  getAppEffectiveAccess(appId) {
+  updateRotationPolicy(id, requestBody) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/permission/app/{app_id}/effective-access",
+      method: "PATCH",
+      url: "/api/v1/manage/rotation/{id}",
       path: {
-        "app_id": appId
+        "id": id
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        403: `Forbidden`,
+        404: `Not found`,
+        500: `Internal server error`
       }
     });
   }
   /**
-   * Grant Env Type Access
-   * Grant a user or team access to an environment type
+   * Delete Rotation Policy
+   * Delete a rotation policy
    * @param id
-   * @param requestBody
-   * @returns PermissionMessageResponse Access granted successfully
+   * @returns ErrorResponse Rotation policy deleted successfully
    * @throws ApiError
    */
-  grantEnvTypeAccess(id, requestBody) {
+  deleteRotationPolicy(id) {
     return this.httpRequest.request({
-      method: "POST",
-      url: "/api/permission/env_type/{id}/grant",
+      method: "DELETE",
+      url: "/api/v1/manage/rotation/{id}",
       path: {
         "id": id
       },
-      body: requestBody,
-      mediaType: "application/json",
       errors: {
+        403: `Forbidden`,
+        404: `Not found`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * Revoke Env Type Access
-   * Revoke a user or team's access to an environment type
+   * Trigger Rotation
+   * Manually trigger a secret rotation for a policy
    * @param id
-   * @param requestBody
-   * @returns PermissionMessageResponse Access revoked successfully
+   * @returns TriggerRotationResponse Rotation executed successfully
    * @throws ApiError
    */
-  revokeEnvTypeAccess(id, requestBody) {
+  triggerRotation(id) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/permission/env_type/{id}/revoke",
+      url: "/api/v1/manage/rotation/{id}/rotate",
       path: {
         "id": id
       },
-      body: requestBody,
-      mediaType: "application/json",
       errors: {
+        403: `Forbidden`,
+        404: `Not found`,
+        409: `Conflict - policy disabled`,
         500: `Internal server error`
       }
     });
   }
   /**
-   * List Env Type Grants
-   * List direct user and team grants on an environment type
+   * Get Rotation States
+   * Get the rotation state history for a policy
    * @param id
-   * @returns GrantsListResponse Env type grants listed successfully
+   * @returns RotationStatesResponse Rotation states retrieved successfully
    * @throws ApiError
    */
-  listEnvTypeGrants(id) {
+  getRotationStates(id) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/permission/env_type/{id}/grants",
+      url: "/api/v1/manage/rotation/{id}/states",
       path: {
         "id": id
+      },
+      errors: {
+        404: `Not found`,
+        500: `Internal server error`
       }
     });
   }
-};
-
-// 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
+   * Revoke Expired Credentials
+   * Revoke old credentials that have passed their dual-credential window
+   * @returns RevokeOldCredentialResponse Expired credentials revoked successfully
    * @throws ApiError
    */
-  getAllRoles() {
+  revokeExpiredCredentials() {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/api/role",
+      method: "POST",
+      url: "/api/v1/manage/rotation/revoke-expired",
       errors: {
         500: `Internal server error`
       }
     });
   }
+};
+
+// src/services/SamlProvidersService.ts
+var SamlProvidersService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
   /**
-   * Create Role
-   * Create a new role in the organization
+   * Register SAML Provider
+   * Register a new SAML identity provider for SSO authentication
    * @param requestBody
-   * @returns RoleResponse Role created successfully
+   * @returns SamlProviderResponse SAML provider created successfully
    * @throws ApiError
    */
-  createRole(requestBody) {
+  createSamlProvider(requestBody) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/api/role",
+      url: "/api/v1/manage/saml",
       body: requestBody,
       mediaType: "application/json",
       errors: {
@@ -2419,31 +3641,31 @@ var RolesService = class {
     });
   }
   /**
-   * Get Role Statistics
-   * Retrieve statistics about roles in the organization
-   * @returns RoleStatsResponse Role statistics retrieved successfully
+   * Get All SAML Providers
+   * Retrieve all SAML providers for the organization
+   * @returns SamlProvidersResponse SAML providers retrieved successfully
    * @throws ApiError
    */
-  getRoleStats() {
+  getAllSamlProviders() {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/role/stats",
+      url: "/api/v1/manage/saml",
       errors: {
         500: `Internal server error`
       }
     });
   }
   /**
-   * Get Role
-   * Retrieve a specific role by ID
+   * Get SAML Provider
+   * Retrieve a specific SAML provider
    * @param id
-   * @returns RoleResponse Role retrieved successfully
+   * @returns SamlProviderResponse SAML provider retrieved successfully
    * @throws ApiError
    */
-  getRole(id) {
+  getSamlProvider(id) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/api/role/{id}",
+      url: "/api/v1/manage/saml/{id}",
       path: {
         "id": id
       },
@@ -2453,17 +3675,17 @@ var RolesService = class {
     });
   }
   /**
-   * Update Role
-   * Update an existing role
+   * Update SAML Provider
+   * Update an existing SAML provider
    * @param id
    * @param requestBody
-   * @returns RoleResponse Role updated successfully
+   * @returns ErrorResponse SAML provider updated successfully
    * @throws ApiError
    */
-  updateRole(id, requestBody) {
+  updateSamlProvider(id, requestBody) {
     return this.httpRequest.request({
-      method: "PATCH",
-      url: "/api/role/{id}",
+      method: "PUT",
+      url: "/api/v1/manage/saml/{id}",
       path: {
         "id": id
       },
@@ -2475,16 +3697,16 @@ var RolesService = class {
     });
   }
   /**
-   * Delete Role
-   * Delete an existing role (non-master roles only)
+   * Delete SAML Provider
+   * Delete an existing SAML provider
    * @param id
-   * @returns RoleResponse Role deleted successfully
+   * @returns ErrorResponse SAML provider deleted successfully
    * @throws ApiError
    */
-  deleteRole(id) {
+  deleteSamlProvider(id) {
     return this.httpRequest.request({
       method: "DELETE",
-      url: "/api/role/{id}",
+      url: "/api/v1/manage/saml/{id}",
       path: {
         "id": id
       },
@@ -2493,6 +3715,66 @@ var RolesService = class {
       }
     });
   }
+  /**
+   * Get SAML SP Metadata
+   * Retrieve SAML Service Provider metadata XML for the organization
+   * @param id
+   * @returns string SP metadata XML
+   * @throws ApiError
+   */
+  getSamlMetadata(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/api/v1/manage/saml/{id}/metadata",
+      path: {
+        "id": id
+      }
+    });
+  }
+};
+
+// src/services/SamlSsoService.ts
+var SamlSsoService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Initiate SAML SSO
+   * Start SP-initiated SAML SSO flow by generating an AuthnRequest redirect URL
+   * @param requestBody
+   * @returns SamlSsoResponse Redirect URL generated
+   * @throws ApiError
+   */
+  initiateSamlSso(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/saml/sso",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        500: `Internal server error`
+      }
+    });
+  }
+  /**
+   * SAML Assertion Consumer Service
+   * Receive and validate SAML Response from the identity provider (ACS endpoint)
+   * @param orgId
+   * @returns any Authentication successful
+   * @throws ApiError
+   */
+  handleSamlAcs(orgId) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/api/v1/manage/saml/acs/{orgId}",
+      path: {
+        "orgId": orgId
+      },
+      errors: {
+        401: `Authentication failed`
+      }
+    });
+  }
 };
 
 // src/services/SecretsService.ts
@@ -2956,6 +4238,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 +4297,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 +4601,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 +4745,29 @@ var EnvSyncAPISDK = class {
   authentication;
   certificates;
   changeRequests;
+  dynamicSecrets;
+  enterprise;
   environmentTypes;
   environmentVariables;
   environmentVariablesPointInTime;
   environmentVariablesRollback;
   fileUpload;
   gpgKeys;
+  license;
+  logForwarding;
+  oidcProviders;
   onboarding;
   organizations;
   permissions;
   roles;
+  rotation;
+  samlProviders;
+  samlSso;
   secrets;
   secretsPointInTime;
   secretsRollback;
   serviceTokens;
+  setup;
   system;
   teams;
   users;
@@ -3431,7 +4776,7 @@ var EnvSyncAPISDK = class {
   constructor(config, HttpRequest = FetchHttpRequest) {
     this.request = new HttpRequest({
       BASE: config?.BASE ?? "http://localhost:4000",
-      VERSION: config?.VERSION ?? "0.10.0",
+      VERSION: config?.VERSION ?? "0.20.0",
       WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
       CREDENTIALS: config?.CREDENTIALS ?? "include",
       TOKEN: config?.TOKEN,
@@ -3447,20 +4792,29 @@ 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.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.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);
@@ -3471,7 +4825,7 @@ var EnvSyncAPISDK = class {
 // src/core/OpenAPI.ts
 var OpenAPI = {
   BASE: "http://localhost:4000",
-  VERSION: "0.10.0",
+  VERSION: "0.20.0",
   WITH_CREDENTIALS: false,
   CREDENTIALS: "include",
   TOKEN: void 0,
@@ -3498,6 +4852,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 +4987,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 +5028,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 +5102,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 +5135,48 @@ 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/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/RevokeAccessRequest.ts
 var RevokeAccessRequest;
 ((RevokeAccessRequest2) => {
@@ -3659,6 +5205,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 +5248,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 +5274,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 +5321,24 @@ 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/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) => {
@@ -3774,8 +5422,20 @@ var WebhookResponse;
   CertificatesService,
   ChangeRequestResponse,
   ChangeRequestsService,
+  CreateDynamicSecretEngineRequest,
+  CreateIntegrationBindingRequest,
+  CreateLogForwardingRequest,
+  CreateManualSyncRunRequest,
+  CreateOidcProviderRequest,
+  CreateProviderConnectionRequest,
+  CreateRotationPolicyRequest,
+  CreateSamlProviderRequest,
   CreateWebhookRequest,
+  DynamicSecretEngineResponse,
+  DynamicSecretsService,
   EffectiveAccessEntry,
+  EnterpriseProviderProfile,
+  EnterpriseService,
   EnvSyncAPISDK,
   EnvironmentTypesService,
   EnvironmentVariablesPointInTimeService,
@@ -3787,23 +5447,40 @@ var WebhookResponse;
   GpgKeysService,
   GrantAccessRequest,
   GrantEntry,
+  IntegrationBinding,
+  LicenseService,
   LicenseState,
+  LogForwardingResponse,
+  LogForwardingService,
+  OidcProviderResponse,
+  OidcProvidersService,
   OnboardingService,
   OpenAPI,
   OrganizationsService,
   PermissionsService,
+  ProviderConnection,
   RevokeAccessRequest,
   RolesService,
   RotateGpgKeyRequest,
+  RotationPolicyResponse,
+  RotationService,
+  SamlProviderResponse,
+  SamlProvidersService,
+  SamlSsoService,
   SecretVariableRollbackResponse,
   SecretsPointInTimeService,
   SecretsRollbackService,
   SecretsService,
   ServiceTokensService,
+  SetupService,
+  SetupStatusResponse,
   SignDataRequest,
+  SyncAuditEvent,
+  SyncRun,
   SystemService,
   SystemStatusState,
   TeamsService,
+  UpdateProviderConnectionRequest,
   UpdateTrustLevelRequest,
   UpdateWebhookRequest,
   UsersService,