ExDaytona.Api.Organizations (ex_daytona v0.1.0)

@spec accept_organization_invitation(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, ExDaytona.Model.OrganizationInvitation.t()} | {:error, Tesla.Env.t()}

Accept organization invitation

Parameters

connection (ExDaytona.Connection): Connection to server
invitation_id (String.t): Invitation ID
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.OrganizationInvitation.t} on success
{:error, Tesla.Env.t} on failure

cancel_organization_invitation(connection, organization_id, invitation_id, opts \\ [])

@spec cancel_organization_invitation(
  Tesla.Env.client(),
  String.t(),
  String.t(),
  keyword()
) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Cancel organization invitation

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
invitation_id (String.t): Invitation ID
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

create_organization(connection, create_organization, opts \\ [])

@spec create_organization(
  Tesla.Env.client(),
  ExDaytona.Model.CreateOrganization.t(),
  keyword()
) ::
  {:ok, ExDaytona.Model.Organization.t()} | {:error, Tesla.Env.t()}

Create organization

Parameters

connection (ExDaytona.Connection): Connection to server
create_organization (CreateOrganization):
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.Organization.t} on success
{:error, Tesla.Env.t} on failure

create_organization_identity_provider(connection, organization_id, create_identity_provider, opts \\ [])

@spec create_organization_identity_provider(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.CreateIdentityProvider.t(),
  keyword()
) :: {:ok, ExDaytona.Model.IdentityProvider.t()} | {:error, Tesla.Env.t()}

Create organization identity provider

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
create_identity_provider (CreateIdentityProvider):
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.IdentityProvider.t} on success
{:error, Tesla.Env.t} on failure

create_organization_invitation(connection, organization_id, create_organization_invitation, opts \\ [])

@spec create_organization_invitation(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.CreateOrganizationInvitation.t(),
  keyword()
) :: {:ok, ExDaytona.Model.OrganizationInvitation.t()} | {:error, Tesla.Env.t()}

Create organization invitation

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
create_organization_invitation (CreateOrganizationInvitation):
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.OrganizationInvitation.t} on success
{:error, Tesla.Env.t} on failure

create_organization_role(connection, organization_id, create_organization_role, opts \\ [])

@spec create_organization_role(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.CreateOrganizationRole.t(),
  keyword()
) :: {:ok, ExDaytona.Model.OrganizationRole.t()} | {:error, Tesla.Env.t()}

Create organization role

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
create_organization_role (CreateOrganizationRole):
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.OrganizationRole.t} on success
{:error, Tesla.Env.t} on failure

create_region(connection, create_region, opts \\ [])

@spec create_region(Tesla.Env.client(), ExDaytona.Model.CreateRegion.t(), keyword()) ::
  {:ok, ExDaytona.Model.CreateRegionResponse.t()} | {:error, Tesla.Env.t()}

Create a new region

Parameters

connection (ExDaytona.Connection): Connection to server
create_region (CreateRegion):
opts (keyword): Optional parameters
- :"X-Daytona-Organization-ID" (String.t): Use with JWT to specify the organization ID

Returns

{:ok, ExDaytona.Model.CreateRegionResponse.t} on success
{:error, Tesla.Env.t} on failure

decline_organization_invitation(connection, invitation_id, opts \\ [])

@spec decline_organization_invitation(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Decline organization invitation

Parameters

connection (ExDaytona.Connection): Connection to server
invitation_id (String.t): Invitation ID
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

delete_organization(connection, organization_id, opts \\ [])

@spec delete_organization(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Delete organization

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

delete_organization_identity_provider(connection, organization_id, id, opts \\ [])

@spec delete_organization_identity_provider(
  Tesla.Env.client(),
  String.t(),
  String.t(),
  keyword()
) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Delete organization identity provider

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
id (String.t): Identity provider ID
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

delete_organization_member(connection, organization_id, user_id, opts \\ [])

@spec delete_organization_member(
  Tesla.Env.client(),
  String.t(),
  String.t(),
  keyword()
) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Delete organization member

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
user_id (String.t): User ID
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

delete_organization_otel_config(connection, organization_id, opts \\ [])

@spec delete_organization_otel_config(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Delete organization OpenTelemetry configuration

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

delete_organization_role(connection, organization_id, role_id, opts \\ [])

@spec delete_organization_role(Tesla.Env.client(), String.t(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Delete organization role

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
role_id (String.t): Role ID
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

delete_region(connection, id, opts \\ [])

@spec delete_region(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Delete a region

Parameters

connection (ExDaytona.Connection): Connection to server
id (String.t): Region ID
opts (keyword): Optional parameters
- :"X-Daytona-Organization-ID" (String.t): Use with JWT to specify the organization ID

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

get_organization(connection, organization_id, opts \\ [])

@spec get_organization(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, ExDaytona.Model.Organization.t()} | {:error, Tesla.Env.t()}

Get organization by ID

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.Organization.t} on success
{:error, Tesla.Env.t} on failure

get_organization_identity_provider(connection, organization_id, id, opts \\ [])

@spec get_organization_identity_provider(
  Tesla.Env.client(),
  String.t(),
  String.t(),
  keyword()
) ::
  {:ok, ExDaytona.Model.IdentityProvider.t()} | {:error, Tesla.Env.t()}

Get organization identity provider

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
id (String.t): Identity provider ID
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.IdentityProvider.t} on success
{:error, Tesla.Env.t} on failure

get_organization_invitations_count_for_authenticated_user(connection, opts \\ [])

@spec get_organization_invitations_count_for_authenticated_user(
  Tesla.Env.client(),
  keyword()
) :: {:ok, number()} | {:error, Tesla.Env.t()}

Get count of organization invitations for authenticated user

Parameters

connection (ExDaytona.Connection): Connection to server
opts (keyword): Optional parameters

Returns

{:ok, number()} on success
{:error, Tesla.Env.t} on failure

get_organization_otel_config(connection, organization_id, opts \\ [])

@spec get_organization_otel_config(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, ExDaytona.Model.OtelConfig.t()} | {:error, Tesla.Env.t()}

Get organization OTEL config by organization ID

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.OtelConfig.t} on success
{:error, Tesla.Env.t} on failure

get_organization_otel_config_by_sandbox_auth_token(connection, auth_token, opts \\ [])

@spec get_organization_otel_config_by_sandbox_auth_token(
  Tesla.Env.client(),
  String.t(),
  keyword()
) ::
  {:ok, ExDaytona.Model.OtelConfig.t()} | {:error, Tesla.Env.t()}

Get organization OTEL config by sandbox auth token

Parameters

connection (ExDaytona.Connection): Connection to server
auth_token (String.t): Sandbox Auth Token
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.OtelConfig.t} on success
{:error, Tesla.Env.t} on failure

get_organization_usage_overview(connection, organization_id, opts \\ [])

@spec get_organization_usage_overview(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, ExDaytona.Model.OrganizationUsageOverview.t()} | {:error, Tesla.Env.t()}

Get organization current usage overview

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.OrganizationUsageOverview.t} on success
{:error, Tesla.Env.t} on failure

get_region_by_id(connection, id, opts \\ [])

@spec get_region_by_id(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, ExDaytona.Model.Region.t()} | {:error, Tesla.Env.t()}

Get region by ID

Parameters

connection (ExDaytona.Connection): Connection to server
id (String.t): Region ID
opts (keyword): Optional parameters
- :"X-Daytona-Organization-ID" (String.t): Use with JWT to specify the organization ID

Returns

{:ok, ExDaytona.Model.Region.t} on success
{:error, Tesla.Env.t} on failure

leave_organization(connection, organization_id, opts \\ [])

@spec leave_organization(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Leave organization

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

list_available_regions(connection, opts \\ [])

@spec list_available_regions(
  Tesla.Env.client(),
  keyword()
) :: {:ok, [ExDaytona.Model.Region.t()]} | {:error, Tesla.Env.t()}

List all available regions for the organization

Parameters

connection (ExDaytona.Connection): Connection to server
opts (keyword): Optional parameters
- :"X-Daytona-Organization-ID" (String.t): Use with JWT to specify the organization ID

Returns

{:ok, [%Region{}, ...]} on success
{:error, Tesla.Env.t} on failure

list_available_sandbox_classes(connection, organization_id, opts \\ [])

@spec list_available_sandbox_classes(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, [ExDaytona.Model.AvailableSandboxClass.t()]} | {:error, Tesla.Env.t()}

List available sandbox classes for organization

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, [%AvailableSandboxClass{}, ...]} on success
{:error, Tesla.Env.t} on failure

list_organization_identity_providers(connection, organization_id, opts \\ [])

@spec list_organization_identity_providers(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, [ExDaytona.Model.IdentityProvider.t()]} | {:error, Tesla.Env.t()}

List organization identity providers

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, [%IdentityProvider{}, ...]} on success
{:error, Tesla.Env.t} on failure

list_organization_invitations(connection, organization_id, opts \\ [])

@spec list_organization_invitations(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, [ExDaytona.Model.OrganizationInvitation.t()]} | {:error, Tesla.Env.t()}

List pending organization invitations

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, [%OrganizationInvitation{}, ...]} on success
{:error, Tesla.Env.t} on failure

list_organization_invitations_for_authenticated_user(connection, opts \\ [])

@spec list_organization_invitations_for_authenticated_user(
  Tesla.Env.client(),
  keyword()
) ::
  {:ok, [ExDaytona.Model.OrganizationInvitation.t()]} | {:error, Tesla.Env.t()}

List organization invitations for authenticated user

Parameters

connection (ExDaytona.Connection): Connection to server
opts (keyword): Optional parameters

Returns

{:ok, [%OrganizationInvitation{}, ...]} on success
{:error, Tesla.Env.t} on failure

list_organization_members(connection, organization_id, opts \\ [])

@spec list_organization_members(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, [ExDaytona.Model.OrganizationUser.t()]} | {:error, Tesla.Env.t()}

List organization members

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, [%OrganizationUser{}, ...]} on success
{:error, Tesla.Env.t} on failure

list_organization_roles(connection, organization_id, opts \\ [])

@spec list_organization_roles(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, [ExDaytona.Model.OrganizationRole.t()]} | {:error, Tesla.Env.t()}

List organization roles

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, [%OrganizationRole{}, ...]} on success
{:error, Tesla.Env.t} on failure

list_organizations(connection, opts \\ [])

@spec list_organizations(
  Tesla.Env.client(),
  keyword()
) :: {:ok, [ExDaytona.Model.Organization.t()]} | {:error, Tesla.Env.t()}

List organizations

Parameters

connection (ExDaytona.Connection): Connection to server
opts (keyword): Optional parameters

Returns

{:ok, [%Organization{}, ...]} on success
{:error, Tesla.Env.t} on failure

regenerate_proxy_api_key(connection, id, opts \\ [])

@spec regenerate_proxy_api_key(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, ExDaytona.Model.RegenerateApiKeyResponse.t()} | {:error, Tesla.Env.t()}

Regenerate proxy API key for a region

Parameters

connection (ExDaytona.Connection): Connection to server
id (String.t): Region ID
opts (keyword): Optional parameters
- :"X-Daytona-Organization-ID" (String.t): Use with JWT to specify the organization ID

Returns

{:ok, ExDaytona.Model.RegenerateApiKeyResponse.t} on success
{:error, Tesla.Env.t} on failure

regenerate_snapshot_manager_credentials(connection, id, opts \\ [])

@spec regenerate_snapshot_manager_credentials(
  Tesla.Env.client(),
  String.t(),
  keyword()
) ::
  {:ok, ExDaytona.Model.SnapshotManagerCredentials.t()}
  | {:error, Tesla.Env.t()}

Regenerate snapshot manager credentials for a region

Parameters

connection (ExDaytona.Connection): Connection to server
id (String.t): Region ID
opts (keyword): Optional parameters
- :"X-Daytona-Organization-ID" (String.t): Use with JWT to specify the organization ID

Returns

{:ok, ExDaytona.Model.SnapshotManagerCredentials.t} on success
{:error, Tesla.Env.t} on failure

regenerate_ssh_gateway_api_key(connection, id, opts \\ [])

@spec regenerate_ssh_gateway_api_key(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, ExDaytona.Model.RegenerateApiKeyResponse.t()} | {:error, Tesla.Env.t()}

Regenerate SSH gateway API key for a region

Parameters

connection (ExDaytona.Connection): Connection to server
id (String.t): Region ID
opts (keyword): Optional parameters
- :"X-Daytona-Organization-ID" (String.t): Use with JWT to specify the organization ID

Returns

{:ok, ExDaytona.Model.RegenerateApiKeyResponse.t} on success
{:error, Tesla.Env.t} on failure

set_organization_default_region(connection, organization_id, update_organization_default_region, opts \\ [])

@spec set_organization_default_region(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.UpdateOrganizationDefaultRegion.t(),
  keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}

Set default region for organization

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
update_organization_default_region (UpdateOrganizationDefaultRegion):
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

suspend_organization(connection, organization_id, opts \\ [])

@spec suspend_organization(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Suspend organization

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters
- :body (OrganizationSuspension):

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

test_organization_identity_provider_connection(connection, organization_id, test_identity_provider_connection, opts \\ [])

@spec test_organization_identity_provider_connection(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.TestIdentityProviderConnection.t(),
  keyword()
) ::
  {:ok, ExDaytona.Model.TestIdentityProviderConnectionResponse.t()}
  | {:error, Tesla.Env.t()}

Test OIDC identity provider connection

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
test_identity_provider_connection (TestIdentityProviderConnection):
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.TestIdentityProviderConnectionResponse.t} on success
{:error, Tesla.Env.t} on failure

unsuspend_organization(connection, organization_id, opts \\ [])

@spec unsuspend_organization(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Unsuspend organization

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

update_access_for_organization_member(connection, organization_id, user_id, update_organization_member_access, opts \\ [])

@spec update_access_for_organization_member(
  Tesla.Env.client(),
  String.t(),
  String.t(),
  ExDaytona.Model.UpdateOrganizationMemberAccess.t(),
  keyword()
) :: {:ok, ExDaytona.Model.OrganizationUser.t()} | {:error, Tesla.Env.t()}

Update access for organization member

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
user_id (String.t): User ID
update_organization_member_access (UpdateOrganizationMemberAccess):
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.OrganizationUser.t} on success
{:error, Tesla.Env.t} on failure

update_experimental_config(connection, organization_id, opts \\ [])

@spec update_experimental_config(Tesla.Env.client(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Update experimental configuration

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
opts (keyword): Optional parameters
- :body (%{optional(String.t) => any()}): Experimental configuration as a JSON object. Set to null to clear the configuration.

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

update_organization_identity_provider(connection, organization_id, id, update_identity_provider, opts \\ [])

@spec update_organization_identity_provider(
  Tesla.Env.client(),
  String.t(),
  String.t(),
  ExDaytona.Model.UpdateIdentityProvider.t(),
  keyword()
) :: {:ok, ExDaytona.Model.IdentityProvider.t()} | {:error, Tesla.Env.t()}

Update organization identity provider

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
id (String.t): Identity provider ID
update_identity_provider (UpdateIdentityProvider):
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.IdentityProvider.t} on success
{:error, Tesla.Env.t} on failure

update_organization_invitation(connection, organization_id, invitation_id, update_organization_invitation, opts \\ [])

@spec update_organization_invitation(
  Tesla.Env.client(),
  String.t(),
  String.t(),
  ExDaytona.Model.UpdateOrganizationInvitation.t(),
  keyword()
) :: {:ok, ExDaytona.Model.OrganizationInvitation.t()} | {:error, Tesla.Env.t()}

Update organization invitation

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
invitation_id (String.t): Invitation ID
update_organization_invitation (UpdateOrganizationInvitation):
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.OrganizationInvitation.t} on success
{:error, Tesla.Env.t} on failure

update_organization_otel_config(connection, organization_id, otel_config, opts \\ [])

@spec update_organization_otel_config(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.OtelConfig.t(),
  keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}

Update organization OpenTelemetry configuration

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
otel_config (OtelConfig):
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

update_organization_preview_warning(connection, organization_id, organization_preview_warning, opts \\ [])

@spec update_organization_preview_warning(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.OrganizationPreviewWarning.t(),
  keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}

Update organization preview warning

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
organization_preview_warning (OrganizationPreviewWarning):
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

update_organization_quota(connection, organization_id, update_organization_quota, opts \\ [])

@spec update_organization_quota(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.UpdateOrganizationQuota.t(),
  keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}

Update organization quota

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
update_organization_quota (UpdateOrganizationQuota):
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

update_organization_region_quota(connection, organization_id, region_id, update_organization_region_quota, opts \\ [])

@spec update_organization_region_quota(
  Tesla.Env.client(),
  String.t(),
  String.t(),
  ExDaytona.Model.UpdateOrganizationRegionQuota.t(),
  keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}

Update organization region quota

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
region_id (String.t): ID of the region where the updated quota will be applied
update_organization_region_quota (UpdateOrganizationRegionQuota):
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

update_organization_role(connection, organization_id, role_id, update_organization_role, opts \\ [])

@spec update_organization_role(
  Tesla.Env.client(),
  String.t(),
  String.t(),
  ExDaytona.Model.UpdateOrganizationRole.t(),
  keyword()
) :: {:ok, ExDaytona.Model.OrganizationRole.t()} | {:error, Tesla.Env.t()}

Update organization role

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
role_id (String.t): Role ID
update_organization_role (UpdateOrganizationRole):
opts (keyword): Optional parameters

Returns

{:ok, ExDaytona.Model.OrganizationRole.t} on success
{:error, Tesla.Env.t} on failure

update_organization_sso_enabled(connection, organization_id, organization_sso_enabled, opts \\ [])

@spec update_organization_sso_enabled(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.OrganizationSsoEnabled.t(),
  keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}

Update organization SSO entitlement

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
organization_sso_enabled (OrganizationSsoEnabled):
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

update_region(connection, id, update_region, opts \\ [])

@spec update_region(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.UpdateRegion.t(),
  keyword()
) ::
  {:ok, nil} | {:error, Tesla.Env.t()}

Update region configuration

Parameters

connection (ExDaytona.Connection): Connection to server
id (String.t): Region ID
update_region (UpdateRegion):
opts (keyword): Optional parameters
- :"X-Daytona-Organization-ID" (String.t): Use with JWT to specify the organization ID

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure

update_sandbox_default_limited_network_egress(connection, organization_id, organization_sandbox_default_limited_network_egress, opts \\ [])

@spec update_sandbox_default_limited_network_egress(
  Tesla.Env.client(),
  String.t(),
  ExDaytona.Model.OrganizationSandboxDefaultLimitedNetworkEgress.t(),
  keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}

Update sandbox default limited network egress

Parameters

connection (ExDaytona.Connection): Connection to server
organization_id (String.t): Organization ID
organization_sandbox_default_limited_network_egress (OrganizationSandboxDefaultLimitedNetworkEgress):
opts (keyword): Optional parameters

Returns

{:ok, nil} on success
{:error, Tesla.Env.t} on failure