@envsync-cloud/envsync-management-ts-sdk 0.8.5

package/dist/index.d.mts

@@ -0,0 +1,747 @@
+type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+
+declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+declare const OpenAPI: OpenAPIConfig;
+
+declare abstract class BaseHttpRequest {
+    readonly config: OpenAPIConfig;
+    constructor(config: OpenAPIConfig);
+    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}
+
+type CreateEnvTypeMappingRequest = {
+    env_type_id: string;
+    integration_binding_id: string;
+    target_identifier: string;
+    branch_ref?: string | null;
+    path_prefix?: string | null;
+    metadata?: Record<string, any>;
+};
+
+type CreateIntegrationBindingRequest = {
+    provider_connection_id: string;
+    provider_type: CreateIntegrationBindingRequest.provider_type;
+    is_enabled?: boolean;
+    metadata?: Record<string, any>;
+};
+declare namespace CreateIntegrationBindingRequest {
+    enum provider_type {
+        GITHUB = "github",
+        GITLAB = "gitlab",
+        AWS_SSM = "aws-ssm",
+        VERCEL = "vercel",
+        GOOGLE_SECRET_MANAGER = "google-secret-manager"
+    }
+}
+
+type CreateManualSyncRunRequest = {
+    app_id?: string | null;
+    provider_type: CreateManualSyncRunRequest.provider_type;
+    metadata?: Record<string, any>;
+};
+declare namespace CreateManualSyncRunRequest {
+    enum provider_type {
+        GITHUB = "github",
+        GITLAB = "gitlab",
+        AWS_SSM = "aws-ssm",
+        VERCEL = "vercel",
+        GOOGLE_SECRET_MANAGER = "google-secret-manager"
+    }
+}
+
+type CreateOrgSecretRequest = {
+    key: string;
+    value: string;
+    description?: string | null;
+    metadata?: Record<string, any>;
+};
+
+type CreateProviderConnectionRequest = {
+    provider_type: CreateProviderConnectionRequest.provider_type;
+    name: string;
+    status?: CreateProviderConnectionRequest.status;
+    auth_config?: Record<string, any>;
+    metadata?: Record<string, any>;
+};
+declare namespace CreateProviderConnectionRequest {
+    enum provider_type {
+        GITHUB = "github",
+        GITLAB = "gitlab",
+        AWS_SSM = "aws-ssm",
+        VERCEL = "vercel",
+        GOOGLE_SECRET_MANAGER = "google-secret-manager"
+    }
+    enum status {
+        ACTIVE = "active",
+        INACTIVE = "inactive",
+        ERROR = "error"
+    }
+}
+
+type EnterpriseProviderProfile = {
+    id: EnterpriseProviderProfile.id;
+    name: string;
+    scope: string;
+    description: string;
+    connection_requirements: Array<string>;
+    binding_metadata_fields: Array<string>;
+    mapping_requirements: Array<string>;
+};
+declare namespace EnterpriseProviderProfile {
+    enum id {
+        GITHUB = "github",
+        GITLAB = "gitlab",
+        AWS_SSM = "aws-ssm",
+        VERCEL = "vercel",
+        GOOGLE_SECRET_MANAGER = "google-secret-manager"
+    }
+}
+
+type EnterpriseProvidersResponse = {
+    providers: Array<EnterpriseProviderProfile>;
+};
+
+type EnvTypeMapping = {
+    id: string;
+    org_id: string;
+    app_id: string;
+    env_type_id: string;
+    integration_binding_id: string;
+    target_identifier: string;
+    branch_ref?: string | null;
+    path_prefix?: string | null;
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+};
+
+type EnvTypeMappingsResponse = Array<EnvTypeMapping>;
+
+type IntegrationBinding = {
+    id: string;
+    org_id: string;
+    app_id: string;
+    provider_connection_id: string;
+    provider_type: IntegrationBinding.provider_type;
+    is_enabled: boolean;
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+};
+declare namespace IntegrationBinding {
+    enum provider_type {
+        GITHUB = "github",
+        GITLAB = "gitlab",
+        AWS_SSM = "aws-ssm",
+        VERCEL = "vercel",
+        GOOGLE_SECRET_MANAGER = "google-secret-manager"
+    }
+}
+
+type IntegrationBindingsResponse = Array<IntegrationBinding>;
+
+type OrgSecret = {
+    id: string;
+    org_id: string;
+    key: string;
+    value: string;
+    description?: string | null;
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+};
+
+type OrgSecretModelResponse = {
+    resource: string;
+    description: string;
+    fields: Array<string>;
+};
+
+type OrgSecretsResponse = Array<OrgSecret>;
+
+type ProviderConnection = {
+    id: string;
+    org_id: string;
+    provider_type: ProviderConnection.provider_type;
+    name: string;
+    status: ProviderConnection.status;
+    auth_config: Record<string, any>;
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+};
+declare namespace ProviderConnection {
+    enum provider_type {
+        GITHUB = "github",
+        GITLAB = "gitlab",
+        AWS_SSM = "aws-ssm",
+        VERCEL = "vercel",
+        GOOGLE_SECRET_MANAGER = "google-secret-manager"
+    }
+    enum status {
+        ACTIVE = "active",
+        INACTIVE = "inactive",
+        ERROR = "error"
+    }
+}
+
+type ProviderConnectionsResponse = Array<ProviderConnection>;
+
+type SyncAuditEvent = {
+    id: string;
+    org_id: string;
+    sync_run_id?: string | null;
+    app_id?: string | null;
+    env_type_id?: string | null;
+    provider_type: SyncAuditEvent.provider_type;
+    action: string;
+    result: SyncAuditEvent.result;
+    actor_user_id?: string | null;
+    details: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+};
+declare namespace SyncAuditEvent {
+    enum provider_type {
+        GITHUB = "github",
+        GITLAB = "gitlab",
+        AWS_SSM = "aws-ssm",
+        VERCEL = "vercel",
+        GOOGLE_SECRET_MANAGER = "google-secret-manager"
+    }
+    enum result {
+        INFO = "info",
+        SUCCESS = "success",
+        ERROR = "error"
+    }
+}
+
+type SyncAuditEventsResponse = Array<SyncAuditEvent>;
+
+type SyncRun = {
+    id: string;
+    org_id: string;
+    app_id?: string | null;
+    provider_type: SyncRun.provider_type;
+    status: SyncRun.status;
+    actor_user_id?: string | null;
+    started_at: string;
+    completed_at?: string | null;
+    error_message?: string | null;
+    metadata: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+};
+declare namespace SyncRun {
+    enum provider_type {
+        GITHUB = "github",
+        GITLAB = "gitlab",
+        AWS_SSM = "aws-ssm",
+        VERCEL = "vercel",
+        GOOGLE_SECRET_MANAGER = "google-secret-manager"
+    }
+    enum status {
+        PENDING = "pending",
+        RUNNING = "running",
+        SUCCEEDED = "succeeded",
+        FAILED = "failed"
+    }
+}
+
+type SyncRunsResponse = Array<SyncRun>;
+
+type UpdateEnvTypeMappingRequest = {
+    target_identifier?: string;
+    branch_ref?: string | null;
+    path_prefix?: string | null;
+    metadata?: Record<string, any>;
+};
+
+type UpdateIntegrationBindingRequest = {
+    is_enabled?: boolean;
+    metadata?: Record<string, any>;
+};
+
+type UpdateOrgSecretRequest = {
+    value?: string;
+    description?: string | null;
+    metadata?: Record<string, any>;
+};
+
+type UpdateProviderConnectionRequest = {
+    name?: string;
+    status?: UpdateProviderConnectionRequest.status;
+    auth_config?: Record<string, any>;
+    metadata?: Record<string, any>;
+};
+declare namespace UpdateProviderConnectionRequest {
+    enum status {
+        ACTIVE = "active",
+        INACTIVE = "inactive",
+        ERROR = "error"
+    }
+}
+
+declare class EnterpriseService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * List Enterprise Providers
+     * @returns EnterpriseProvidersResponse Enterprise provider catalog
+     * @throws ApiError
+     */
+    listEnterpriseProviders(): CancelablePromise<EnterpriseProvidersResponse>;
+    /**
+     * Get Enterprise Org Secret Model
+     * @returns OrgSecretModelResponse Org secret model
+     * @throws ApiError
+     */
+    getEnterpriseOrgSecretModel(): CancelablePromise<OrgSecretModelResponse>;
+    /**
+     * List Enterprise Provider Connections
+     * @returns ProviderConnectionsResponse Provider connections
+     * @throws ApiError
+     */
+    listEnterpriseProviderConnections(): CancelablePromise<ProviderConnectionsResponse>;
+    /**
+     * Create Enterprise Provider Connection
+     * @param requestBody
+     * @returns ProviderConnection Provider connection created
+     * @throws ApiError
+     */
+    createEnterpriseProviderConnection(requestBody?: CreateProviderConnectionRequest): CancelablePromise<ProviderConnection>;
+    /**
+     * Update Enterprise Provider Connection
+     * @param id
+     * @param requestBody
+     * @returns ProviderConnection Provider connection updated
+     * @throws ApiError
+     */
+    updateEnterpriseProviderConnection(id: string, requestBody?: UpdateProviderConnectionRequest): CancelablePromise<ProviderConnection>;
+    /**
+     * List Enterprise Org Secrets
+     * @returns OrgSecretsResponse Org secrets
+     * @throws ApiError
+     */
+    listEnterpriseOrgSecrets(): CancelablePromise<OrgSecretsResponse>;
+    /**
+     * Create Enterprise Org Secret
+     * @param requestBody
+     * @returns OrgSecret Org secret created
+     * @throws ApiError
+     */
+    createEnterpriseOrgSecret(requestBody?: CreateOrgSecretRequest): CancelablePromise<OrgSecret>;
+    /**
+     * Update Enterprise Org Secret
+     * @param id
+     * @param requestBody
+     * @returns OrgSecret Org secret updated
+     * @throws ApiError
+     */
+    updateEnterpriseOrgSecret(id: string, requestBody?: UpdateOrgSecretRequest): CancelablePromise<OrgSecret>;
+    /**
+     * List Enterprise Integration Bindings
+     * @param appId
+     * @returns IntegrationBindingsResponse Integration bindings
+     * @throws ApiError
+     */
+    listEnterpriseIntegrationBindings(appId: string): CancelablePromise<IntegrationBindingsResponse>;
+    /**
+     * Create Enterprise Integration Binding
+     * @param appId
+     * @param requestBody
+     * @returns IntegrationBinding Integration binding created
+     * @throws ApiError
+     */
+    createEnterpriseIntegrationBinding(appId: string, requestBody?: CreateIntegrationBindingRequest): CancelablePromise<IntegrationBinding>;
+    /**
+     * Update Enterprise Integration Binding
+     * @param appId
+     * @param id
+     * @param requestBody
+     * @returns IntegrationBinding Integration binding updated
+     * @throws ApiError
+     */
+    updateEnterpriseIntegrationBinding(appId: string, id: string, requestBody?: UpdateIntegrationBindingRequest): CancelablePromise<IntegrationBinding>;
+    /**
+     * List Enterprise Env-Type Mappings
+     * @param appId
+     * @returns EnvTypeMappingsResponse Env-type mappings
+     * @throws ApiError
+     */
+    listEnterpriseEnvTypeMappings(appId: string): CancelablePromise<EnvTypeMappingsResponse>;
+    /**
+     * Create Enterprise Env-Type Mapping
+     * @param appId
+     * @param requestBody
+     * @returns EnvTypeMapping Env-type mapping created
+     * @throws ApiError
+     */
+    createEnterpriseEnvTypeMapping(appId: string, requestBody?: CreateEnvTypeMappingRequest): CancelablePromise<EnvTypeMapping>;
+    /**
+     * Update Enterprise Env-Type Mapping
+     * @param appId
+     * @param id
+     * @param requestBody
+     * @returns EnvTypeMapping Env-type mapping updated
+     * @throws ApiError
+     */
+    updateEnterpriseEnvTypeMapping(appId: string, id: string, requestBody?: UpdateEnvTypeMappingRequest): CancelablePromise<EnvTypeMapping>;
+    /**
+     * List Enterprise Sync Runs
+     * @returns SyncRunsResponse Sync runs
+     * @throws ApiError
+     */
+    listEnterpriseSyncRuns(): CancelablePromise<SyncRunsResponse>;
+    /**
+     * Create Enterprise Manual Sync Run
+     * @param requestBody
+     * @returns SyncRun Sync run created
+     * @throws ApiError
+     */
+    createEnterpriseManualSyncRun(requestBody?: CreateManualSyncRunRequest): CancelablePromise<SyncRun>;
+    /**
+     * List Enterprise Sync Audit Events
+     * @param syncRunId
+     * @returns SyncAuditEventsResponse Sync audit events
+     * @throws ApiError
+     */
+    listEnterpriseSyncAuditEvents(syncRunId: string): CancelablePromise<SyncAuditEventsResponse>;
+}
+
+type LicenseState = {
+    status: LicenseState.status;
+    lease_expires_at?: string | null;
+    last_verified_at?: string | null;
+    last_error_code?: string | null;
+    last_error_message?: string | null;
+};
+declare namespace LicenseState {
+    enum status {
+        UNKNOWN = "unknown",
+        ACTIVE = "active",
+        INACTIVE = "inactive",
+        EXPIRED = "expired",
+        ERROR = "error",
+        LOCKED = "locked"
+    }
+}
+
+type LicenseActionResponse = {
+    message: string;
+    state: LicenseState;
+};
+
+type LicenseStatusResponse = {
+    required: boolean;
+    locked: boolean;
+    reason?: string | null;
+    state: LicenseState;
+};
+
+declare class LicenseService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get Management License Status
+     * @returns LicenseStatusResponse Current license status
+     * @throws ApiError
+     */
+    getManagementLicenseStatus(): CancelablePromise<LicenseStatusResponse>;
+    /**
+     * Activate Management License
+     * @returns LicenseActionResponse License activated
+     * @throws ApiError
+     */
+    activateManagementLicense(): CancelablePromise<LicenseActionResponse>;
+    /**
+     * Verify Management License
+     * @returns LicenseActionResponse License verified
+     * @throws ApiError
+     */
+    verifyManagementLicense(): CancelablePromise<LicenseActionResponse>;
+}
+
+type AcceptOrgInviteRequest = {
+    org_data: {
+        name: string;
+        size: string;
+        website: string;
+    };
+    user_data: {
+        full_name: string;
+        password: string;
+    };
+};
+
+type AcceptOrgInviteResponse = {
+    message: string;
+    generated_certificate_bundle: {
+        root_ca_pem: string;
+        member_cert_pem: string;
+        member_key_pem: string;
+        member_certificate_id: string;
+        member_serial_hex: string;
+        is_system_generated: boolean;
+    };
+};
+
+type AcceptUserInviteRequest = {
+    full_name: string;
+    password: string;
+};
+
+type AcceptUserInviteResponse = {
+    message: string;
+    generated_certificate_bundle: {
+        root_ca_pem: string;
+        member_cert_pem: string;
+        member_key_pem: string;
+        member_certificate_id: string;
+        member_serial_hex: string;
+        is_system_generated: boolean;
+    };
+};
+
+type CreateOrgInviteRequest = {
+    email: string;
+};
+
+type CreateOrgInviteResponse = {
+    message: string;
+};
+
+type CreateUserInviteRequest = {
+    email: string;
+    role_id: string;
+};
+
+type CreateUserInviteResponse = {
+    message: string;
+};
+
+type DeleteUserInviteResponse = {
+    message: string;
+};
+
+type GetOrgInviteByCodeResponse = {
+    invite: {
+        id: string;
+        email: string;
+        invite_token: string;
+        is_accepted: boolean;
+        created_at: string;
+        updated_at: string;
+    };
+};
+
+type GetUserInviteByTokenResponse = {
+    invite: {
+        id: string;
+        email: string;
+        invite_token: string;
+        role_id: string;
+        org_id: string;
+        is_accepted: boolean;
+        created_at: string;
+        updated_at: string;
+    };
+};
+
+type UpdateUserInviteRequest = {
+    role_id: string;
+};
+
+type UpdateUserInviteResponse = {
+    message: string;
+};
+
+declare class OnboardingService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Create Organization Invite
+     * Create an organization invite
+     * @param requestBody
+     * @returns CreateOrgInviteResponse Successful greeting response
+     * @throws ApiError
+     */
+    createOrgInvite(requestBody?: CreateOrgInviteRequest): CancelablePromise<CreateOrgInviteResponse>;
+    /**
+     * Get Organization Invite by Code
+     * Get organization invite by code
+     * @param inviteCode
+     * @returns GetOrgInviteByCodeResponse Organization invite retrieved successfully
+     * @throws ApiError
+     */
+    getOrgInviteByCode(inviteCode: string): CancelablePromise<GetOrgInviteByCodeResponse>;
+    /**
+     * Accept Organization Invite
+     * Accept organization invite
+     * @param inviteCode
+     * @param requestBody
+     * @returns AcceptOrgInviteResponse Organization invite accepted successfully
+     * @throws ApiError
+     */
+    acceptOrgInvite(inviteCode: string, requestBody?: AcceptOrgInviteRequest): CancelablePromise<AcceptOrgInviteResponse>;
+    /**
+     * Get User Invite by Code
+     * Get user invite by code
+     * @param inviteCode
+     * @returns GetUserInviteByTokenResponse User invite retrieved successfully
+     * @throws ApiError
+     */
+    getUserInviteByCode(inviteCode: string): CancelablePromise<GetUserInviteByTokenResponse>;
+    /**
+     * Update User Invite
+     * Update user invite
+     * @param inviteCode
+     * @param requestBody
+     * @returns UpdateUserInviteResponse User invite updated successfully
+     * @throws ApiError
+     */
+    updateUserInvite(inviteCode: string, requestBody?: UpdateUserInviteRequest): CancelablePromise<UpdateUserInviteResponse>;
+    /**
+     * Accept User Invite
+     * Accept user invite
+     * @param inviteCode
+     * @param requestBody
+     * @returns AcceptUserInviteResponse User invite accepted successfully
+     * @throws ApiError
+     */
+    acceptUserInvite(inviteCode: string, requestBody?: AcceptUserInviteRequest): CancelablePromise<AcceptUserInviteResponse>;
+    /**
+     * Create User Invite
+     * Create a user invite
+     * @param requestBody
+     * @returns CreateUserInviteResponse User invite created successfully
+     * @throws ApiError
+     */
+    createUserInvite(requestBody?: CreateUserInviteRequest): CancelablePromise<CreateUserInviteResponse>;
+    /**
+     * Get All User Invites
+     * Get all user invites
+     * @returns GetUserInviteByTokenResponse User invites retrieved successfully
+     * @throws ApiError
+     */
+    getAllUserInvites(): CancelablePromise<GetUserInviteByTokenResponse>;
+    /**
+     * Delete User Invite
+     * Delete user invite
+     * @param inviteId
+     * @returns DeleteUserInviteResponse User invite deleted successfully
+     * @throws ApiError
+     */
+    deleteUserInvite(inviteId: string): CancelablePromise<DeleteUserInviteResponse>;
+}
+
+type SystemStatusState = {
+    edition: SystemStatusState.edition;
+    single_org_mode: boolean;
+    management_enabled: boolean;
+    observability_enabled: boolean;
+    management_web_enabled: boolean;
+    landing_enabled: boolean;
+    first_bootstrap_completed_at?: string | null;
+    org_count: number;
+};
+declare namespace SystemStatusState {
+    enum edition {
+        OSS = "oss",
+        ENTERPRISE = "enterprise"
+    }
+}
+
+type SystemStatusResponse = {
+    system: SystemStatusState;
+    license: LicenseStatusResponse;
+};
+
+declare class SystemService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Get Management System Status
+     * @returns SystemStatusResponse Management system status
+     * @throws ApiError
+     */
+    getManagementSystemStatus(): CancelablePromise<SystemStatusResponse>;
+}
+
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+declare class EnvSyncManagementAPISDK {
+    readonly enterprise: EnterpriseService;
+    readonly license: LicenseService;
+    readonly onboarding: OnboardingService;
+    readonly system: SystemService;
+    readonly request: BaseHttpRequest;
+    constructor(config?: Partial<OpenAPIConfig>, HttpRequest?: HttpRequestConstructor);
+}
+
+type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};
+
+declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}
+
+type ErrorResponse = {
+    error: string;
+};
+
+export { type AcceptOrgInviteRequest, type AcceptOrgInviteResponse, type AcceptUserInviteRequest, type AcceptUserInviteResponse, ApiError, BaseHttpRequest, CancelError, CancelablePromise, type CreateEnvTypeMappingRequest, CreateIntegrationBindingRequest, CreateManualSyncRunRequest, type CreateOrgInviteRequest, type CreateOrgInviteResponse, type CreateOrgSecretRequest, CreateProviderConnectionRequest, type CreateUserInviteRequest, type CreateUserInviteResponse, type DeleteUserInviteResponse, EnterpriseProviderProfile, type EnterpriseProvidersResponse, EnterpriseService, EnvSyncManagementAPISDK, type EnvTypeMapping, type EnvTypeMappingsResponse, type ErrorResponse, type GetOrgInviteByCodeResponse, type GetUserInviteByTokenResponse, IntegrationBinding, type IntegrationBindingsResponse, type LicenseActionResponse, LicenseService, LicenseState, type LicenseStatusResponse, OnboardingService, OpenAPI, type OpenAPIConfig, type OrgSecret, type OrgSecretModelResponse, type OrgSecretsResponse, ProviderConnection, type ProviderConnectionsResponse, SyncAuditEvent, type SyncAuditEventsResponse, SyncRun, type SyncRunsResponse, SystemService, type SystemStatusResponse, SystemStatusState, type UpdateEnvTypeMappingRequest, type UpdateIntegrationBindingRequest, type UpdateOrgSecretRequest, UpdateProviderConnectionRequest, type UpdateUserInviteRequest, type UpdateUserInviteResponse };