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

package/src/services/organizations.ts

@@ -0,0 +1,2712 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface AcceptOrganizationInvitationRequest {
+  /** Invitation ID */
+  invitationId: string;
+}
+export const AcceptOrganizationInvitationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    invitationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/organizations/invitations/{invitationId}/accept",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "AcceptOrganizationInvitationRequest",
+}) as any as S.Schema<AcceptOrganizationInvitationRequest>;
+
+/** Invitation status */
+export type OrganizationInvitationStatus =
+  | "pending"
+  | "accepted"
+  | "declined"
+  | "cancelled";
+export const OrganizationInvitationStatus = S.String;
+
+/** Member role */
+export type OrganizationInvitationRole = "owner" | "member";
+export const OrganizationInvitationRole = S.String;
+
+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 const OrganizationRolePermissionsItem = S.String;
+
+/** Roles assigned to the user */
+export type OrganizationRolePermissionsList =
+  Array<OrganizationRolePermissionsItem>;
+export const OrganizationRolePermissionsList = /*@__PURE__*/ S.Array(
+  OrganizationRolePermissionsItem,
+) as any as 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 const OrganizationRole = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    name: S.String,
+    description: S.String,
+    permissions: OrganizationRolePermissionsList,
+    isGlobal: S.Boolean,
+    createdAt: S.String,
+    updatedAt: S.String,
+  }),
+).annotate({
+  identifier: "OrganizationRole",
+}) as any as S.Schema<OrganizationRole>;
+
+/** Assigned roles */
+export type OrganizationInvitationAssignedRolesList = Array<OrganizationRole>;
+export const OrganizationInvitationAssignedRolesList = /*@__PURE__*/ S.Array(
+  OrganizationRole,
+) as any as 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 const OrganizationInvitation = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    email: S.String,
+    invitedBy: S.String,
+    organizationId: S.String,
+    organizationName: S.String,
+    expiresAt: S.String,
+    status: OrganizationInvitationStatus,
+    role: OrganizationInvitationRole,
+    assignedRoles: OrganizationInvitationAssignedRolesList,
+    createdAt: S.String,
+    updatedAt: S.String,
+  }),
+).annotate({
+  identifier: "OrganizationInvitation",
+}) as any as S.Schema<OrganizationInvitation>;
+
+export interface CancelOrganizationInvitationRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Invitation ID */
+  invitationId: string;
+}
+export const CancelOrganizationInvitationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    invitationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/organizations/{organizationId}/invitations/{invitationId}/cancel",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CancelOrganizationInvitationRequest",
+}) as any as S.Schema<CancelOrganizationInvitationRequest>;
+
+export interface CancelOrganizationInvitationResponse {}
+export const CancelOrganizationInvitationResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "CancelOrganizationInvitationResponse",
+}) as any as S.Schema<CancelOrganizationInvitationResponse>;
+
+export interface CreateOrganizationRequest {
+  /** The name of organization */
+  name: string;
+  /** The ID of the default region for the organization */
+  defaultRegionId: string;
+}
+export const CreateOrganizationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String,
+    defaultRegionId: S.String,
+  }).pipe(T.Http({ method: "POST", uri: "/organizations", code: 200 })),
+).annotate({
+  identifier: "CreateOrganizationRequest",
+}) as any as S.Schema<CreateOrganizationRequest>;
+
+/** Headers */
+export type OtelConfigHeadersMap = { [key: string]: string | undefined };
+export const OtelConfigHeadersMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<OtelConfigHeadersMap>;
+
+export interface OtelConfig {
+  /** Endpoint */
+  endpoint: string;
+  /** Headers */
+  headers?: OtelConfigHeadersMap | null;
+  /** Organization ID the config belongs to */
+  organizationId?: string;
+}
+export const OtelConfig = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    endpoint: S.String,
+    headers: S.optional(S.NullOr(OtelConfigHeadersMap)),
+    organizationId: S.optional(S.String),
+  }),
+).annotate({ identifier: "OtelConfig" }) as any as 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 const Organization = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    name: S.String,
+    createdBy: S.String,
+    personal: S.Boolean,
+    createdAt: S.String,
+    updatedAt: S.String,
+    suspended: S.Boolean,
+    suspendedAt: S.String,
+    suspensionReason: S.String,
+    suspendedUntil: S.String,
+    suspensionCleanupGracePeriodHours: S.Number,
+    maxCpuPerSandbox: S.Number,
+    maxMemoryPerSandbox: S.Number,
+    maxDiskPerSandbox: S.Number,
+    secretQuota: S.Number,
+    maxSecretsPerSandbox: S.Number,
+    snapshotDeactivationTimeoutMinutes: S.Number,
+    sandboxLimitedNetworkEgress: S.Boolean,
+    previewWarningEnabled: S.Boolean,
+    ssoEnabled: S.Boolean,
+    scimEnabled: S.Boolean,
+    defaultRegionId: S.optional(S.String),
+    workosOrgId: S.optional(S.String),
+    authenticatedRateLimit: S.NullOr(S.Number),
+    sandboxCreateRateLimit: S.NullOr(S.Number),
+    sandboxLifecycleRateLimit: S.NullOr(S.Number),
+    experimentalConfig: S.Unknown,
+    otelConfig: S.NullOr(OtelConfig),
+    authenticatedRateLimitTtlSeconds: S.NullOr(S.Number),
+    sandboxCreateRateLimitTtlSeconds: S.NullOr(S.Number),
+    sandboxLifecycleRateLimitTtlSeconds: S.NullOr(S.Number),
+  }),
+).annotate({ identifier: "Organization" }) as any as 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 const OidcIdPConfig = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    issuerUrl: S.String,
+    clientId: S.String,
+    clientSecret: S.String.pipe(T.SensitiveValue({})),
+    scope: S.optional(S.String),
+  }),
+).annotate({ identifier: "OidcIdPConfig" }) as any as 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 const CreateOrganizationIdentityProviderRequestEmailDomainsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as 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 const CreateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as 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 const CreateOrganizationIdentityProviderRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      name: S.String,
+      oidcConfig: OidcIdPConfig,
+      emailDomains: CreateOrganizationIdentityProviderRequestEmailDomainsList,
+      allowAnyDomain: S.optional(S.Boolean),
+      trustEmailVerified: S.optional(S.Boolean),
+      defaultAssignedRoleIds: S.optional(
+        CreateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList,
+      ),
+      enabled: S.optional(S.Boolean),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/organizations/{organizationId}/identity-providers",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "CreateOrganizationIdentityProviderRequest",
+  }) as any as S.Schema<CreateOrganizationIdentityProviderRequest>;
+
+export interface OidcIdPConfigResponse {
+  /** OIDC Issuer URL */
+  issuerUrl: string;
+  /** OAuth Client ID */
+  clientId: string;
+  /** OAuth scopes */
+  scope?: string;
+}
+export const OidcIdPConfigResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    issuerUrl: S.String,
+    clientId: S.String,
+    scope: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "OidcIdPConfigResponse",
+}) as any as 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 const IdentityProviderEmailDomainsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<IdentityProviderEmailDomainsList>;
+
+/** Organization role IDs assigned to users who join via SSO through this identity provider */
+export type IdentityProviderDefaultAssignedRoleIdsList = Array<string>;
+export const IdentityProviderDefaultAssignedRoleIdsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as 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 const IdentityProvider = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    organizationId: S.String,
+    name: S.String,
+    oidcConfig: OidcIdPConfigResponse,
+    emailDomains: IdentityProviderEmailDomainsList,
+    allowAnyDomain: S.Boolean,
+    trustEmailVerified: S.Boolean,
+    defaultAssignedRoleIds: IdentityProviderDefaultAssignedRoleIdsList,
+    enabled: S.Boolean,
+    createdAt: S.String,
+    updatedAt: S.String,
+  }),
+).annotate({
+  identifier: "IdentityProvider",
+}) as any as S.Schema<IdentityProvider>;
+
+/** Organization member role for the invitee */
+export type CreateOrganizationInvitationRequestRole = "owner" | "member";
+export const CreateOrganizationInvitationRequestRole = S.String;
+
+/** Array of assigned role IDs for the invitee */
+export type CreateOrganizationInvitationRequestAssignedRoleIdsList =
+  Array<string>;
+export const CreateOrganizationInvitationRequestAssignedRoleIdsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as 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 const CreateOrganizationInvitationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    email: S.String,
+    role: CreateOrganizationInvitationRequestRole,
+    assignedRoleIds: CreateOrganizationInvitationRequestAssignedRoleIdsList,
+    expiresAt: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/organizations/{organizationId}/invitations",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateOrganizationInvitationRequest",
+}) as any as 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 const CreateOrganizationRoleRequestPermissionsItem = S.String;
+
+/** The list of permissions assigned to the role */
+export type CreateOrganizationRoleRequestPermissionsList = Array<
+  CreateOrganizationRoleRequestPermissionsItem | (string & {})
+>;
+export const CreateOrganizationRoleRequestPermissionsList =
+  /*@__PURE__*/ S.Array(
+    CreateOrganizationRoleRequestPermissionsItem,
+  ) as any as 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 const CreateOrganizationRoleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    name: S.String,
+    description: S.String,
+    permissions: CreateOrganizationRoleRequestPermissionsList,
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/organizations/{organizationId}/roles",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "CreateOrganizationRoleRequest",
+}) as any as 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 const CreateRegionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    name: S.String,
+    proxyUrl: S.optional(S.NullOr(S.String)),
+    sshGatewayUrl: S.optional(S.NullOr(S.String)),
+    snapshotManagerUrl: S.optional(S.NullOr(S.String)),
+    otelEndpoint: S.optional(S.NullOr(S.String)),
+  }).pipe(T.Http({ method: "POST", uri: "/regions", code: 200 })),
+).annotate({
+  identifier: "CreateRegionRequest",
+}) as any as 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 const CreateRegionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    proxyApiKey: S.optional(S.NullOr(S.String)),
+    sshGatewayApiKey: S.optional(S.NullOr(S.String)),
+    snapshotManagerUsername: S.optional(S.NullOr(S.String)),
+    snapshotManagerPassword: S.optional(
+      S.NullOr(S.String).pipe(T.SensitiveValue({})),
+    ),
+  }),
+).annotate({
+  identifier: "CreateRegionResponse",
+}) as any as S.Schema<CreateRegionResponse>;
+
+export interface DeclineOrganizationInvitationRequest {
+  /** Invitation ID */
+  invitationId: string;
+}
+export const DeclineOrganizationInvitationRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      invitationId: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/organizations/invitations/{invitationId}/decline",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "DeclineOrganizationInvitationRequest",
+}) as any as S.Schema<DeclineOrganizationInvitationRequest>;
+
+export interface DeclineOrganizationInvitationResponse {}
+export const DeclineOrganizationInvitationResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "DeclineOrganizationInvitationResponse",
+}) as any as S.Schema<DeclineOrganizationInvitationResponse>;
+
+export interface DeleteOrganizationRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const DeleteOrganizationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/organizations/{organizationId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOrganizationRequest",
+}) as any as S.Schema<DeleteOrganizationRequest>;
+
+export interface DeleteOrganizationResponse {}
+export const DeleteOrganizationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOrganizationResponse",
+}) as any as S.Schema<DeleteOrganizationResponse>;
+
+export interface DeleteOrganizationIdentityProviderRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Identity provider ID */
+  id: string;
+}
+export const DeleteOrganizationIdentityProviderRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      id: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "DELETE",
+        uri: "/organizations/{organizationId}/identity-providers/{id}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "DeleteOrganizationIdentityProviderRequest",
+  }) as any as S.Schema<DeleteOrganizationIdentityProviderRequest>;
+
+export interface DeleteOrganizationIdentityProviderResponse {}
+export const DeleteOrganizationIdentityProviderResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "DeleteOrganizationIdentityProviderResponse",
+  }) as any as S.Schema<DeleteOrganizationIdentityProviderResponse>;
+
+export interface DeleteOrganizationMemberRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** User ID */
+  userId: string;
+}
+export const DeleteOrganizationMemberRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    userId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/organizations/{organizationId}/users/{userId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOrganizationMemberRequest",
+}) as any as S.Schema<DeleteOrganizationMemberRequest>;
+
+export interface DeleteOrganizationMemberResponse {}
+export const DeleteOrganizationMemberResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOrganizationMemberResponse",
+}) as any as S.Schema<DeleteOrganizationMemberResponse>;
+
+export interface DeleteOrganizationOtelConfigRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const DeleteOrganizationOtelConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/organizations/{organizationId}/otel-config",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOrganizationOtelConfigRequest",
+}) as any as S.Schema<DeleteOrganizationOtelConfigRequest>;
+
+export interface DeleteOrganizationOtelConfigResponse {}
+export const DeleteOrganizationOtelConfigResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "DeleteOrganizationOtelConfigResponse",
+}) as any as S.Schema<DeleteOrganizationOtelConfigResponse>;
+
+export interface DeleteOrganizationRoleRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Role ID */
+  roleId: string;
+}
+export const DeleteOrganizationRoleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    roleId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/organizations/{organizationId}/roles/{roleId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteOrganizationRoleRequest",
+}) as any as S.Schema<DeleteOrganizationRoleRequest>;
+
+export interface DeleteOrganizationRoleResponse {}
+export const DeleteOrganizationRoleResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteOrganizationRoleResponse",
+}) as any as S.Schema<DeleteOrganizationRoleResponse>;
+
+export interface DeleteRegionRequest {
+  /** Region ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const DeleteRegionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "DELETE", uri: "/regions/{id}", code: 200 })),
+).annotate({
+  identifier: "DeleteRegionRequest",
+}) as any as S.Schema<DeleteRegionRequest>;
+
+export interface DeleteRegionResponse {}
+export const DeleteRegionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteRegionResponse",
+}) as any as 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 const WorkosAdminPortalIntent = S.String;
+
+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 const GenerateWorkosAdminPortalLinkRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      intent: WorkosAdminPortalIntent,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/organizations/{organizationId}/identity-providers/workos-admin-portal-link",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GenerateWorkosAdminPortalLinkRequest",
+}) as any as S.Schema<GenerateWorkosAdminPortalLinkRequest>;
+
+export interface WorkosAdminPortalLink {
+  /** Single-purpose WorkOS Admin Portal URL. Expires five minutes after issuance; open it immediately. */
+  link: string;
+}
+export const WorkosAdminPortalLink = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    link: S.String,
+  }),
+).annotate({
+  identifier: "WorkosAdminPortalLink",
+}) as any as S.Schema<WorkosAdminPortalLink>;
+
+export interface GetGpuCapacityRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const GetGpuCapacityRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organizations/{organizationId}/gpu-capacity",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetGpuCapacityRequest",
+}) as any as S.Schema<GetGpuCapacityRequest>;
+
+export type GpuType =
+  | "H100"
+  | "H200"
+  | "RTX-PRO-6000"
+  | "RTX-4090"
+  | "RTX-5090"
+  | "MI355X";
+export const GpuType = S.String;
+
+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 const GpuCapacity = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    gpuType: GpuType,
+    availableOnDemand: S.Number,
+    availableSpot: S.Number,
+  }),
+).annotate({ identifier: "GpuCapacity" }) as any as S.Schema<GpuCapacity>;
+
+export type GpuCapacityResponseCapacityList = Array<GpuCapacity>;
+export const GpuCapacityResponseCapacityList = /*@__PURE__*/ S.Array(
+  GpuCapacity,
+) as any as 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 const GpuCapacityResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    observedAt: S.String,
+    capacity: GpuCapacityResponseCapacityList,
+  }),
+).annotate({
+  identifier: "GpuCapacityResponse",
+}) as any as S.Schema<GpuCapacityResponse>;
+
+export interface GetOrganizationRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const GetOrganizationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organizations/{organizationId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOrganizationRequest",
+}) as any as S.Schema<GetOrganizationRequest>;
+
+export interface GetOrganizationIdentityProviderRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Identity provider ID */
+  id: string;
+}
+export const GetOrganizationIdentityProviderRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      id: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organizations/{organizationId}/identity-providers/{id}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GetOrganizationIdentityProviderRequest",
+}) as any as S.Schema<GetOrganizationIdentityProviderRequest>;
+
+export interface GetOrganizationInvitationsCountForAuthenticatedUserRequest {}
+export const GetOrganizationInvitationsCountForAuthenticatedUserRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organizations/invitations/count",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetOrganizationInvitationsCountForAuthenticatedUserRequest",
+  }) as any as S.Schema<GetOrganizationInvitationsCountForAuthenticatedUserRequest>;
+
+export type GetOrganizationInvitationsCountForAuthenticatedUserResponse =
+  number;
+export const GetOrganizationInvitationsCountForAuthenticatedUserResponse =
+  /*@__PURE__*/ S.suspend(() => S.Number.pipe(T.RawResponseRoot())).annotate({
+    identifier: "GetOrganizationInvitationsCountForAuthenticatedUserResponse",
+  }) as any as S.Schema<GetOrganizationInvitationsCountForAuthenticatedUserResponse>;
+
+export interface GetOrganizationOtelConfigRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const GetOrganizationOtelConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organizations/{organizationId}/otel-config",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOrganizationOtelConfigRequest",
+}) as any as S.Schema<GetOrganizationOtelConfigRequest>;
+
+export interface GetOrganizationOtelConfigBySandboxAuthTokenRequest {
+  /** Sandbox Auth Token */
+  authToken: string;
+}
+export const GetOrganizationOtelConfigBySandboxAuthTokenRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      authToken: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organizations/otel-config/by-sandbox-auth-token/{authToken}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetOrganizationOtelConfigBySandboxAuthTokenRequest",
+  }) as any as S.Schema<GetOrganizationOtelConfigBySandboxAuthTokenRequest>;
+
+export interface GetOrganizationUsageOverviewRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const GetOrganizationUsageOverviewRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organizations/{organizationId}/usage",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetOrganizationUsageOverviewRequest",
+}) as any as S.Schema<GetOrganizationUsageOverviewRequest>;
+
+export type SandboxClass = "linux-vm" | "container" | "android" | "windows";
+export const SandboxClass = S.String;
+
+export type RegionUsageOverviewAllowedGpuTypesList = Array<GpuType>;
+export const RegionUsageOverviewAllowedGpuTypesList = /*@__PURE__*/ S.Array(
+  GpuType,
+) as any as 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 const RegionUsageOverview = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    regionId: S.String,
+    sandboxClass: SandboxClass,
+    totalCpuQuota: S.Number,
+    currentCpuUsage: S.Number,
+    totalMemoryQuota: S.Number,
+    currentMemoryUsage: S.Number,
+    totalDiskQuota: S.Number,
+    currentDiskUsage: S.Number,
+    totalGpuQuota: S.Number,
+    currentGpuUsage: S.Number,
+    allowedGpuTypes: S.optional(RegionUsageOverviewAllowedGpuTypesList),
+    maxCpuPerSandbox: S.NullOr(S.Number),
+    maxMemoryPerSandbox: S.NullOr(S.Number),
+    maxDiskPerSandbox: S.NullOr(S.Number),
+    maxDiskPerNonEphemeralSandbox: S.NullOr(S.Number),
+    maxCpuPerGpu: S.NullOr(S.Number),
+    maxMemoryPerGpu: S.NullOr(S.Number),
+    maxDiskPerGpu: S.NullOr(S.Number),
+  }),
+).annotate({
+  identifier: "RegionUsageOverview",
+}) as any as S.Schema<RegionUsageOverview>;
+
+export type OrganizationUsageOverviewRegionUsageList =
+  Array<RegionUsageOverview>;
+export const OrganizationUsageOverviewRegionUsageList = /*@__PURE__*/ S.Array(
+  RegionUsageOverview,
+) as any as S.Schema<OrganizationUsageOverviewRegionUsageList>;
+
+export interface OrganizationUsageOverview {
+  regionUsage: OrganizationUsageOverviewRegionUsageList;
+  totalSnapshotQuota: number;
+  currentSnapshotUsage: number;
+  totalVolumeQuota: number;
+  currentVolumeUsage: number;
+}
+export const OrganizationUsageOverview = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    regionUsage: OrganizationUsageOverviewRegionUsageList,
+    totalSnapshotQuota: S.Number,
+    currentSnapshotUsage: S.Number,
+    totalVolumeQuota: S.Number,
+    currentVolumeUsage: S.Number,
+  }),
+).annotate({
+  identifier: "OrganizationUsageOverview",
+}) as any as S.Schema<OrganizationUsageOverview>;
+
+export interface GetRegionRequest {
+  /** Region ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetRegionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/regions/{id}", code: 200 })),
+).annotate({
+  identifier: "GetRegionRequest",
+}) as any as S.Schema<GetRegionRequest>;
+
+/** The type of the region */
+export type RegionType = "shared" | "dedicated" | "custom";
+export const RegionType = S.String;
+
+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 const Region = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    name: S.String,
+    organizationId: S.optional(S.NullOr(S.String)),
+    regionType: RegionType,
+    createdAt: S.String,
+    updatedAt: S.String,
+    proxyUrl: S.optional(S.NullOr(S.String)),
+    sshGatewayUrl: S.optional(S.NullOr(S.String)),
+    snapshotManagerUrl: S.optional(S.NullOr(S.String)),
+    otelEndpoint: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({ identifier: "Region" }) as any as S.Schema<Region>;
+
+export interface GetSandboxIdentityBySandboxAuthTokenRequest {
+  /** Sandbox Auth Token */
+  authToken: string;
+}
+export const GetSandboxIdentityBySandboxAuthTokenRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      authToken: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organizations/sandbox-identity/by-sandbox-auth-token/{authToken}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetSandboxIdentityBySandboxAuthTokenRequest",
+  }) as any as S.Schema<GetSandboxIdentityBySandboxAuthTokenRequest>;
+
+export interface SandboxIdentity {
+  /** Sandbox ID */
+  sandboxId: string;
+  /** Organization ID */
+  organizationId: string;
+}
+export const SandboxIdentity = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String,
+    organizationId: S.String,
+  }),
+).annotate({
+  identifier: "SandboxIdentity",
+}) as any as S.Schema<SandboxIdentity>;
+
+export interface LeaveOrganizationRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const LeaveOrganizationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/organizations/{organizationId}/leave",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "LeaveOrganizationRequest",
+}) as any as S.Schema<LeaveOrganizationRequest>;
+
+export interface LeaveOrganizationResponse {}
+export const LeaveOrganizationResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "LeaveOrganizationResponse",
+}) as any as S.Schema<LeaveOrganizationResponse>;
+
+export interface ListAvailableRegionsRequest {
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ListAvailableRegionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/regions", code: 200 })),
+).annotate({
+  identifier: "ListAvailableRegionsRequest",
+}) as any as S.Schema<ListAvailableRegionsRequest>;
+
+export type ListAvailableRegionsResponseBodyList = Array<Region>;
+export const ListAvailableRegionsResponseBodyList = /*@__PURE__*/ S.Array(
+  Region,
+) as any as S.Schema<ListAvailableRegionsResponseBodyList>;
+
+export type ListAvailableRegionsResponse = ListAvailableRegionsResponseBodyList;
+export const ListAvailableRegionsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAvailableRegionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAvailableRegionsResponse",
+}) as any as S.Schema<ListAvailableRegionsResponse>;
+
+export interface ListAvailableSandboxClassesRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const ListAvailableSandboxClassesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organizations/{organizationId}/available-sandbox-classes",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListAvailableSandboxClassesRequest",
+}) as any as S.Schema<ListAvailableSandboxClassesRequest>;
+
+export type AvailableSandboxClassAllowedGpuTypesList = Array<GpuType>;
+export const AvailableSandboxClassAllowedGpuTypesList = /*@__PURE__*/ S.Array(
+  GpuType,
+) as any as S.Schema<AvailableSandboxClassAllowedGpuTypesList>;
+
+export interface AvailableSandboxClass {
+  regionId: string;
+  sandboxClass: SandboxClass;
+  gpuAvailable: boolean;
+  allowedGpuTypes?: AvailableSandboxClassAllowedGpuTypesList;
+}
+export const AvailableSandboxClass = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    regionId: S.String,
+    sandboxClass: SandboxClass,
+    gpuAvailable: S.Boolean,
+    allowedGpuTypes: S.optional(AvailableSandboxClassAllowedGpuTypesList),
+  }),
+).annotate({
+  identifier: "AvailableSandboxClass",
+}) as any as S.Schema<AvailableSandboxClass>;
+
+export type ListAvailableSandboxClassesResponseBodyList =
+  Array<AvailableSandboxClass>;
+export const ListAvailableSandboxClassesResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    AvailableSandboxClass,
+  ) as any as S.Schema<ListAvailableSandboxClassesResponseBodyList>;
+
+export type ListAvailableSandboxClassesResponse =
+  ListAvailableSandboxClassesResponseBodyList;
+export const ListAvailableSandboxClassesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListAvailableSandboxClassesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListAvailableSandboxClassesResponse",
+}) as any as S.Schema<ListAvailableSandboxClassesResponse>;
+
+export interface ListOrganizationIdentityProvidersRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const ListOrganizationIdentityProvidersRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/organizations/{organizationId}/identity-providers",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "ListOrganizationIdentityProvidersRequest",
+}) as any as S.Schema<ListOrganizationIdentityProvidersRequest>;
+
+export type ListOrganizationIdentityProvidersResponseBodyList =
+  Array<IdentityProvider>;
+export const ListOrganizationIdentityProvidersResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    IdentityProvider,
+  ) as any as S.Schema<ListOrganizationIdentityProvidersResponseBodyList>;
+
+export type ListOrganizationIdentityProvidersResponse =
+  ListOrganizationIdentityProvidersResponseBodyList;
+export const ListOrganizationIdentityProvidersResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListOrganizationIdentityProvidersResponseBodyList.pipe(T.RawResponseRoot()),
+  ).annotate({
+    identifier: "ListOrganizationIdentityProvidersResponse",
+  }) as any as S.Schema<ListOrganizationIdentityProvidersResponse>;
+
+export interface ListOrganizationInvitationsRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const ListOrganizationInvitationsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organizations/{organizationId}/invitations",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOrganizationInvitationsRequest",
+}) as any as S.Schema<ListOrganizationInvitationsRequest>;
+
+export type ListOrganizationInvitationsResponseBodyList =
+  Array<OrganizationInvitation>;
+export const ListOrganizationInvitationsResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    OrganizationInvitation,
+  ) as any as S.Schema<ListOrganizationInvitationsResponseBodyList>;
+
+export type ListOrganizationInvitationsResponse =
+  ListOrganizationInvitationsResponseBodyList;
+export const ListOrganizationInvitationsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOrganizationInvitationsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOrganizationInvitationsResponse",
+}) as any as S.Schema<ListOrganizationInvitationsResponse>;
+
+export interface ListOrganizationInvitationsForAuthenticatedUserRequest {}
+export const ListOrganizationInvitationsForAuthenticatedUserRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({}).pipe(
+      T.Http({ method: "GET", uri: "/organizations/invitations", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "ListOrganizationInvitationsForAuthenticatedUserRequest",
+  }) as any as S.Schema<ListOrganizationInvitationsForAuthenticatedUserRequest>;
+
+export type ListOrganizationInvitationsForAuthenticatedUserResponseBodyList =
+  Array<OrganizationInvitation>;
+export const ListOrganizationInvitationsForAuthenticatedUserResponseBodyList =
+  /*@__PURE__*/ S.Array(
+    OrganizationInvitation,
+  ) as any as S.Schema<ListOrganizationInvitationsForAuthenticatedUserResponseBodyList>;
+
+export type ListOrganizationInvitationsForAuthenticatedUserResponse =
+  ListOrganizationInvitationsForAuthenticatedUserResponseBodyList;
+export const ListOrganizationInvitationsForAuthenticatedUserResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    ListOrganizationInvitationsForAuthenticatedUserResponseBodyList.pipe(
+      T.RawResponseRoot(),
+    ),
+  ).annotate({
+    identifier: "ListOrganizationInvitationsForAuthenticatedUserResponse",
+  }) as any as S.Schema<ListOrganizationInvitationsForAuthenticatedUserResponse>;
+
+export interface ListOrganizationMembersRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const ListOrganizationMembersRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organizations/{organizationId}/users",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOrganizationMembersRequest",
+}) as any as S.Schema<ListOrganizationMembersRequest>;
+
+/** Member role */
+export type OrganizationUserRole = "owner" | "member";
+export const OrganizationUserRole = S.String;
+
+/** Roles assigned to the user */
+export type OrganizationUserAssignedRolesList = Array<OrganizationRole>;
+export const OrganizationUserAssignedRolesList = /*@__PURE__*/ S.Array(
+  OrganizationRole,
+) as any as 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 const OrganizationUser = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    userId: S.String,
+    organizationId: S.String,
+    name: S.String,
+    email: S.String,
+    role: OrganizationUserRole,
+    assignedRoles: OrganizationUserAssignedRolesList,
+    createdAt: S.String,
+    updatedAt: S.String,
+  }),
+).annotate({
+  identifier: "OrganizationUser",
+}) as any as S.Schema<OrganizationUser>;
+
+export type ListOrganizationMembersResponseBodyList = Array<OrganizationUser>;
+export const ListOrganizationMembersResponseBodyList = /*@__PURE__*/ S.Array(
+  OrganizationUser,
+) as any as S.Schema<ListOrganizationMembersResponseBodyList>;
+
+export type ListOrganizationMembersResponse =
+  ListOrganizationMembersResponseBodyList;
+export const ListOrganizationMembersResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOrganizationMembersResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOrganizationMembersResponse",
+}) as any as S.Schema<ListOrganizationMembersResponse>;
+
+export interface ListOrganizationRolesRequest {
+  /** Organization ID */
+  organizationId: string;
+}
+export const ListOrganizationRolesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/organizations/{organizationId}/roles",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "ListOrganizationRolesRequest",
+}) as any as S.Schema<ListOrganizationRolesRequest>;
+
+export type ListOrganizationRolesResponseBodyList = Array<OrganizationRole>;
+export const ListOrganizationRolesResponseBodyList = /*@__PURE__*/ S.Array(
+  OrganizationRole,
+) as any as S.Schema<ListOrganizationRolesResponseBodyList>;
+
+export type ListOrganizationRolesResponse =
+  ListOrganizationRolesResponseBodyList;
+export const ListOrganizationRolesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOrganizationRolesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOrganizationRolesResponse",
+}) as any as S.Schema<ListOrganizationRolesResponse>;
+
+export interface ListOrganizationsRequest {}
+export const ListOrganizationsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/organizations", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListOrganizationsRequest",
+}) as any as S.Schema<ListOrganizationsRequest>;
+
+export type ListOrganizationsResponseBodyList = Array<Organization>;
+export const ListOrganizationsResponseBodyList = /*@__PURE__*/ S.Array(
+  Organization,
+) as any as S.Schema<ListOrganizationsResponseBodyList>;
+
+export type ListOrganizationsResponse = ListOrganizationsResponseBodyList;
+export const ListOrganizationsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListOrganizationsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListOrganizationsResponse",
+}) as any as S.Schema<ListOrganizationsResponse>;
+
+export interface RegenerateProxyApiKeyRequest {
+  /** Region ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const RegenerateProxyApiKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/regions/{id}/regenerate-proxy-api-key",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RegenerateProxyApiKeyRequest",
+}) as any as S.Schema<RegenerateProxyApiKeyRequest>;
+
+export interface RegenerateApiKeyResponse {
+  /** The newly generated API key */
+  apiKey: string | Redacted.Redacted<string>;
+}
+export const RegenerateApiKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    apiKey: S.String.pipe(T.SensitiveValue({})),
+  }),
+).annotate({
+  identifier: "RegenerateApiKeyResponse",
+}) as any as S.Schema<RegenerateApiKeyResponse>;
+
+export interface RegenerateSnapshotManagerCredentialsRequest {
+  /** Region ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const RegenerateSnapshotManagerCredentialsRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      id: S.String.pipe(T.Label()),
+      xDaytonaOrganizationID: S.optional(
+        S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+      ),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/regions/{id}/regenerate-snapshot-manager-credentials",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "RegenerateSnapshotManagerCredentialsRequest",
+  }) as any as 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 const SnapshotManagerCredentials = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String,
+    password: S.String.pipe(T.SensitiveValue({})),
+  }),
+).annotate({
+  identifier: "SnapshotManagerCredentials",
+}) as any as S.Schema<SnapshotManagerCredentials>;
+
+export interface RegenerateSshGatewayApiKeyRequest {
+  /** Region ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const RegenerateSshGatewayApiKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/regions/{id}/regenerate-ssh-gateway-api-key",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RegenerateSshGatewayApiKeyRequest",
+}) as any as S.Schema<RegenerateSshGatewayApiKeyRequest>;
+
+export interface SetOrganizationDefaultRegionRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** The ID of the default region for the organization */
+  defaultRegionId: string;
+}
+export const SetOrganizationDefaultRegionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    defaultRegionId: S.String,
+  }).pipe(
+    T.Http({
+      method: "PATCH",
+      uri: "/organizations/{organizationId}/default-region",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "SetOrganizationDefaultRegionRequest",
+}) as any as S.Schema<SetOrganizationDefaultRegionRequest>;
+
+export interface SetOrganizationDefaultRegionResponse {}
+export const SetOrganizationDefaultRegionResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "SetOrganizationDefaultRegionResponse",
+}) as any as S.Schema<SetOrganizationDefaultRegionResponse>;
+
+export interface TestOrganizationIdentityProviderConnectionRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** OIDC Issuer URL to test */
+  issuerUrl: string;
+}
+export const TestOrganizationIdentityProviderConnectionRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      issuerUrl: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/organizations/{organizationId}/identity-providers/test-connection",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "TestOrganizationIdentityProviderConnectionRequest",
+  }) as any as 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 const TestIdentityProviderConnectionResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      success: S.Boolean,
+      issuer: S.optional(S.String),
+      error: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "TestIdentityProviderConnectionResponse",
+}) as any as S.Schema<TestIdentityProviderConnectionResponse>;
+
+/** Organization member role */
+export type UpdateAccessForOrganizationMemberRequestRole = "owner" | "member";
+export const UpdateAccessForOrganizationMemberRequestRole = S.String;
+
+/** Array of assigned role IDs */
+export type UpdateAccessForOrganizationMemberRequestAssignedRoleIdsList =
+  Array<string>;
+export const UpdateAccessForOrganizationMemberRequestAssignedRoleIdsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as 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 const UpdateAccessForOrganizationMemberRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      userId: S.String.pipe(T.Label()),
+      role: UpdateAccessForOrganizationMemberRequestRole,
+      assignedRoleIds:
+        UpdateAccessForOrganizationMemberRequestAssignedRoleIdsList,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/organizations/{organizationId}/users/{userId}/access",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "UpdateAccessForOrganizationMemberRequest",
+}) as any as S.Schema<UpdateAccessForOrganizationMemberRequest>;
+
+export type UpdateExperimentalConfigRequestBodyMap = {
+  [key: string]: unknown | undefined;
+};
+export const UpdateExperimentalConfigRequestBodyMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.Unknown,
+) as any as S.Schema<UpdateExperimentalConfigRequestBodyMap>;
+
+export interface UpdateExperimentalConfigRequest {
+  /** Organization ID */
+  organizationId: string;
+  body?: UpdateExperimentalConfigRequestBodyMap;
+}
+export const UpdateExperimentalConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    body: S.optional(UpdateExperimentalConfigRequestBodyMap.pipe(T.HttpBody())),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/organizations/{organizationId}/experimental-config",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateExperimentalConfigRequest",
+}) as any as S.Schema<UpdateExperimentalConfigRequest>;
+
+export interface UpdateExperimentalConfigResponse {}
+export const UpdateExperimentalConfigResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateExperimentalConfigResponse",
+}) as any as 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 const UpdateOidcIdPConfig = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    issuerUrl: S.optional(S.String),
+    clientId: S.optional(S.String),
+    clientSecret: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    scope: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "UpdateOidcIdPConfig",
+}) as any as 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 const UpdateOrganizationIdentityProviderRequestEmailDomainsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as 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 const UpdateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as 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 const UpdateOrganizationIdentityProviderRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      id: S.String.pipe(T.Label()),
+      name: S.optional(S.String),
+      oidcConfig: S.optional(UpdateOidcIdPConfig),
+      emailDomains: S.optional(
+        UpdateOrganizationIdentityProviderRequestEmailDomainsList,
+      ),
+      allowAnyDomain: S.optional(S.Boolean),
+      trustEmailVerified: S.optional(S.Boolean),
+      defaultAssignedRoleIds: S.optional(
+        UpdateOrganizationIdentityProviderRequestDefaultAssignedRoleIdsList,
+      ),
+      enabled: S.optional(S.Boolean),
+    }).pipe(
+      T.Http({
+        method: "PATCH",
+        uri: "/organizations/{organizationId}/identity-providers/{id}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "UpdateOrganizationIdentityProviderRequest",
+  }) as any as S.Schema<UpdateOrganizationIdentityProviderRequest>;
+
+/** Organization member role */
+export type UpdateOrganizationInvitationRequestRole = "owner" | "member";
+export const UpdateOrganizationInvitationRequestRole = S.String;
+
+/** Array of role IDs */
+export type UpdateOrganizationInvitationRequestAssignedRoleIdsList =
+  Array<string>;
+export const UpdateOrganizationInvitationRequestAssignedRoleIdsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as 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 const UpdateOrganizationInvitationRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    invitationId: S.String.pipe(T.Label()),
+    role: UpdateOrganizationInvitationRequestRole,
+    assignedRoleIds: UpdateOrganizationInvitationRequestAssignedRoleIdsList,
+    expiresAt: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/organizations/{organizationId}/invitations/{invitationId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateOrganizationInvitationRequest",
+}) as any as S.Schema<UpdateOrganizationInvitationRequest>;
+
+/** Headers */
+export type UpdateOrganizationOtelConfigRequestHeadersMap = {
+  [key: string]: string | undefined;
+};
+export const UpdateOrganizationOtelConfigRequestHeadersMap =
+  /*@__PURE__*/ S.Record(
+    S.String,
+    S.String,
+  ) as any as S.Schema<UpdateOrganizationOtelConfigRequestHeadersMap>;
+
+export interface UpdateOrganizationOtelConfigRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Endpoint */
+  endpoint: string;
+  /** Headers */
+  headers?: UpdateOrganizationOtelConfigRequestHeadersMap | null;
+}
+export const UpdateOrganizationOtelConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    endpoint: S.String,
+    headers: S.optional(
+      S.NullOr(UpdateOrganizationOtelConfigRequestHeadersMap),
+    ),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/organizations/{organizationId}/otel-config",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateOrganizationOtelConfigRequest",
+}) as any as S.Schema<UpdateOrganizationOtelConfigRequest>;
+
+export interface UpdateOrganizationOtelConfigResponse {}
+export const UpdateOrganizationOtelConfigResponse = /*@__PURE__*/ S.suspend(
+  () => S.Struct({}),
+).annotate({
+  identifier: "UpdateOrganizationOtelConfigResponse",
+}) as any as 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 const UpdateOrganizationRoleRequestPermissionsItem = S.String;
+
+/** The list of permissions assigned to the role */
+export type UpdateOrganizationRoleRequestPermissionsList = Array<
+  UpdateOrganizationRoleRequestPermissionsItem | (string & {})
+>;
+export const UpdateOrganizationRoleRequestPermissionsList =
+  /*@__PURE__*/ S.Array(
+    UpdateOrganizationRoleRequestPermissionsItem,
+  ) as any as 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 const UpdateOrganizationRoleRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String.pipe(T.Label()),
+    roleId: S.String.pipe(T.Label()),
+    name: S.String,
+    description: S.String,
+    permissions: UpdateOrganizationRoleRequestPermissionsList,
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/organizations/{organizationId}/roles/{roleId}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "UpdateOrganizationRoleRequest",
+}) as any as 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 const UpdateRegionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    proxyUrl: S.optional(S.NullOr(S.String)),
+    sshGatewayUrl: S.optional(S.NullOr(S.String)),
+    snapshotManagerUrl: S.optional(S.NullOr(S.String)),
+    otelEndpoint: S.optional(S.NullOr(S.String)),
+  }).pipe(T.Http({ method: "PATCH", uri: "/regions/{id}", code: 200 })),
+).annotate({
+  identifier: "UpdateRegionRequest",
+}) as any as S.Schema<UpdateRegionRequest>;
+
+export interface UpdateRegionResponse {}
+export const UpdateRegionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "UpdateRegionResponse",
+}) as any as S.Schema<UpdateRegionResponse>;
+
+export type AcceptOrganizationInvitationError = DaytonaOpError;
+/** Accept organization invitation */
+export const acceptOrganizationInvitation: API.OperationMethod<
+  AcceptOrganizationInvitationRequest,
+  OrganizationInvitation,
+  AcceptOrganizationInvitationError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: AcceptOrganizationInvitationRequest,
+  output: OrganizationInvitation,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CancelOrganizationInvitationError = DaytonaOpError;
+/** Cancel organization invitation */
+export const cancelOrganizationInvitation: API.OperationMethod<
+  CancelOrganizationInvitationRequest,
+  CancelOrganizationInvitationResponse,
+  CancelOrganizationInvitationError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CancelOrganizationInvitationRequest,
+  output: CancelOrganizationInvitationResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOrganizationError = DaytonaOpError;
+/** Create organization */
+export const createOrganization: API.OperationMethod<
+  CreateOrganizationRequest,
+  Organization,
+  CreateOrganizationError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOrganizationRequest,
+  output: Organization,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOrganizationIdentityProviderError = DaytonaOpError;
+/** Create organization identity provider */
+export const createOrganizationIdentityProvider: API.OperationMethod<
+  CreateOrganizationIdentityProviderRequest,
+  IdentityProvider,
+  CreateOrganizationIdentityProviderError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOrganizationIdentityProviderRequest,
+  output: IdentityProvider,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOrganizationInvitationError = DaytonaOpError;
+/** Create organization invitation */
+export const createOrganizationInvitation: API.OperationMethod<
+  CreateOrganizationInvitationRequest,
+  OrganizationInvitation,
+  CreateOrganizationInvitationError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOrganizationInvitationRequest,
+  output: OrganizationInvitation,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOrganizationRoleError = DaytonaOpError;
+/** Create organization role */
+export const createOrganizationRole: API.OperationMethod<
+  CreateOrganizationRoleRequest,
+  OrganizationRole,
+  CreateOrganizationRoleError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOrganizationRoleRequest,
+  output: OrganizationRole,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateRegionError = DaytonaOpError;
+/** Create a new region */
+export const createRegion: API.OperationMethod<
+  CreateRegionRequest,
+  CreateRegionResponse,
+  CreateRegionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateRegionRequest,
+  output: CreateRegionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeclineOrganizationInvitationError = DaytonaOpError;
+/** Decline organization invitation */
+export const declineOrganizationInvitation: API.OperationMethod<
+  DeclineOrganizationInvitationRequest,
+  DeclineOrganizationInvitationResponse,
+  DeclineOrganizationInvitationError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeclineOrganizationInvitationRequest,
+  output: DeclineOrganizationInvitationResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOrganizationError = DaytonaOpError;
+/** Delete organization */
+export const deleteOrganization: API.OperationMethod<
+  DeleteOrganizationRequest,
+  DeleteOrganizationResponse,
+  DeleteOrganizationError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOrganizationRequest,
+  output: DeleteOrganizationResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOrganizationIdentityProviderError = DaytonaOpError;
+/** Delete organization identity provider */
+export const deleteOrganizationIdentityProvider: API.OperationMethod<
+  DeleteOrganizationIdentityProviderRequest,
+  DeleteOrganizationIdentityProviderResponse,
+  DeleteOrganizationIdentityProviderError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOrganizationIdentityProviderRequest,
+  output: DeleteOrganizationIdentityProviderResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOrganizationMemberError = DaytonaOpError;
+/** Delete organization member */
+export const deleteOrganizationMember: API.OperationMethod<
+  DeleteOrganizationMemberRequest,
+  DeleteOrganizationMemberResponse,
+  DeleteOrganizationMemberError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOrganizationMemberRequest,
+  output: DeleteOrganizationMemberResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOrganizationOtelConfigError = DaytonaOpError;
+/** Delete organization OpenTelemetry configuration */
+export const deleteOrganizationOtelConfig: API.OperationMethod<
+  DeleteOrganizationOtelConfigRequest,
+  DeleteOrganizationOtelConfigResponse,
+  DeleteOrganizationOtelConfigError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOrganizationOtelConfigRequest,
+  output: DeleteOrganizationOtelConfigResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteOrganizationRoleError = DaytonaOpError;
+/** Delete organization role */
+export const deleteOrganizationRole: API.OperationMethod<
+  DeleteOrganizationRoleRequest,
+  DeleteOrganizationRoleResponse,
+  DeleteOrganizationRoleError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteOrganizationRoleRequest,
+  output: DeleteOrganizationRoleResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteRegionError = DaytonaOpError;
+/** Delete a region */
+export const deleteRegion: API.OperationMethod<
+  DeleteRegionRequest,
+  DeleteRegionResponse,
+  DeleteRegionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteRegionRequest,
+  output: DeleteRegionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateWorkosAdminPortalLinkError = DaytonaOpError;
+/** Generate a WorkOS Admin Portal link for configuring SSO or SCIM directory sync */
+export const generateWorkosAdminPortalLink: API.OperationMethod<
+  GenerateWorkosAdminPortalLinkRequest,
+  WorkosAdminPortalLink,
+  GenerateWorkosAdminPortalLinkError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateWorkosAdminPortalLinkRequest,
+  output: WorkosAdminPortalLink,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+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 const getGpuCapacity: API.OperationMethod<
+  GetGpuCapacityRequest,
+  GpuCapacityResponse,
+  GetGpuCapacityError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetGpuCapacityRequest,
+  output: GpuCapacityResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrganizationError = DaytonaOpError;
+/** Get organization by ID */
+export const getOrganization: API.OperationMethod<
+  GetOrganizationRequest,
+  Organization,
+  GetOrganizationError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrganizationRequest,
+  output: Organization,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrganizationIdentityProviderError = DaytonaOpError;
+/** Get organization identity provider */
+export const getOrganizationIdentityProvider: API.OperationMethod<
+  GetOrganizationIdentityProviderRequest,
+  IdentityProvider,
+  GetOrganizationIdentityProviderError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrganizationIdentityProviderRequest,
+  output: IdentityProvider,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrganizationInvitationsCountForAuthenticatedUserError =
+  DaytonaOpError;
+/** Get count of organization invitations for authenticated user */
+export const getOrganizationInvitationsCountForAuthenticatedUser: API.OperationMethod<
+  GetOrganizationInvitationsCountForAuthenticatedUserRequest,
+  GetOrganizationInvitationsCountForAuthenticatedUserResponse,
+  GetOrganizationInvitationsCountForAuthenticatedUserError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrganizationInvitationsCountForAuthenticatedUserRequest,
+  output: GetOrganizationInvitationsCountForAuthenticatedUserResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrganizationOtelConfigError = DaytonaOpError;
+/** Get organization OTEL config by organization ID */
+export const getOrganizationOtelConfig: API.OperationMethod<
+  GetOrganizationOtelConfigRequest,
+  OtelConfig,
+  GetOrganizationOtelConfigError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrganizationOtelConfigRequest,
+  output: OtelConfig,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrganizationOtelConfigBySandboxAuthTokenError = DaytonaOpError;
+/** Get organization OTEL config by sandbox auth token */
+export const getOrganizationOtelConfigBySandboxAuthToken: API.OperationMethod<
+  GetOrganizationOtelConfigBySandboxAuthTokenRequest,
+  OtelConfig,
+  GetOrganizationOtelConfigBySandboxAuthTokenError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrganizationOtelConfigBySandboxAuthTokenRequest,
+  output: OtelConfig,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetOrganizationUsageOverviewError = DaytonaOpError;
+/** Get organization current usage overview */
+export const getOrganizationUsageOverview: API.OperationMethod<
+  GetOrganizationUsageOverviewRequest,
+  OrganizationUsageOverview,
+  GetOrganizationUsageOverviewError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetOrganizationUsageOverviewRequest,
+  output: OrganizationUsageOverview,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetRegionError = DaytonaOpError;
+/** Get region by ID */
+export const getRegion: API.OperationMethod<
+  GetRegionRequest,
+  Region,
+  GetRegionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetRegionRequest,
+  output: Region,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSandboxIdentityBySandboxAuthTokenError = DaytonaOpError;
+/** Get sandbox identity by sandbox auth token */
+export const getSandboxIdentityBySandboxAuthToken: API.OperationMethod<
+  GetSandboxIdentityBySandboxAuthTokenRequest,
+  SandboxIdentity,
+  GetSandboxIdentityBySandboxAuthTokenError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxIdentityBySandboxAuthTokenRequest,
+  output: SandboxIdentity,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type LeaveOrganizationError = DaytonaOpError;
+/** Leave organization */
+export const leaveOrganization: API.OperationMethod<
+  LeaveOrganizationRequest,
+  LeaveOrganizationResponse,
+  LeaveOrganizationError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: LeaveOrganizationRequest,
+  output: LeaveOrganizationResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAvailableRegionsError = DaytonaOpError;
+/** List all available regions for the organization */
+export const listAvailableRegions: API.OperationMethod<
+  ListAvailableRegionsRequest,
+  ListAvailableRegionsResponse,
+  ListAvailableRegionsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAvailableRegionsRequest,
+  output: ListAvailableRegionsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListAvailableSandboxClassesError = DaytonaOpError;
+/** List available sandbox classes for organization */
+export const listAvailableSandboxClasses: API.OperationMethod<
+  ListAvailableSandboxClassesRequest,
+  ListAvailableSandboxClassesResponse,
+  ListAvailableSandboxClassesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListAvailableSandboxClassesRequest,
+  output: ListAvailableSandboxClassesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationIdentityProvidersError = DaytonaOpError;
+/** List organization identity providers */
+export const listOrganizationIdentityProviders: API.OperationMethod<
+  ListOrganizationIdentityProvidersRequest,
+  ListOrganizationIdentityProvidersResponse,
+  ListOrganizationIdentityProvidersError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationIdentityProvidersRequest,
+  output: ListOrganizationIdentityProvidersResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationInvitationsError = DaytonaOpError;
+/** List pending organization invitations */
+export const listOrganizationInvitations: API.OperationMethod<
+  ListOrganizationInvitationsRequest,
+  ListOrganizationInvitationsResponse,
+  ListOrganizationInvitationsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationInvitationsRequest,
+  output: ListOrganizationInvitationsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationInvitationsForAuthenticatedUserError =
+  DaytonaOpError;
+/** List organization invitations for authenticated user */
+export const listOrganizationInvitationsForAuthenticatedUser: API.OperationMethod<
+  ListOrganizationInvitationsForAuthenticatedUserRequest,
+  ListOrganizationInvitationsForAuthenticatedUserResponse,
+  ListOrganizationInvitationsForAuthenticatedUserError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationInvitationsForAuthenticatedUserRequest,
+  output: ListOrganizationInvitationsForAuthenticatedUserResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationMembersError = DaytonaOpError;
+/** List organization members */
+export const listOrganizationMembers: API.OperationMethod<
+  ListOrganizationMembersRequest,
+  ListOrganizationMembersResponse,
+  ListOrganizationMembersError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationMembersRequest,
+  output: ListOrganizationMembersResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationRolesError = DaytonaOpError;
+/** List organization roles */
+export const listOrganizationRoles: API.OperationMethod<
+  ListOrganizationRolesRequest,
+  ListOrganizationRolesResponse,
+  ListOrganizationRolesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationRolesRequest,
+  output: ListOrganizationRolesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListOrganizationsError = DaytonaOpError;
+/** List organizations */
+export const listOrganizations: API.OperationMethod<
+  ListOrganizationsRequest,
+  ListOrganizationsResponse,
+  ListOrganizationsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListOrganizationsRequest,
+  output: ListOrganizationsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RegenerateProxyApiKeyError = DaytonaOpError;
+/** Regenerate proxy API key for a region */
+export const regenerateProxyApiKey: API.OperationMethod<
+  RegenerateProxyApiKeyRequest,
+  RegenerateApiKeyResponse,
+  RegenerateProxyApiKeyError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RegenerateProxyApiKeyRequest,
+  output: RegenerateApiKeyResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RegenerateSnapshotManagerCredentialsError = DaytonaOpError;
+/** Regenerate snapshot manager credentials for a region */
+export const regenerateSnapshotManagerCredentials: API.OperationMethod<
+  RegenerateSnapshotManagerCredentialsRequest,
+  SnapshotManagerCredentials,
+  RegenerateSnapshotManagerCredentialsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RegenerateSnapshotManagerCredentialsRequest,
+  output: SnapshotManagerCredentials,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RegenerateSshGatewayApiKeyError = DaytonaOpError;
+/** Regenerate SSH gateway API key for a region */
+export const regenerateSshGatewayApiKey: API.OperationMethod<
+  RegenerateSshGatewayApiKeyRequest,
+  RegenerateApiKeyResponse,
+  RegenerateSshGatewayApiKeyError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RegenerateSshGatewayApiKeyRequest,
+  output: RegenerateApiKeyResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SetOrganizationDefaultRegionError = DaytonaOpError;
+/** Set default region for organization */
+export const setOrganizationDefaultRegion: API.OperationMethod<
+  SetOrganizationDefaultRegionRequest,
+  SetOrganizationDefaultRegionResponse,
+  SetOrganizationDefaultRegionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SetOrganizationDefaultRegionRequest,
+  output: SetOrganizationDefaultRegionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TestOrganizationIdentityProviderConnectionError = DaytonaOpError;
+/** Test OIDC identity provider connection */
+export const testOrganizationIdentityProviderConnection: API.OperationMethod<
+  TestOrganizationIdentityProviderConnectionRequest,
+  TestIdentityProviderConnectionResponse,
+  TestOrganizationIdentityProviderConnectionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TestOrganizationIdentityProviderConnectionRequest,
+  output: TestIdentityProviderConnectionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateAccessForOrganizationMemberError = DaytonaOpError;
+/** Update access for organization member */
+export const updateAccessForOrganizationMember: API.OperationMethod<
+  UpdateAccessForOrganizationMemberRequest,
+  OrganizationUser,
+  UpdateAccessForOrganizationMemberError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateAccessForOrganizationMemberRequest,
+  output: OrganizationUser,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateExperimentalConfigError = DaytonaOpError;
+/** Update experimental configuration */
+export const updateExperimentalConfig: API.OperationMethod<
+  UpdateExperimentalConfigRequest,
+  UpdateExperimentalConfigResponse,
+  UpdateExperimentalConfigError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateExperimentalConfigRequest,
+  output: UpdateExperimentalConfigResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateOrganizationIdentityProviderError = DaytonaOpError;
+/** Update organization identity provider */
+export const updateOrganizationIdentityProvider: API.OperationMethod<
+  UpdateOrganizationIdentityProviderRequest,
+  IdentityProvider,
+  UpdateOrganizationIdentityProviderError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateOrganizationIdentityProviderRequest,
+  output: IdentityProvider,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateOrganizationInvitationError = DaytonaOpError;
+/** Update organization invitation */
+export const updateOrganizationInvitation: API.OperationMethod<
+  UpdateOrganizationInvitationRequest,
+  OrganizationInvitation,
+  UpdateOrganizationInvitationError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateOrganizationInvitationRequest,
+  output: OrganizationInvitation,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateOrganizationOtelConfigError = DaytonaOpError;
+/** Update organization OpenTelemetry configuration */
+export const updateOrganizationOtelConfig: API.OperationMethod<
+  UpdateOrganizationOtelConfigRequest,
+  UpdateOrganizationOtelConfigResponse,
+  UpdateOrganizationOtelConfigError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateOrganizationOtelConfigRequest,
+  output: UpdateOrganizationOtelConfigResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateOrganizationRoleError = DaytonaOpError;
+/** Update organization role */
+export const updateOrganizationRole: API.OperationMethod<
+  UpdateOrganizationRoleRequest,
+  OrganizationRole,
+  UpdateOrganizationRoleError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateOrganizationRoleRequest,
+  output: OrganizationRole,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateRegionError = DaytonaOpError;
+/** Update region configuration */
+export const updateRegion: API.OperationMethod<
+  UpdateRegionRequest,
+  UpdateRegionResponse,
+  UpdateRegionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateRegionRequest,
+  output: UpdateRegionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));