@distilled.cloud/daytona 0.0.0-placeholder → 1.0.0-rc.13

package/lib/services/organizations.d.ts

@@ -0,0 +1,963 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type DaytonaOpError, type DaytonaOpContext } from "../protocol.ts";
+export type { DaytonaOpError, DaytonaOpContext };
+export interface AcceptOrganizationInvitationRequest {
+    /** Invitation ID */
+    invitationId: string;
+}
+export declare const AcceptOrganizationInvitationRequest: S.Schema<AcceptOrganizationInvitationRequest>;
+/** Invitation status */
+export type OrganizationInvitationStatus = "pending" | "accepted" | "declined" | "cancelled";
+export declare const OrganizationInvitationStatus: any;
+/** Member role */
+export type OrganizationInvitationRole = "owner" | "member";
+export declare const OrganizationInvitationRole: any;
+export type OrganizationRolePermissionsItem = "write:registries" | "delete:registries" | "write:snapshots" | "delete:snapshots" | "write:sandboxes" | "delete:sandboxes" | "read:volumes" | "write:volumes" | "delete:volumes" | "write:regions" | "delete:regions" | "read:runners" | "write:runners" | "delete:runners" | "read:audit_logs" | "manage:api_keys" | "manage:secrets" | "read:limits" | "manage:sso" | "read:billing" | "manage:billing";
+export declare const OrganizationRolePermissionsItem: any;
+/** Roles assigned to the user */
+export type OrganizationRolePermissionsList = Array<OrganizationRolePermissionsItem>;
+export declare const OrganizationRolePermissionsList: S.Schema<OrganizationRolePermissionsList>;
+export interface OrganizationRole {
+    /** Role ID */
+    id: string;
+    /** Role name */
+    name: string;
+    /** Role description */
+    description: string;
+    /** Roles assigned to the user */
+    permissions: OrganizationRolePermissionsList;
+    /** Global role flag */
+    isGlobal: boolean;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+export declare const OrganizationRole: S.Schema<OrganizationRole>;
+/** Assigned roles */
+export type OrganizationInvitationAssignedRolesList = Array<OrganizationRole>;
+export declare const OrganizationInvitationAssignedRolesList: S.Schema<OrganizationInvitationAssignedRolesList>;
+export interface OrganizationInvitation {
+    /** Invitation ID */
+    id: string;
+    /** Email address of the invitee */
+    email: string;
+    /** Email address of the inviter */
+    invitedBy: string;
+    /** Organization ID */
+    organizationId: string;
+    /** Organization name */
+    organizationName: string;
+    /** Expiration date of the invitation */
+    expiresAt: string;
+    /** Invitation status */
+    status: OrganizationInvitationStatus;
+    /** Member role */
+    role: OrganizationInvitationRole;
+    /** Assigned roles */
+    assignedRoles: OrganizationInvitationAssignedRolesList;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+export declare const OrganizationInvitation: S.Schema<OrganizationInvitation>;
+export interface CancelOrganizationInvitationRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Invitation ID */
+    invitationId: string;
+}
+export declare const CancelOrganizationInvitationRequest: S.Schema<CancelOrganizationInvitationRequest>;
+export interface CancelOrganizationInvitationResponse {
+}
+export declare const CancelOrganizationInvitationResponse: S.Schema<CancelOrganizationInvitationResponse>;
+export interface CreateOrganizationRequest {
+    /** The name of organization */
+    name: string;
+    /** The ID of the default region for the organization */
+    defaultRegionId: string;
+}
+export declare const CreateOrganizationRequest: S.Schema<CreateOrganizationRequest>;
+/** Headers */
+export type OtelConfigHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const OtelConfigHeadersMap: S.Schema<OtelConfigHeadersMap>;
+export interface OtelConfig {
+    /** Endpoint */
+    endpoint: string;
+    /** Headers */
+    headers?: OtelConfigHeadersMap | null;
+    /** Organization ID the config belongs to */
+    organizationId?: string;
+}
+export declare const OtelConfig: S.Schema<OtelConfig>;
+export interface Organization {
+    /** Organization ID */
+    id: string;
+    /** Organization name */
+    name: string;
+    /** User ID of the organization creator */
+    createdBy: string;
+    /** Personal organization flag */
+    personal: boolean;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+    /** Suspended flag */
+    suspended: boolean;
+    /** Suspended at */
+    suspendedAt: string;
+    /** Suspended reason */
+    suspensionReason: string;
+    /** Suspended until */
+    suspendedUntil: string;
+    /** Suspension cleanup grace period hours */
+    suspensionCleanupGracePeriodHours: number;
+    /** Max CPU per sandbox */
+    maxCpuPerSandbox: number;
+    /** Max memory per sandbox */
+    maxMemoryPerSandbox: number;
+    /** Max disk per sandbox */
+    maxDiskPerSandbox: number;
+    /** Maximum number of secrets */
+    secretQuota: number;
+    /** Maximum number of secrets that can be mounted to a single sandbox */
+    maxSecretsPerSandbox: number;
+    /** Time in minutes before an unused snapshot is deactivated */
+    snapshotDeactivationTimeoutMinutes: number;
+    /** Sandbox default network block all */
+    sandboxLimitedNetworkEgress: boolean;
+    /** Whether the proxy shows the preview URL warning page for this organization */
+    previewWarningEnabled: boolean;
+    /** Whether this organization may configure SSO identity providers */
+    ssoEnabled: boolean;
+    /** Whether this organization may use SCIM directory sync */
+    scimEnabled: boolean;
+    /** Default region ID */
+    defaultRegionId?: string;
+    /** ID of the WorkOS organization mirrored from this organization (absent for personal organizations, which are never mirrored) */
+    workosOrgId?: string;
+    /** Authenticated rate limit per minute */
+    authenticatedRateLimit: number | null;
+    /** Sandbox create rate limit per minute */
+    sandboxCreateRateLimit: number | null;
+    /** Sandbox lifecycle rate limit per minute */
+    sandboxLifecycleRateLimit: number | null;
+    /** Experimental configuration */
+    experimentalConfig: unknown;
+    /** OpenTelemetry collection configuration */
+    otelConfig: OtelConfig | null;
+    /** Authenticated rate limit TTL in seconds */
+    authenticatedRateLimitTtlSeconds: number | null;
+    /** Sandbox create rate limit TTL in seconds */
+    sandboxCreateRateLimitTtlSeconds: number | null;
+    /** Sandbox lifecycle rate limit TTL in seconds */
+    sandboxLifecycleRateLimitTtlSeconds: number | null;
+}
+export declare const Organization: S.Schema<Organization>;
+export interface OidcIdPConfig {
+    /** OIDC Issuer URL */
+    issuerUrl: string;
+    /** OAuth Client ID */
+    clientId: string;
+    /** OAuth Client Secret */
+    clientSecret: string | Redacted.Redacted<string>;
+    /** OAuth scopes */
+    scope?: string;
+}
+export declare const OidcIdPConfig: S.Schema<OidcIdPConfig>;
+/** Email domains used for IdP discovery on the login form and to validate the user identity returned by the IdP. Required and must be non-empty unless `allowAnyDomain` is true. */
+export type CreateOrganizationIdentityProviderRequestEmailDomainsList = Array<string>;
+export declare const CreateOrganizationIdentityProviderRequestEmailDomainsList: S.Schema<CreateOrganizationIdentityProviderRequestEmailDomainsList>;
+/** Organization role IDs assigned to users who join the organization via SSO through this identity provider. Roles must be global or belong to this organization. Empty (default) grants the lowest access: membership with no resource permissions. */
+export type CreateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList = Array<string>;
+export declare const CreateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList: S.Schema<CreateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList>;
+export interface CreateOrganizationIdentityProviderRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Display name for the identity provider */
+    name: string;
+    /** OIDC configuration */
+    oidcConfig: OidcIdPConfig;
+    /** Email domains used for IdP discovery on the login form and to validate the user identity returned by the IdP. Required and must be non-empty unless `allowAnyDomain` is true. */
+    emailDomains: CreateOrganizationIdentityProviderRequestEmailDomainsList;
+    /** When true, the IdP accepts any email domain returned by the external provider. Disables the post-callback domain check and allows `emailDomains` to be empty. Only enable for trusted IdPs that strictly control which users can authenticate. */
+    allowAnyDomain?: boolean;
+    /** When true, skip the `email_verified` claim check on SSO logins through this identity provider. Only intended for providers that never emit the claim (e.g. Microsoft Entra ID). Risky: only enable if the IdP strictly controls its users' email addresses. */
+    trustEmailVerified?: boolean;
+    /** Organization role IDs assigned to users who join the organization via SSO through this identity provider. Roles must be global or belong to this organization. Empty (default) grants the lowest access: membership with no resource permissions. */
+    defaultAssignedRoleIds?: CreateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList;
+    /** Whether the identity provider is enabled */
+    enabled?: boolean;
+}
+export declare const CreateOrganizationIdentityProviderRequest: S.Schema<CreateOrganizationIdentityProviderRequest>;
+export interface OidcIdPConfigResponse {
+    /** OIDC Issuer URL */
+    issuerUrl: string;
+    /** OAuth Client ID */
+    clientId: string;
+    /** OAuth scopes */
+    scope?: string;
+}
+export declare const OidcIdPConfigResponse: S.Schema<OidcIdPConfigResponse>;
+/** Email domains used for IdP discovery on the login form. May be empty when `allowAnyDomain` is true. */
+export type IdentityProviderEmailDomainsList = Array<string>;
+export declare const IdentityProviderEmailDomainsList: S.Schema<IdentityProviderEmailDomainsList>;
+/** Organization role IDs assigned to users who join via SSO through this identity provider */
+export type IdentityProviderDefaultAssignedRoleIdsList = Array<string>;
+export declare const IdentityProviderDefaultAssignedRoleIdsList: S.Schema<IdentityProviderDefaultAssignedRoleIdsList>;
+export interface IdentityProvider {
+    /** Unique identifier */
+    id: string;
+    /** Organization ID */
+    organizationId: string;
+    /** Display name for the identity provider */
+    name: string;
+    /** OIDC configuration (secret redacted) */
+    oidcConfig: OidcIdPConfigResponse;
+    /** Email domains used for IdP discovery on the login form. May be empty when `allowAnyDomain` is true. */
+    emailDomains: IdentityProviderEmailDomainsList;
+    /** Whether the IdP accepts any email domain returned by the external provider */
+    allowAnyDomain: boolean;
+    /** Whether the `email_verified` claim check is skipped on SSO logins through this identity provider */
+    trustEmailVerified: boolean;
+    /** Organization role IDs assigned to users who join via SSO through this identity provider */
+    defaultAssignedRoleIds: IdentityProviderDefaultAssignedRoleIdsList;
+    /** Whether the identity provider is enabled */
+    enabled: boolean;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+export declare const IdentityProvider: S.Schema<IdentityProvider>;
+/** Organization member role for the invitee */
+export type CreateOrganizationInvitationRequestRole = "owner" | "member";
+export declare const CreateOrganizationInvitationRequestRole: any;
+/** Array of assigned role IDs for the invitee */
+export type CreateOrganizationInvitationRequestAssignedRoleIdsList = Array<string>;
+export declare const CreateOrganizationInvitationRequestAssignedRoleIdsList: S.Schema<CreateOrganizationInvitationRequestAssignedRoleIdsList>;
+export interface CreateOrganizationInvitationRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Email address of the invitee */
+    email: string;
+    /** Organization member role for the invitee */
+    role: CreateOrganizationInvitationRequestRole | (string & {});
+    /** Array of assigned role IDs for the invitee */
+    assignedRoleIds: CreateOrganizationInvitationRequestAssignedRoleIdsList;
+    /** Expiration date of the invitation */
+    expiresAt?: string;
+}
+export declare const CreateOrganizationInvitationRequest: S.Schema<CreateOrganizationInvitationRequest>;
+export type CreateOrganizationRoleRequestPermissionsItem = "write:registries" | "delete:registries" | "write:snapshots" | "delete:snapshots" | "write:sandboxes" | "delete:sandboxes" | "read:volumes" | "write:volumes" | "delete:volumes" | "write:regions" | "delete:regions" | "read:runners" | "write:runners" | "delete:runners" | "read:audit_logs" | "manage:api_keys" | "manage:secrets" | "read:limits" | "manage:sso" | "read:billing" | "manage:billing";
+export declare const CreateOrganizationRoleRequestPermissionsItem: any;
+/** The list of permissions assigned to the role */
+export type CreateOrganizationRoleRequestPermissionsList = Array<CreateOrganizationRoleRequestPermissionsItem | (string & {})>;
+export declare const CreateOrganizationRoleRequestPermissionsList: S.Schema<CreateOrganizationRoleRequestPermissionsList>;
+export interface CreateOrganizationRoleRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** The name of the role */
+    name: string;
+    /** The description of the role */
+    description: string;
+    /** The list of permissions assigned to the role */
+    permissions: CreateOrganizationRoleRequestPermissionsList;
+}
+export declare const CreateOrganizationRoleRequest: S.Schema<CreateOrganizationRoleRequest>;
+export interface CreateRegionRequest {
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+    /** Region name */
+    name: string;
+    /** Proxy URL for the region */
+    proxyUrl?: string | null;
+    /** SSH Gateway URL for the region */
+    sshGatewayUrl?: string | null;
+    /** Snapshot Manager URL for the region */
+    snapshotManagerUrl?: string | null;
+    /** OTel collector endpoint for sandboxes created in this region. When set, sandbox OTel data is sent to this endpoint instead of the Daytona-hosted collector and will not be available in the Daytona analytics API or dashboard. */
+    otelEndpoint?: string | null;
+}
+export declare const CreateRegionRequest: S.Schema<CreateRegionRequest>;
+export interface CreateRegionResponse {
+    /** ID of the created region */
+    id: string;
+    /** Proxy API key for the region */
+    proxyApiKey?: string | null;
+    /** SSH Gateway API key for the region */
+    sshGatewayApiKey?: string | null;
+    /** Snapshot Manager username for the region */
+    snapshotManagerUsername?: string | null;
+    /** Snapshot Manager password for the region */
+    snapshotManagerPassword?: string | Redacted.Redacted<string> | null;
+}
+export declare const CreateRegionResponse: S.Schema<CreateRegionResponse>;
+export interface DeclineOrganizationInvitationRequest {
+    /** Invitation ID */
+    invitationId: string;
+}
+export declare const DeclineOrganizationInvitationRequest: S.Schema<DeclineOrganizationInvitationRequest>;
+export interface DeclineOrganizationInvitationResponse {
+}
+export declare const DeclineOrganizationInvitationResponse: S.Schema<DeclineOrganizationInvitationResponse>;
+export interface DeleteOrganizationRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const DeleteOrganizationRequest: S.Schema<DeleteOrganizationRequest>;
+export interface DeleteOrganizationResponse {
+}
+export declare const DeleteOrganizationResponse: S.Schema<DeleteOrganizationResponse>;
+export interface DeleteOrganizationIdentityProviderRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Identity provider ID */
+    id: string;
+}
+export declare const DeleteOrganizationIdentityProviderRequest: S.Schema<DeleteOrganizationIdentityProviderRequest>;
+export interface DeleteOrganizationIdentityProviderResponse {
+}
+export declare const DeleteOrganizationIdentityProviderResponse: S.Schema<DeleteOrganizationIdentityProviderResponse>;
+export interface DeleteOrganizationMemberRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** User ID */
+    userId: string;
+}
+export declare const DeleteOrganizationMemberRequest: S.Schema<DeleteOrganizationMemberRequest>;
+export interface DeleteOrganizationMemberResponse {
+}
+export declare const DeleteOrganizationMemberResponse: S.Schema<DeleteOrganizationMemberResponse>;
+export interface DeleteOrganizationOtelConfigRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const DeleteOrganizationOtelConfigRequest: S.Schema<DeleteOrganizationOtelConfigRequest>;
+export interface DeleteOrganizationOtelConfigResponse {
+}
+export declare const DeleteOrganizationOtelConfigResponse: S.Schema<DeleteOrganizationOtelConfigResponse>;
+export interface DeleteOrganizationRoleRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Role ID */
+    roleId: string;
+}
+export declare const DeleteOrganizationRoleRequest: S.Schema<DeleteOrganizationRoleRequest>;
+export interface DeleteOrganizationRoleResponse {
+}
+export declare const DeleteOrganizationRoleResponse: S.Schema<DeleteOrganizationRoleResponse>;
+export interface DeleteRegionRequest {
+    /** Region ID */
+    id: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const DeleteRegionRequest: S.Schema<DeleteRegionRequest>;
+export interface DeleteRegionResponse {
+}
+export declare const DeleteRegionResponse: S.Schema<DeleteRegionResponse>;
+/** Which setup flow to open: sso for a single sign-on connection, dsync for SCIM directory sync */
+export type WorkosAdminPortalIntent = "sso" | "dsync";
+export declare const WorkosAdminPortalIntent: any;
+export interface GenerateWorkosAdminPortalLinkRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Which setup flow to open: sso for a single sign-on connection, dsync for SCIM directory sync */
+    intent: WorkosAdminPortalIntent | (string & {});
+}
+export declare const GenerateWorkosAdminPortalLinkRequest: S.Schema<GenerateWorkosAdminPortalLinkRequest>;
+export interface WorkosAdminPortalLink {
+    /** Single-purpose WorkOS Admin Portal URL. Expires five minutes after issuance; open it immediately. */
+    link: string;
+}
+export declare const WorkosAdminPortalLink: S.Schema<WorkosAdminPortalLink>;
+export interface GetGpuCapacityRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const GetGpuCapacityRequest: S.Schema<GetGpuCapacityRequest>;
+export type GpuType = "H100" | "H200" | "RTX-PRO-6000" | "RTX-4090" | "RTX-5090" | "MI355X";
+export declare const GpuType: any;
+export interface GpuCapacity {
+    gpuType: GpuType;
+    /** GPU units available for on-demand placement across schedulable runners in the shared US fleet, including capacity occupied by spot sandboxes that are immediately reclaimable. */
+    availableOnDemand: number;
+    /** GPU units currently free for spot placement across schedulable runners in the shared US fleet. */
+    availableSpot: number;
+}
+export declare const GpuCapacity: S.Schema<GpuCapacity>;
+export type GpuCapacityResponseCapacityList = Array<GpuCapacity>;
+export declare const GpuCapacityResponseCapacityList: S.Schema<GpuCapacityResponseCapacityList>;
+export interface GpuCapacityResponse {
+    /** Time at which this capacity snapshot was calculated. Responses may be cached for up to five seconds. */
+    observedAt: string;
+    capacity: GpuCapacityResponseCapacityList;
+}
+export declare const GpuCapacityResponse: S.Schema<GpuCapacityResponse>;
+export interface GetOrganizationRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const GetOrganizationRequest: S.Schema<GetOrganizationRequest>;
+export interface GetOrganizationIdentityProviderRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Identity provider ID */
+    id: string;
+}
+export declare const GetOrganizationIdentityProviderRequest: S.Schema<GetOrganizationIdentityProviderRequest>;
+export interface GetOrganizationInvitationsCountForAuthenticatedUserRequest {
+}
+export declare const GetOrganizationInvitationsCountForAuthenticatedUserRequest: S.Schema<GetOrganizationInvitationsCountForAuthenticatedUserRequest>;
+export type GetOrganizationInvitationsCountForAuthenticatedUserResponse = number;
+export declare const GetOrganizationInvitationsCountForAuthenticatedUserResponse: S.Schema<GetOrganizationInvitationsCountForAuthenticatedUserResponse>;
+export interface GetOrganizationOtelConfigRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const GetOrganizationOtelConfigRequest: S.Schema<GetOrganizationOtelConfigRequest>;
+export interface GetOrganizationOtelConfigBySandboxAuthTokenRequest {
+    /** Sandbox Auth Token */
+    authToken: string;
+}
+export declare const GetOrganizationOtelConfigBySandboxAuthTokenRequest: S.Schema<GetOrganizationOtelConfigBySandboxAuthTokenRequest>;
+export interface GetOrganizationUsageOverviewRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const GetOrganizationUsageOverviewRequest: S.Schema<GetOrganizationUsageOverviewRequest>;
+export type SandboxClass = "linux-vm" | "container" | "android" | "windows";
+export declare const SandboxClass: any;
+export type RegionUsageOverviewAllowedGpuTypesList = Array<GpuType>;
+export declare const RegionUsageOverviewAllowedGpuTypesList: S.Schema<RegionUsageOverviewAllowedGpuTypesList>;
+export interface RegionUsageOverview {
+    regionId: string;
+    sandboxClass: SandboxClass;
+    totalCpuQuota: number;
+    currentCpuUsage: number;
+    totalMemoryQuota: number;
+    currentMemoryUsage: number;
+    totalDiskQuota: number;
+    currentDiskUsage: number;
+    totalGpuQuota: number;
+    currentGpuUsage: number;
+    allowedGpuTypes?: RegionUsageOverviewAllowedGpuTypesList;
+    maxCpuPerSandbox: number | null;
+    maxMemoryPerSandbox: number | null;
+    maxDiskPerSandbox: number | null;
+    maxDiskPerNonEphemeralSandbox: number | null;
+    /** CPU maximum per requested GPU unit for GPU sandboxes. */
+    maxCpuPerGpu: number | null;
+    /** Memory maximum per requested GPU unit for GPU sandboxes. */
+    maxMemoryPerGpu: number | null;
+    /** Disk maximum per requested GPU unit for GPU sandboxes. */
+    maxDiskPerGpu: number | null;
+}
+export declare const RegionUsageOverview: S.Schema<RegionUsageOverview>;
+export type OrganizationUsageOverviewRegionUsageList = Array<RegionUsageOverview>;
+export declare const OrganizationUsageOverviewRegionUsageList: S.Schema<OrganizationUsageOverviewRegionUsageList>;
+export interface OrganizationUsageOverview {
+    regionUsage: OrganizationUsageOverviewRegionUsageList;
+    totalSnapshotQuota: number;
+    currentSnapshotUsage: number;
+    totalVolumeQuota: number;
+    currentVolumeUsage: number;
+}
+export declare const OrganizationUsageOverview: S.Schema<OrganizationUsageOverview>;
+export interface GetRegionRequest {
+    /** Region ID */
+    id: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const GetRegionRequest: S.Schema<GetRegionRequest>;
+/** The type of the region */
+export type RegionType = "shared" | "dedicated" | "custom";
+export declare const RegionType: any;
+export interface Region {
+    /** Region ID */
+    id: string;
+    /** Region name */
+    name: string;
+    /** Organization ID */
+    organizationId?: string | null;
+    /** The type of the region */
+    regionType: RegionType;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+    /** Proxy URL for the region */
+    proxyUrl?: string | null;
+    /** SSH Gateway URL for the region */
+    sshGatewayUrl?: string | null;
+    /** Snapshot Manager URL for the region */
+    snapshotManagerUrl?: string | null;
+    /** OTel collector endpoint for sandboxes created in this region. When set, sandbox OTel data is sent to this endpoint instead of the Daytona-hosted collector and will not be available in the Daytona analytics API or dashboard. */
+    otelEndpoint?: string | null;
+}
+export declare const Region: S.Schema<Region>;
+export interface GetSandboxIdentityBySandboxAuthTokenRequest {
+    /** Sandbox Auth Token */
+    authToken: string;
+}
+export declare const GetSandboxIdentityBySandboxAuthTokenRequest: S.Schema<GetSandboxIdentityBySandboxAuthTokenRequest>;
+export interface SandboxIdentity {
+    /** Sandbox ID */
+    sandboxId: string;
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const SandboxIdentity: S.Schema<SandboxIdentity>;
+export interface LeaveOrganizationRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const LeaveOrganizationRequest: S.Schema<LeaveOrganizationRequest>;
+export interface LeaveOrganizationResponse {
+}
+export declare const LeaveOrganizationResponse: S.Schema<LeaveOrganizationResponse>;
+export interface ListAvailableRegionsRequest {
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const ListAvailableRegionsRequest: S.Schema<ListAvailableRegionsRequest>;
+export type ListAvailableRegionsResponseBodyList = Array<Region>;
+export declare const ListAvailableRegionsResponseBodyList: S.Schema<ListAvailableRegionsResponseBodyList>;
+export type ListAvailableRegionsResponse = ListAvailableRegionsResponseBodyList;
+export declare const ListAvailableRegionsResponse: S.Schema<ListAvailableRegionsResponse>;
+export interface ListAvailableSandboxClassesRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const ListAvailableSandboxClassesRequest: S.Schema<ListAvailableSandboxClassesRequest>;
+export type AvailableSandboxClassAllowedGpuTypesList = Array<GpuType>;
+export declare const AvailableSandboxClassAllowedGpuTypesList: S.Schema<AvailableSandboxClassAllowedGpuTypesList>;
+export interface AvailableSandboxClass {
+    regionId: string;
+    sandboxClass: SandboxClass;
+    gpuAvailable: boolean;
+    allowedGpuTypes?: AvailableSandboxClassAllowedGpuTypesList;
+}
+export declare const AvailableSandboxClass: S.Schema<AvailableSandboxClass>;
+export type ListAvailableSandboxClassesResponseBodyList = Array<AvailableSandboxClass>;
+export declare const ListAvailableSandboxClassesResponseBodyList: S.Schema<ListAvailableSandboxClassesResponseBodyList>;
+export type ListAvailableSandboxClassesResponse = ListAvailableSandboxClassesResponseBodyList;
+export declare const ListAvailableSandboxClassesResponse: S.Schema<ListAvailableSandboxClassesResponse>;
+export interface ListOrganizationIdentityProvidersRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const ListOrganizationIdentityProvidersRequest: S.Schema<ListOrganizationIdentityProvidersRequest>;
+export type ListOrganizationIdentityProvidersResponseBodyList = Array<IdentityProvider>;
+export declare const ListOrganizationIdentityProvidersResponseBodyList: S.Schema<ListOrganizationIdentityProvidersResponseBodyList>;
+export type ListOrganizationIdentityProvidersResponse = ListOrganizationIdentityProvidersResponseBodyList;
+export declare const ListOrganizationIdentityProvidersResponse: S.Schema<ListOrganizationIdentityProvidersResponse>;
+export interface ListOrganizationInvitationsRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const ListOrganizationInvitationsRequest: S.Schema<ListOrganizationInvitationsRequest>;
+export type ListOrganizationInvitationsResponseBodyList = Array<OrganizationInvitation>;
+export declare const ListOrganizationInvitationsResponseBodyList: S.Schema<ListOrganizationInvitationsResponseBodyList>;
+export type ListOrganizationInvitationsResponse = ListOrganizationInvitationsResponseBodyList;
+export declare const ListOrganizationInvitationsResponse: S.Schema<ListOrganizationInvitationsResponse>;
+export interface ListOrganizationInvitationsForAuthenticatedUserRequest {
+}
+export declare const ListOrganizationInvitationsForAuthenticatedUserRequest: S.Schema<ListOrganizationInvitationsForAuthenticatedUserRequest>;
+export type ListOrganizationInvitationsForAuthenticatedUserResponseBodyList = Array<OrganizationInvitation>;
+export declare const ListOrganizationInvitationsForAuthenticatedUserResponseBodyList: S.Schema<ListOrganizationInvitationsForAuthenticatedUserResponseBodyList>;
+export type ListOrganizationInvitationsForAuthenticatedUserResponse = ListOrganizationInvitationsForAuthenticatedUserResponseBodyList;
+export declare const ListOrganizationInvitationsForAuthenticatedUserResponse: S.Schema<ListOrganizationInvitationsForAuthenticatedUserResponse>;
+export interface ListOrganizationMembersRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const ListOrganizationMembersRequest: S.Schema<ListOrganizationMembersRequest>;
+/** Member role */
+export type OrganizationUserRole = "owner" | "member";
+export declare const OrganizationUserRole: any;
+/** Roles assigned to the user */
+export type OrganizationUserAssignedRolesList = Array<OrganizationRole>;
+export declare const OrganizationUserAssignedRolesList: S.Schema<OrganizationUserAssignedRolesList>;
+export interface OrganizationUser {
+    /** User ID */
+    userId: string;
+    /** Organization ID */
+    organizationId: string;
+    /** User name */
+    name: string;
+    /** User email */
+    email: string;
+    /** Member role */
+    role: OrganizationUserRole;
+    /** Roles assigned to the user */
+    assignedRoles: OrganizationUserAssignedRolesList;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+export declare const OrganizationUser: S.Schema<OrganizationUser>;
+export type ListOrganizationMembersResponseBodyList = Array<OrganizationUser>;
+export declare const ListOrganizationMembersResponseBodyList: S.Schema<ListOrganizationMembersResponseBodyList>;
+export type ListOrganizationMembersResponse = ListOrganizationMembersResponseBodyList;
+export declare const ListOrganizationMembersResponse: S.Schema<ListOrganizationMembersResponse>;
+export interface ListOrganizationRolesRequest {
+    /** Organization ID */
+    organizationId: string;
+}
+export declare const ListOrganizationRolesRequest: S.Schema<ListOrganizationRolesRequest>;
+export type ListOrganizationRolesResponseBodyList = Array<OrganizationRole>;
+export declare const ListOrganizationRolesResponseBodyList: S.Schema<ListOrganizationRolesResponseBodyList>;
+export type ListOrganizationRolesResponse = ListOrganizationRolesResponseBodyList;
+export declare const ListOrganizationRolesResponse: S.Schema<ListOrganizationRolesResponse>;
+export interface ListOrganizationsRequest {
+}
+export declare const ListOrganizationsRequest: S.Schema<ListOrganizationsRequest>;
+export type ListOrganizationsResponseBodyList = Array<Organization>;
+export declare const ListOrganizationsResponseBodyList: S.Schema<ListOrganizationsResponseBodyList>;
+export type ListOrganizationsResponse = ListOrganizationsResponseBodyList;
+export declare const ListOrganizationsResponse: S.Schema<ListOrganizationsResponse>;
+export interface RegenerateProxyApiKeyRequest {
+    /** Region ID */
+    id: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const RegenerateProxyApiKeyRequest: S.Schema<RegenerateProxyApiKeyRequest>;
+export interface RegenerateApiKeyResponse {
+    /** The newly generated API key */
+    apiKey: string | Redacted.Redacted<string>;
+}
+export declare const RegenerateApiKeyResponse: S.Schema<RegenerateApiKeyResponse>;
+export interface RegenerateSnapshotManagerCredentialsRequest {
+    /** Region ID */
+    id: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const RegenerateSnapshotManagerCredentialsRequest: S.Schema<RegenerateSnapshotManagerCredentialsRequest>;
+export interface SnapshotManagerCredentials {
+    /** Snapshot Manager username for the region */
+    username: string;
+    /** Snapshot Manager password for the region */
+    password: string | Redacted.Redacted<string>;
+}
+export declare const SnapshotManagerCredentials: S.Schema<SnapshotManagerCredentials>;
+export interface RegenerateSshGatewayApiKeyRequest {
+    /** Region ID */
+    id: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+}
+export declare const RegenerateSshGatewayApiKeyRequest: S.Schema<RegenerateSshGatewayApiKeyRequest>;
+export interface SetOrganizationDefaultRegionRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** The ID of the default region for the organization */
+    defaultRegionId: string;
+}
+export declare const SetOrganizationDefaultRegionRequest: S.Schema<SetOrganizationDefaultRegionRequest>;
+export interface SetOrganizationDefaultRegionResponse {
+}
+export declare const SetOrganizationDefaultRegionResponse: S.Schema<SetOrganizationDefaultRegionResponse>;
+export interface TestOrganizationIdentityProviderConnectionRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** OIDC Issuer URL to test */
+    issuerUrl: string;
+}
+export declare const TestOrganizationIdentityProviderConnectionRequest: S.Schema<TestOrganizationIdentityProviderConnectionRequest>;
+export interface TestIdentityProviderConnectionResponse {
+    /** Whether the connection test was successful */
+    success: boolean;
+    /** The discovered issuer from the OIDC configuration */
+    issuer?: string;
+    /** Error message if the connection test failed */
+    error?: string;
+}
+export declare const TestIdentityProviderConnectionResponse: S.Schema<TestIdentityProviderConnectionResponse>;
+/** Organization member role */
+export type UpdateAccessForOrganizationMemberRequestRole = "owner" | "member";
+export declare const UpdateAccessForOrganizationMemberRequestRole: any;
+/** Array of assigned role IDs */
+export type UpdateAccessForOrganizationMemberRequestAssignedRoleIdsList = Array<string>;
+export declare const UpdateAccessForOrganizationMemberRequestAssignedRoleIdsList: S.Schema<UpdateAccessForOrganizationMemberRequestAssignedRoleIdsList>;
+export interface UpdateAccessForOrganizationMemberRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** User ID */
+    userId: string;
+    /** Organization member role */
+    role: UpdateAccessForOrganizationMemberRequestRole | (string & {});
+    /** Array of assigned role IDs */
+    assignedRoleIds: UpdateAccessForOrganizationMemberRequestAssignedRoleIdsList;
+}
+export declare const UpdateAccessForOrganizationMemberRequest: S.Schema<UpdateAccessForOrganizationMemberRequest>;
+export type UpdateExperimentalConfigRequestBodyMap = {
+    [key: string]: unknown | undefined;
+};
+export declare const UpdateExperimentalConfigRequestBodyMap: S.Schema<UpdateExperimentalConfigRequestBodyMap>;
+export interface UpdateExperimentalConfigRequest {
+    /** Organization ID */
+    organizationId: string;
+    body?: UpdateExperimentalConfigRequestBodyMap;
+}
+export declare const UpdateExperimentalConfigRequest: S.Schema<UpdateExperimentalConfigRequest>;
+export interface UpdateExperimentalConfigResponse {
+}
+export declare const UpdateExperimentalConfigResponse: S.Schema<UpdateExperimentalConfigResponse>;
+export interface UpdateOidcIdPConfig {
+    /** OIDC Issuer URL */
+    issuerUrl?: string;
+    /** OAuth Client ID */
+    clientId?: string;
+    /** OAuth Client Secret */
+    clientSecret?: string | Redacted.Redacted<string>;
+    /** OAuth scopes */
+    scope?: string;
+}
+export declare const UpdateOidcIdPConfig: S.Schema<UpdateOidcIdPConfig>;
+/** Email domains used for IdP discovery on the login form and to validate the user identity returned by the IdP. If provided and `allowAnyDomain` is not being set to true, must contain at least one domain. To clear domains in the same request, set `allowAnyDomain: true` and `emailDomains: []`. */
+export type UpdateOrganizationIdentityProviderRequestEmailDomainsList = Array<string>;
+export declare const UpdateOrganizationIdentityProviderRequestEmailDomainsList: S.Schema<UpdateOrganizationIdentityProviderRequestEmailDomainsList>;
+/** Organization role IDs assigned to users who join the organization via SSO through this identity provider. Roles must be global or belong to this organization. Empty grants the lowest access: membership with no resource permissions. */
+export type UpdateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList = Array<string>;
+export declare const UpdateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList: S.Schema<UpdateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList>;
+export interface UpdateOrganizationIdentityProviderRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Identity provider ID */
+    id: string;
+    /** Display name for the identity provider */
+    name?: string;
+    /** OIDC configuration */
+    oidcConfig?: UpdateOidcIdPConfig;
+    /** Email domains used for IdP discovery on the login form and to validate the user identity returned by the IdP. If provided and `allowAnyDomain` is not being set to true, must contain at least one domain. To clear domains in the same request, set `allowAnyDomain: true` and `emailDomains: []`. */
+    emailDomains?: UpdateOrganizationIdentityProviderRequestEmailDomainsList;
+    /** When true, the IdP accepts any email domain returned by the external provider. Disables the post-callback domain check and allows `emailDomains` to be empty. Only enable for trusted IdPs that strictly control which users can authenticate. */
+    allowAnyDomain?: boolean;
+    /** When true, skip the `email_verified` claim check on SSO logins through this identity provider. Only intended for providers that never emit the claim (e.g. Microsoft Entra ID). Risky: only enable if the IdP strictly controls its users' email addresses. */
+    trustEmailVerified?: boolean;
+    /** Organization role IDs assigned to users who join the organization via SSO through this identity provider. Roles must be global or belong to this organization. Empty grants the lowest access: membership with no resource permissions. */
+    defaultAssignedRoleIds?: UpdateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList;
+    /** Whether the identity provider is enabled */
+    enabled?: boolean;
+}
+export declare const UpdateOrganizationIdentityProviderRequest: S.Schema<UpdateOrganizationIdentityProviderRequest>;
+/** Organization member role */
+export type UpdateOrganizationInvitationRequestRole = "owner" | "member";
+export declare const UpdateOrganizationInvitationRequestRole: any;
+/** Array of role IDs */
+export type UpdateOrganizationInvitationRequestAssignedRoleIdsList = Array<string>;
+export declare const UpdateOrganizationInvitationRequestAssignedRoleIdsList: S.Schema<UpdateOrganizationInvitationRequestAssignedRoleIdsList>;
+export interface UpdateOrganizationInvitationRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Invitation ID */
+    invitationId: string;
+    /** Organization member role */
+    role: UpdateOrganizationInvitationRequestRole | (string & {});
+    /** Array of role IDs */
+    assignedRoleIds: UpdateOrganizationInvitationRequestAssignedRoleIdsList;
+    /** Expiration date of the invitation */
+    expiresAt?: string;
+}
+export declare const UpdateOrganizationInvitationRequest: S.Schema<UpdateOrganizationInvitationRequest>;
+/** Headers */
+export type UpdateOrganizationOtelConfigRequestHeadersMap = {
+    [key: string]: string | undefined;
+};
+export declare const UpdateOrganizationOtelConfigRequestHeadersMap: S.Schema<UpdateOrganizationOtelConfigRequestHeadersMap>;
+export interface UpdateOrganizationOtelConfigRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Endpoint */
+    endpoint: string;
+    /** Headers */
+    headers?: UpdateOrganizationOtelConfigRequestHeadersMap | null;
+}
+export declare const UpdateOrganizationOtelConfigRequest: S.Schema<UpdateOrganizationOtelConfigRequest>;
+export interface UpdateOrganizationOtelConfigResponse {
+}
+export declare const UpdateOrganizationOtelConfigResponse: S.Schema<UpdateOrganizationOtelConfigResponse>;
+export type UpdateOrganizationRoleRequestPermissionsItem = "write:registries" | "delete:registries" | "write:snapshots" | "delete:snapshots" | "write:sandboxes" | "delete:sandboxes" | "read:volumes" | "write:volumes" | "delete:volumes" | "write:regions" | "delete:regions" | "read:runners" | "write:runners" | "delete:runners" | "read:audit_logs" | "manage:api_keys" | "manage:secrets" | "read:limits" | "manage:sso" | "read:billing" | "manage:billing";
+export declare const UpdateOrganizationRoleRequestPermissionsItem: any;
+/** The list of permissions assigned to the role */
+export type UpdateOrganizationRoleRequestPermissionsList = Array<UpdateOrganizationRoleRequestPermissionsItem | (string & {})>;
+export declare const UpdateOrganizationRoleRequestPermissionsList: S.Schema<UpdateOrganizationRoleRequestPermissionsList>;
+export interface UpdateOrganizationRoleRequest {
+    /** Organization ID */
+    organizationId: string;
+    /** Role ID */
+    roleId: string;
+    /** The name of the role */
+    name: string;
+    /** The description of the role */
+    description: string;
+    /** The list of permissions assigned to the role */
+    permissions: UpdateOrganizationRoleRequestPermissionsList;
+}
+export declare const UpdateOrganizationRoleRequest: S.Schema<UpdateOrganizationRoleRequest>;
+export interface UpdateRegionRequest {
+    /** Region ID */
+    id: string;
+    /** Use with JWT to specify the organization ID */
+    xDaytonaOrganizationID?: string;
+    /** Proxy URL for the region */
+    proxyUrl?: string | null;
+    /** SSH Gateway URL for the region */
+    sshGatewayUrl?: string | null;
+    /** Snapshot Manager URL for the region */
+    snapshotManagerUrl?: string | null;
+    /** OTel collector endpoint for sandboxes created in this region. When set, sandbox OTel data is sent to this endpoint instead of the Daytona-hosted collector and will not be available in the Daytona analytics API or dashboard. */
+    otelEndpoint?: string | null;
+}
+export declare const UpdateRegionRequest: S.Schema<UpdateRegionRequest>;
+export interface UpdateRegionResponse {
+}
+export declare const UpdateRegionResponse: S.Schema<UpdateRegionResponse>;
+export type AcceptOrganizationInvitationError = DaytonaOpError;
+/** Accept organization invitation */
+export declare const acceptOrganizationInvitation: API.OperationMethod<AcceptOrganizationInvitationRequest, OrganizationInvitation, AcceptOrganizationInvitationError, DaytonaOpContext>;
+export type CancelOrganizationInvitationError = DaytonaOpError;
+/** Cancel organization invitation */
+export declare const cancelOrganizationInvitation: API.OperationMethod<CancelOrganizationInvitationRequest, CancelOrganizationInvitationResponse, CancelOrganizationInvitationError, DaytonaOpContext>;
+export type CreateOrganizationError = DaytonaOpError;
+/** Create organization */
+export declare const createOrganization: API.OperationMethod<CreateOrganizationRequest, Organization, CreateOrganizationError, DaytonaOpContext>;
+export type CreateOrganizationIdentityProviderError = DaytonaOpError;
+/** Create organization identity provider */
+export declare const createOrganizationIdentityProvider: API.OperationMethod<CreateOrganizationIdentityProviderRequest, IdentityProvider, CreateOrganizationIdentityProviderError, DaytonaOpContext>;
+export type CreateOrganizationInvitationError = DaytonaOpError;
+/** Create organization invitation */
+export declare const createOrganizationInvitation: API.OperationMethod<CreateOrganizationInvitationRequest, OrganizationInvitation, CreateOrganizationInvitationError, DaytonaOpContext>;
+export type CreateOrganizationRoleError = DaytonaOpError;
+/** Create organization role */
+export declare const createOrganizationRole: API.OperationMethod<CreateOrganizationRoleRequest, OrganizationRole, CreateOrganizationRoleError, DaytonaOpContext>;
+export type CreateRegionError = DaytonaOpError;
+/** Create a new region */
+export declare const createRegion: API.OperationMethod<CreateRegionRequest, CreateRegionResponse, CreateRegionError, DaytonaOpContext>;
+export type DeclineOrganizationInvitationError = DaytonaOpError;
+/** Decline organization invitation */
+export declare const declineOrganizationInvitation: API.OperationMethod<DeclineOrganizationInvitationRequest, DeclineOrganizationInvitationResponse, DeclineOrganizationInvitationError, DaytonaOpContext>;
+export type DeleteOrganizationError = DaytonaOpError;
+/** Delete organization */
+export declare const deleteOrganization: API.OperationMethod<DeleteOrganizationRequest, DeleteOrganizationResponse, DeleteOrganizationError, DaytonaOpContext>;
+export type DeleteOrganizationIdentityProviderError = DaytonaOpError;
+/** Delete organization identity provider */
+export declare const deleteOrganizationIdentityProvider: API.OperationMethod<DeleteOrganizationIdentityProviderRequest, DeleteOrganizationIdentityProviderResponse, DeleteOrganizationIdentityProviderError, DaytonaOpContext>;
+export type DeleteOrganizationMemberError = DaytonaOpError;
+/** Delete organization member */
+export declare const deleteOrganizationMember: API.OperationMethod<DeleteOrganizationMemberRequest, DeleteOrganizationMemberResponse, DeleteOrganizationMemberError, DaytonaOpContext>;
+export type DeleteOrganizationOtelConfigError = DaytonaOpError;
+/** Delete organization OpenTelemetry configuration */
+export declare const deleteOrganizationOtelConfig: API.OperationMethod<DeleteOrganizationOtelConfigRequest, DeleteOrganizationOtelConfigResponse, DeleteOrganizationOtelConfigError, DaytonaOpContext>;
+export type DeleteOrganizationRoleError = DaytonaOpError;
+/** Delete organization role */
+export declare const deleteOrganizationRole: API.OperationMethod<DeleteOrganizationRoleRequest, DeleteOrganizationRoleResponse, DeleteOrganizationRoleError, DaytonaOpContext>;
+export type DeleteRegionError = DaytonaOpError;
+/** Delete a region */
+export declare const deleteRegion: API.OperationMethod<DeleteRegionRequest, DeleteRegionResponse, DeleteRegionError, DaytonaOpContext>;
+export type GenerateWorkosAdminPortalLinkError = DaytonaOpError;
+/** Generate a WorkOS Admin Portal link for configuring SSO or SCIM directory sync */
+export declare const generateWorkosAdminPortalLink: API.OperationMethod<GenerateWorkosAdminPortalLinkRequest, WorkosAdminPortalLink, GenerateWorkosAdminPortalLinkError, DaytonaOpContext>;
+export type GetGpuCapacityError = DaytonaOpError;
+/** Get shared US GPU capacity Returns a short-lived observation of the shared US GPU fleet. Organization quotas and entitlements are not applied. Capacity can change immediately and sandbox creation remains authoritative. */
+export declare const getGpuCapacity: API.OperationMethod<GetGpuCapacityRequest, GpuCapacityResponse, GetGpuCapacityError, DaytonaOpContext>;
+export type GetOrganizationError = DaytonaOpError;
+/** Get organization by ID */
+export declare const getOrganization: API.OperationMethod<GetOrganizationRequest, Organization, GetOrganizationError, DaytonaOpContext>;
+export type GetOrganizationIdentityProviderError = DaytonaOpError;
+/** Get organization identity provider */
+export declare const getOrganizationIdentityProvider: API.OperationMethod<GetOrganizationIdentityProviderRequest, IdentityProvider, GetOrganizationIdentityProviderError, DaytonaOpContext>;
+export type GetOrganizationInvitationsCountForAuthenticatedUserError = DaytonaOpError;
+/** Get count of organization invitations for authenticated user */
+export declare const getOrganizationInvitationsCountForAuthenticatedUser: API.OperationMethod<GetOrganizationInvitationsCountForAuthenticatedUserRequest, GetOrganizationInvitationsCountForAuthenticatedUserResponse, GetOrganizationInvitationsCountForAuthenticatedUserError, DaytonaOpContext>;
+export type GetOrganizationOtelConfigError = DaytonaOpError;
+/** Get organization OTEL config by organization ID */
+export declare const getOrganizationOtelConfig: API.OperationMethod<GetOrganizationOtelConfigRequest, OtelConfig, GetOrganizationOtelConfigError, DaytonaOpContext>;
+export type GetOrganizationOtelConfigBySandboxAuthTokenError = DaytonaOpError;
+/** Get organization OTEL config by sandbox auth token */
+export declare const getOrganizationOtelConfigBySandboxAuthToken: API.OperationMethod<GetOrganizationOtelConfigBySandboxAuthTokenRequest, OtelConfig, GetOrganizationOtelConfigBySandboxAuthTokenError, DaytonaOpContext>;
+export type GetOrganizationUsageOverviewError = DaytonaOpError;
+/** Get organization current usage overview */
+export declare const getOrganizationUsageOverview: API.OperationMethod<GetOrganizationUsageOverviewRequest, OrganizationUsageOverview, GetOrganizationUsageOverviewError, DaytonaOpContext>;
+export type GetRegionError = DaytonaOpError;
+/** Get region by ID */
+export declare const getRegion: API.OperationMethod<GetRegionRequest, Region, GetRegionError, DaytonaOpContext>;
+export type GetSandboxIdentityBySandboxAuthTokenError = DaytonaOpError;
+/** Get sandbox identity by sandbox auth token */
+export declare const getSandboxIdentityBySandboxAuthToken: API.OperationMethod<GetSandboxIdentityBySandboxAuthTokenRequest, SandboxIdentity, GetSandboxIdentityBySandboxAuthTokenError, DaytonaOpContext>;
+export type LeaveOrganizationError = DaytonaOpError;
+/** Leave organization */
+export declare const leaveOrganization: API.OperationMethod<LeaveOrganizationRequest, LeaveOrganizationResponse, LeaveOrganizationError, DaytonaOpContext>;
+export type ListAvailableRegionsError = DaytonaOpError;
+/** List all available regions for the organization */
+export declare const listAvailableRegions: API.OperationMethod<ListAvailableRegionsRequest, ListAvailableRegionsResponse, ListAvailableRegionsError, DaytonaOpContext>;
+export type ListAvailableSandboxClassesError = DaytonaOpError;
+/** List available sandbox classes for organization */
+export declare const listAvailableSandboxClasses: API.OperationMethod<ListAvailableSandboxClassesRequest, ListAvailableSandboxClassesResponse, ListAvailableSandboxClassesError, DaytonaOpContext>;
+export type ListOrganizationIdentityProvidersError = DaytonaOpError;
+/** List organization identity providers */
+export declare const listOrganizationIdentityProviders: API.OperationMethod<ListOrganizationIdentityProvidersRequest, ListOrganizationIdentityProvidersResponse, ListOrganizationIdentityProvidersError, DaytonaOpContext>;
+export type ListOrganizationInvitationsError = DaytonaOpError;
+/** List pending organization invitations */
+export declare const listOrganizationInvitations: API.OperationMethod<ListOrganizationInvitationsRequest, ListOrganizationInvitationsResponse, ListOrganizationInvitationsError, DaytonaOpContext>;
+export type ListOrganizationInvitationsForAuthenticatedUserError = DaytonaOpError;
+/** List organization invitations for authenticated user */
+export declare const listOrganizationInvitationsForAuthenticatedUser: API.OperationMethod<ListOrganizationInvitationsForAuthenticatedUserRequest, ListOrganizationInvitationsForAuthenticatedUserResponse, ListOrganizationInvitationsForAuthenticatedUserError, DaytonaOpContext>;
+export type ListOrganizationMembersError = DaytonaOpError;
+/** List organization members */
+export declare const listOrganizationMembers: API.OperationMethod<ListOrganizationMembersRequest, ListOrganizationMembersResponse, ListOrganizationMembersError, DaytonaOpContext>;
+export type ListOrganizationRolesError = DaytonaOpError;
+/** List organization roles */
+export declare const listOrganizationRoles: API.OperationMethod<ListOrganizationRolesRequest, ListOrganizationRolesResponse, ListOrganizationRolesError, DaytonaOpContext>;
+export type ListOrganizationsError = DaytonaOpError;
+/** List organizations */
+export declare const listOrganizations: API.OperationMethod<ListOrganizationsRequest, ListOrganizationsResponse, ListOrganizationsError, DaytonaOpContext>;
+export type RegenerateProxyApiKeyError = DaytonaOpError;
+/** Regenerate proxy API key for a region */
+export declare const regenerateProxyApiKey: API.OperationMethod<RegenerateProxyApiKeyRequest, RegenerateApiKeyResponse, RegenerateProxyApiKeyError, DaytonaOpContext>;
+export type RegenerateSnapshotManagerCredentialsError = DaytonaOpError;
+/** Regenerate snapshot manager credentials for a region */
+export declare const regenerateSnapshotManagerCredentials: API.OperationMethod<RegenerateSnapshotManagerCredentialsRequest, SnapshotManagerCredentials, RegenerateSnapshotManagerCredentialsError, DaytonaOpContext>;
+export type RegenerateSshGatewayApiKeyError = DaytonaOpError;
+/** Regenerate SSH gateway API key for a region */
+export declare const regenerateSshGatewayApiKey: API.OperationMethod<RegenerateSshGatewayApiKeyRequest, RegenerateApiKeyResponse, RegenerateSshGatewayApiKeyError, DaytonaOpContext>;
+export type SetOrganizationDefaultRegionError = DaytonaOpError;
+/** Set default region for organization */
+export declare const setOrganizationDefaultRegion: API.OperationMethod<SetOrganizationDefaultRegionRequest, SetOrganizationDefaultRegionResponse, SetOrganizationDefaultRegionError, DaytonaOpContext>;
+export type TestOrganizationIdentityProviderConnectionError = DaytonaOpError;
+/** Test OIDC identity provider connection */
+export declare const testOrganizationIdentityProviderConnection: API.OperationMethod<TestOrganizationIdentityProviderConnectionRequest, TestIdentityProviderConnectionResponse, TestOrganizationIdentityProviderConnectionError, DaytonaOpContext>;
+export type UpdateAccessForOrganizationMemberError = DaytonaOpError;
+/** Update access for organization member */
+export declare const updateAccessForOrganizationMember: API.OperationMethod<UpdateAccessForOrganizationMemberRequest, OrganizationUser, UpdateAccessForOrganizationMemberError, DaytonaOpContext>;
+export type UpdateExperimentalConfigError = DaytonaOpError;
+/** Update experimental configuration */
+export declare const updateExperimentalConfig: API.OperationMethod<UpdateExperimentalConfigRequest, UpdateExperimentalConfigResponse, UpdateExperimentalConfigError, DaytonaOpContext>;
+export type UpdateOrganizationIdentityProviderError = DaytonaOpError;
+/** Update organization identity provider */
+export declare const updateOrganizationIdentityProvider: API.OperationMethod<UpdateOrganizationIdentityProviderRequest, IdentityProvider, UpdateOrganizationIdentityProviderError, DaytonaOpContext>;
+export type UpdateOrganizationInvitationError = DaytonaOpError;
+/** Update organization invitation */
+export declare const updateOrganizationInvitation: API.OperationMethod<UpdateOrganizationInvitationRequest, OrganizationInvitation, UpdateOrganizationInvitationError, DaytonaOpContext>;
+export type UpdateOrganizationOtelConfigError = DaytonaOpError;
+/** Update organization OpenTelemetry configuration */
+export declare const updateOrganizationOtelConfig: API.OperationMethod<UpdateOrganizationOtelConfigRequest, UpdateOrganizationOtelConfigResponse, UpdateOrganizationOtelConfigError, DaytonaOpContext>;
+export type UpdateOrganizationRoleError = DaytonaOpError;
+/** Update organization role */
+export declare const updateOrganizationRole: API.OperationMethod<UpdateOrganizationRoleRequest, OrganizationRole, UpdateOrganizationRoleError, DaytonaOpContext>;
+export type UpdateRegionError = DaytonaOpError;
+/** Update region configuration */
+export declare const updateRegion: API.OperationMethod<UpdateRegionRequest, UpdateRegionResponse, UpdateRegionError, DaytonaOpContext>;
+//# sourceMappingURL=organizations.d.ts.map