blaxel 0.2.34__py3-none-any.whl → 0.2.35__py3-none-any.whl

blaxel/core/client/models/agent_runtime.py

@@ -0,0 +1,139 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.agent_runtime_generation import AgentRuntimeGeneration
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.env import Env
+
+
+T = TypeVar("T", bound="AgentRuntime")
+
+
+@_attrs_define
+class AgentRuntime:
+    """Runtime configuration defining how the AI agent is deployed and scaled globally
+
+    Attributes:
+        envs (Union[Unset, list['Env']]): Environment variables injected into the agent. Supports Kubernetes EnvVar
+            format with valueFrom references.
+        generation (Union[Unset, AgentRuntimeGeneration]): Infrastructure generation: mk2 (containers, 2-10s cold
+            starts, 15+ global regions) or mk3 (microVMs, sub-25ms cold starts) Example: mk3.
+        image (Union[Unset, str]): Container image built by Blaxel when deploying with 'bl deploy'. This field is auto-
+            populated during deployment.
+        max_scale (Union[Unset, int]): Maximum number of concurrent agent instances for auto-scaling under load Example:
+            10.
+        memory (Union[Unset, int]): Memory allocation in megabytes. Also determines CPU allocation (CPU cores = memory
+            in MB / 2048, e.g., 4096MB = 2 CPUs). Example: 2048.
+        min_scale (Union[Unset, int]): Minimum instances to keep warm. Set to 1+ to eliminate cold starts, 0 for scale-
+            to-zero.
+    """
+
+    envs: Union[Unset, list["Env"]] = UNSET
+    generation: Union[Unset, AgentRuntimeGeneration] = UNSET
+    image: Union[Unset, str] = UNSET
+    max_scale: Union[Unset, int] = UNSET
+    memory: Union[Unset, int] = UNSET
+    min_scale: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        envs: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.envs, Unset):
+            envs = []
+            for envs_item_data in self.envs:
+                if type(envs_item_data) is dict:
+                    envs_item = envs_item_data
+                else:
+                    envs_item = envs_item_data.to_dict()
+                envs.append(envs_item)
+
+        generation: Union[Unset, str] = UNSET
+        if not isinstance(self.generation, Unset):
+            generation = self.generation.value
+
+        image = self.image
+
+        max_scale = self.max_scale
+
+        memory = self.memory
+
+        min_scale = self.min_scale
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if envs is not UNSET:
+            field_dict["envs"] = envs
+        if generation is not UNSET:
+            field_dict["generation"] = generation
+        if image is not UNSET:
+            field_dict["image"] = image
+        if max_scale is not UNSET:
+            field_dict["maxScale"] = max_scale
+        if memory is not UNSET:
+            field_dict["memory"] = memory
+        if min_scale is not UNSET:
+            field_dict["minScale"] = min_scale
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
+        from ..models.env import Env
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        envs = []
+        _envs = d.pop("envs", UNSET)
+        for envs_item_data in _envs or []:
+            envs_item = Env.from_dict(envs_item_data)
+
+            envs.append(envs_item)
+
+        _generation = d.pop("generation", UNSET)
+        generation: Union[Unset, AgentRuntimeGeneration]
+        if isinstance(_generation, Unset):
+            generation = UNSET
+        else:
+            generation = AgentRuntimeGeneration(_generation)
+
+        image = d.pop("image", UNSET)
+
+        max_scale = d.pop("maxScale", d.pop("max_scale", UNSET))
+
+        memory = d.pop("memory", UNSET)
+
+        min_scale = d.pop("minScale", d.pop("min_scale", UNSET))
+
+        agent_runtime = cls(
+            envs=envs,
+            generation=generation,
+            image=image,
+            max_scale=max_scale,
+            memory=memory,
+            min_scale=min_scale,
+        )
+
+        agent_runtime.additional_properties = d
+        return agent_runtime
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/core/client/models/agent_runtime_generation.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class AgentRuntimeGeneration(str, Enum):
+    MK2 = "mk2"
+    MK3 = "mk3"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "AgentRuntimeGeneration | None":
+        if isinstance(value, str):
+            upper_value = value.upper()
+            for member in cls:
+                if member.value.upper() == upper_value:
+                    return member
+        return None

blaxel/core/client/models/agent_spec.py

@@ -6,11 +6,9 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
-    from ..models.core_spec_configurations import CoreSpecConfigurations
-    from ..models.flavor import Flavor
+    from ..models.agent_runtime import AgentRuntime
     from ..models.repository import Repository
     from ..models.revision_configuration import RevisionConfiguration
-    from ..models.runtime import Runtime
     from ..models.trigger import Trigger
 
 
@@ -19,66 +17,44 @@ T = TypeVar("T", bound="AgentSpec")
 
 @_attrs_define
 class AgentSpec:
-    """Agent specification
+    """Configuration for an AI agent including runtime settings, repository source, and deployment triggers
 
     Attributes:
-        configurations (Union[Unset, CoreSpecConfigurations]): Optional configurations for the object
-        enabled (Union[Unset, bool]): Enable or disable the resource
-        flavors (Union[Unset, list['Flavor']]): Types of hardware available for deployments
-        integration_connections (Union[Unset, list[str]]):
+        enabled (Union[Unset, bool]): When false, the agent is disabled and will not serve inference requests Default:
+            True. Example: True.
         policies (Union[Unset, list[str]]):
-        revision (Union[Unset, RevisionConfiguration]): Revision configuration
-        runtime (Union[Unset, Runtime]): Set of configurations for a deployment
-        sandbox (Union[Unset, bool]): Sandbox mode
-        description (Union[Unset, str]): Description, small description computed from the prompt
         repository (Union[Unset, Repository]): Repository
+        revision (Union[Unset, RevisionConfiguration]): Revision configuration
+        runtime (Union[Unset, AgentRuntime]): Runtime configuration defining how the AI agent is deployed and scaled
+            globally
         triggers (Union[Unset, list['Trigger']]): Triggers to use your agent
     """
 
-    configurations: Union[Unset, "CoreSpecConfigurations"] = UNSET
-    enabled: Union[Unset, bool] = UNSET
-    flavors: Union[Unset, list["Flavor"]] = UNSET
-    integration_connections: Union[Unset, list[str]] = UNSET
+    enabled: Union[Unset, bool] = True
     policies: Union[Unset, list[str]] = UNSET
-    revision: Union[Unset, "RevisionConfiguration"] = UNSET
-    runtime: Union[Unset, "Runtime"] = UNSET
-    sandbox: Union[Unset, bool] = UNSET
-    description: Union[Unset, str] = UNSET
     repository: Union[Unset, "Repository"] = UNSET
+    revision: Union[Unset, "RevisionConfiguration"] = UNSET
+    runtime: Union[Unset, "AgentRuntime"] = UNSET
     triggers: Union[Unset, list["Trigger"]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        configurations: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.configurations
-            and not isinstance(self.configurations, Unset)
-            and not isinstance(self.configurations, dict)
-        ):
-            configurations = self.configurations.to_dict()
-        elif self.configurations and isinstance(self.configurations, dict):
-            configurations = self.configurations
-
         enabled = self.enabled
 
-        flavors: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.flavors, Unset):
-            flavors = []
-            for componentsschemas_flavors_item_data in self.flavors:
-                if type(componentsschemas_flavors_item_data) is dict:
-                    componentsschemas_flavors_item = componentsschemas_flavors_item_data
-                else:
-                    componentsschemas_flavors_item = componentsschemas_flavors_item_data.to_dict()
-                flavors.append(componentsschemas_flavors_item)
-
-        integration_connections: Union[Unset, list[str]] = UNSET
-        if not isinstance(self.integration_connections, Unset):
-            integration_connections = self.integration_connections
-
         policies: Union[Unset, list[str]] = UNSET
         if not isinstance(self.policies, Unset):
             policies = self.policies
 
+        repository: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.repository
+            and not isinstance(self.repository, Unset)
+            and not isinstance(self.repository, dict)
+        ):
+            repository = self.repository.to_dict()
+        elif self.repository and isinstance(self.repository, dict):
+            repository = self.repository
+
         revision: Union[Unset, dict[str, Any]] = UNSET
         if (
             self.revision
@@ -99,20 +75,6 @@ class AgentSpec:
         elif self.runtime and isinstance(self.runtime, dict):
             runtime = self.runtime
 
-        sandbox = self.sandbox
-
-        description = self.description
-
-        repository: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.repository
-            and not isinstance(self.repository, Unset)
-            and not isinstance(self.repository, dict)
-        ):
-            repository = self.repository.to_dict()
-        elif self.repository and isinstance(self.repository, dict):
-            repository = self.repository
-
         triggers: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.triggers, Unset):
             triggers = []
@@ -126,26 +88,16 @@ class AgentSpec:
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
-        if configurations is not UNSET:
-            field_dict["configurations"] = configurations
         if enabled is not UNSET:
             field_dict["enabled"] = enabled
-        if flavors is not UNSET:
-            field_dict["flavors"] = flavors
-        if integration_connections is not UNSET:
-            field_dict["integrationConnections"] = integration_connections
         if policies is not UNSET:
             field_dict["policies"] = policies
+        if repository is not UNSET:
+            field_dict["repository"] = repository
         if revision is not UNSET:
             field_dict["revision"] = revision
         if runtime is not UNSET:
             field_dict["runtime"] = runtime
-        if sandbox is not UNSET:
-            field_dict["sandbox"] = sandbox
-        if description is not UNSET:
-            field_dict["description"] = description
-        if repository is not UNSET:
-            field_dict["repository"] = repository
         if triggers is not UNSET:
             field_dict["triggers"] = triggers
 
@@ -153,38 +105,25 @@ class AgentSpec:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.core_spec_configurations import CoreSpecConfigurations
-        from ..models.flavor import Flavor
+        from ..models.agent_runtime import AgentRuntime
         from ..models.repository import Repository
         from ..models.revision_configuration import RevisionConfiguration
-        from ..models.runtime import Runtime
         from ..models.trigger import Trigger
 
         if not src_dict:
             return None
         d = src_dict.copy()
-        _configurations = d.pop("configurations", UNSET)
-        configurations: Union[Unset, CoreSpecConfigurations]
-        if isinstance(_configurations, Unset):
-            configurations = UNSET
-        else:
-            configurations = CoreSpecConfigurations.from_dict(_configurations)
-
         enabled = d.pop("enabled", UNSET)
 
-        flavors = []
-        _flavors = d.pop("flavors", UNSET)
-        for componentsschemas_flavors_item_data in _flavors or []:
-            componentsschemas_flavors_item = Flavor.from_dict(componentsschemas_flavors_item_data)
-
-            flavors.append(componentsschemas_flavors_item)
-
-        integration_connections = cast(
-            list[str], d.pop("integrationConnections", d.pop("integration_connections", UNSET))
-        )
-
         policies = cast(list[str], d.pop("policies", UNSET))
 
+        _repository = d.pop("repository", UNSET)
+        repository: Union[Unset, Repository]
+        if isinstance(_repository, Unset):
+            repository = UNSET
+        else:
+            repository = Repository.from_dict(_repository)
+
         _revision = d.pop("revision", UNSET)
         revision: Union[Unset, RevisionConfiguration]
         if isinstance(_revision, Unset):
@@ -193,22 +132,11 @@ class AgentSpec:
             revision = RevisionConfiguration.from_dict(_revision)
 
         _runtime = d.pop("runtime", UNSET)
-        runtime: Union[Unset, Runtime]
+        runtime: Union[Unset, AgentRuntime]
         if isinstance(_runtime, Unset):
             runtime = UNSET
         else:
-            runtime = Runtime.from_dict(_runtime)
-
-        sandbox = d.pop("sandbox", UNSET)
-
-        description = d.pop("description", UNSET)
-
-        _repository = d.pop("repository", UNSET)
-        repository: Union[Unset, Repository]
-        if isinstance(_repository, Unset):
-            repository = UNSET
-        else:
-            repository = Repository.from_dict(_repository)
+            runtime = AgentRuntime.from_dict(_runtime)
 
         triggers = []
         _triggers = d.pop("triggers", UNSET)
@@ -220,16 +148,11 @@ class AgentSpec:
             triggers.append(componentsschemas_triggers_item)
 
         agent_spec = cls(
-            configurations=configurations,
             enabled=enabled,
-            flavors=flavors,
-            integration_connections=integration_connections,
             policies=policies,
+            repository=repository,
             revision=revision,
             runtime=runtime,
-            sandbox=sandbox,
-            description=description,
-            repository=repository,
             triggers=triggers,
         )
 

blaxel/core/client/models/api_key.py

@@ -18,11 +18,12 @@ class ApiKey:
         created_by (Union[Unset, str]): The user or service account who created the resource
         updated_by (Union[Unset, str]): The user or service account who updated the resource
         api_key (Union[Unset, str]): Api key
-        expires_in (Union[Unset, str]): Duration until expiration (in seconds)
-        id (Union[Unset, str]): Api key id, to retrieve it from the API
-        name (Union[Unset, str]): Name for the API key
+        expires_in (Union[Unset, str]): Duration until expiration. Supports formats like '30d' (30 days), '24h' (24
+            hours), '1w' (1 week). If not set, the API key never expires. Example: 30d.
+        id (Union[Unset, str]): Api key id, to retrieve it from the API Example: ak_abc123def456.
+        name (Union[Unset, str]): Name for the API key Example: CI/CD Pipeline Key.
         sub (Union[Unset, str]): User subject identifier
-        sub_type (Union[Unset, str]): Subject type
+        sub_type (Union[Unset, str]): Subject type (user or service_account) Example: user.
     """
 
     created_at: Union[Unset, str] = UNSET

blaxel/core/client/models/core_event.py

@@ -14,11 +14,11 @@ class CoreEvent:
 
     Attributes:
         canary_revision (Union[Unset, str]): Canary revisionID link to the event
-        message (Union[Unset, str]): Event message
-        revision (Union[Unset, str]): RevisionID link to the event
-        status (Union[Unset, str]): Event status
-        time (Union[Unset, str]): Event time
-        type_ (Union[Unset, str]): Event type
+        message (Union[Unset, str]): Event message Example: Deployment successful.
+        revision (Union[Unset, str]): RevisionID link to the event Example: rev-abc123.
+        status (Union[Unset, str]): Event status Example: DEPLOYED.
+        time (Union[Unset, str]): Event time Example: 2025-01-15T10:30:00Z.
+        type_ (Union[Unset, str]): Event type Example: deployment.
     """
 
     canary_revision: Union[Unset, str] = UNSET

blaxel/core/client/models/create_api_key_for_service_account_body.py

@@ -12,7 +12,8 @@ T = TypeVar("T", bound="CreateApiKeyForServiceAccountBody")
 class CreateApiKeyForServiceAccountBody:
     """
     Attributes:
-        expires_in (Union[Unset, str]): Expiration period for the API key
+        expires_in (Union[Unset, str]): Expiration period for the API key. Supports formats like '30d' (30 days), '24h'
+            (24 hours), '1w' (1 week). If not set, the API key never expires.
         name (Union[Unset, str]): Name for the API key
     """
 

blaxel/core/client/models/create_job_execution_request.py

@@ -19,7 +19,7 @@ class CreateJobExecutionRequest:
     Attributes:
         execution_id (Union[Unset, str]): Execution ID (optional, will be generated if not provided)
         id (Union[Unset, str]): Unique message ID
-        job_id (Union[Unset, str]): Job ID
+        job_id (Union[Unset, str]): Job ID Example: data-processing-job.
         tasks (Union[Unset, list['CreateJobExecutionRequestTasksItem']]): Array of task parameters for parallel
             execution
         workspace_id (Union[Unset, str]): Workspace ID

blaxel/core/client/models/create_job_execution_response.py

@@ -16,15 +16,19 @@ T = TypeVar("T", bound="CreateJobExecutionResponse")
 
 @_attrs_define
 class CreateJobExecutionResponse:
-    """Response for creating a job execution
-
-    Attributes:
-        execution_id (Union[Unset, str]): Execution ID
-        id (Union[Unset, str]): Unique message ID
-        job_id (Union[Unset, str]): Job ID
-        tasks (Union[Unset, list['CreateJobExecutionResponseTasksItem']]): Array of task parameters for parallel
-            execution
-        workspace_id (Union[Unset, str]): Workspace ID
+    """Response returned when a job execution is successfully created. Contains identifiers and the tasks that will be
+    executed.
+
+        Attributes:
+            execution_id (Union[Unset, str]): Unique identifier for the created execution. Use this ID to track execution
+                status, retrieve logs, or cancel the execution. Example: exec-abc123.
+            id (Union[Unset, str]): Unique identifier for this request, used for idempotency and tracking. Auto-generated if
+                not provided in the request. Example: 550e8400-e29b-41d4-a716-446655440000.
+            job_id (Union[Unset, str]): Name of the job that this execution belongs to Example: data-processing-job.
+            tasks (Union[Unset, list['CreateJobExecutionResponseTasksItem']]): Array of task configurations that will be
+                executed in parallel according to the job's concurrency settings. Each task can have custom parameters.
+            workspace_id (Union[Unset, str]): Name of the workspace where the job execution was created Example: my-
+                workspace.
     """
 
     execution_id: Union[Unset, str] = UNSET

blaxel/core/client/models/custom_domain.py

@@ -1,10 +1,8 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..types import UNSET, Unset
-
 if TYPE_CHECKING:
     from ..models.custom_domain_metadata import CustomDomainMetadata
     from ..models.custom_domain_spec import CustomDomainSpec
@@ -21,38 +19,33 @@ class CustomDomain:
     <preview-id>.preview.<base-domain> (e.g., abc123.preview.example.com)
 
         Attributes:
-            metadata (Union[Unset, CustomDomainMetadata]): Custom domain metadata
-            spec (Union[Unset, CustomDomainSpec]): Custom domain specification
+            metadata (CustomDomainMetadata): Custom domain metadata
+            spec (CustomDomainSpec): Custom domain specification
     """
 
-    metadata: Union[Unset, "CustomDomainMetadata"] = UNSET
-    spec: Union[Unset, "CustomDomainSpec"] = UNSET
+    metadata: "CustomDomainMetadata"
+    spec: "CustomDomainSpec"
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        metadata: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.metadata
-            and not isinstance(self.metadata, Unset)
-            and not isinstance(self.metadata, dict)
-        ):
-            metadata = self.metadata.to_dict()
-        elif self.metadata and isinstance(self.metadata, dict):
+        if type(self.metadata) is dict:
             metadata = self.metadata
+        else:
+            metadata = self.metadata.to_dict()
 
-        spec: Union[Unset, dict[str, Any]] = UNSET
-        if self.spec and not isinstance(self.spec, Unset) and not isinstance(self.spec, dict):
-            spec = self.spec.to_dict()
-        elif self.spec and isinstance(self.spec, dict):
+        if type(self.spec) is dict:
             spec = self.spec
+        else:
+            spec = self.spec.to_dict()
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if metadata is not UNSET:
-            field_dict["metadata"] = metadata
-        if spec is not UNSET:
-            field_dict["spec"] = spec
+        field_dict.update(
+            {
+                "metadata": metadata,
+                "spec": spec,
+            }
+        )
 
         return field_dict
 
@@ -64,19 +57,9 @@ class CustomDomain:
         if not src_dict:
             return None
         d = src_dict.copy()
-        _metadata = d.pop("metadata", UNSET)
-        metadata: Union[Unset, CustomDomainMetadata]
-        if isinstance(_metadata, Unset):
-            metadata = UNSET
-        else:
-            metadata = CustomDomainMetadata.from_dict(_metadata)
+        metadata = CustomDomainMetadata.from_dict(d.pop("metadata"))
 
-        _spec = d.pop("spec", UNSET)
-        spec: Union[Unset, CustomDomainSpec]
-        if isinstance(_spec, Unset):
-            spec = UNSET
-        else:
-            spec = CustomDomainSpec.from_dict(_spec)
+        spec = CustomDomainSpec.from_dict(d.pop("spec"))
 
         custom_domain = cls(
             metadata=metadata,

blaxel/core/client/models/custom_domain_metadata.py

@@ -21,9 +21,10 @@ class CustomDomainMetadata:
         updated_at (Union[Unset, str]): The date and time when the resource was updated
         created_by (Union[Unset, str]): The user or service account who created the resource
         updated_by (Union[Unset, str]): The user or service account who updated the resource
-        display_name (Union[Unset, str]): Display name for the custom domain
-        labels (Union[Unset, MetadataLabels]): Labels
-        name (Union[Unset, str]): Domain name (e.g., "example.com")
+        display_name (Union[Unset, str]): Display name for the custom domain Example: Preview Domain.
+        labels (Union[Unset, MetadataLabels]): Key-value pairs for organizing and filtering resources. Labels can be
+            used to categorize resources by environment, project, team, or any custom taxonomy.
+        name (Union[Unset, str]): Domain name (e.g., "example.com") Example: preview.example.com.
         workspace (Union[Unset, str]): Workspace name
     """
 

blaxel/core/client/models/custom_domain_spec.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, TypeVar, Union
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.custom_domain_spec_status import CustomDomainSpecStatus
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
@@ -19,8 +20,9 @@ class CustomDomainSpec:
     Attributes:
         cname_records (Union[Unset, str]): CNAME target for the domain
         last_verified_at (Union[Unset, str]): Last verification attempt timestamp
-        region (Union[Unset, str]): Region that the custom domain is associated with
-        status (Union[Unset, str]): Current status of the domain (pending, verified, failed)
+        region (Union[Unset, str]): Region that the custom domain is associated with Example: us-pdx-1.
+        status (Union[Unset, CustomDomainSpecStatus]): Current status of the domain (pending, verified, failed) Example:
+            verified.
         txt_records (Union[Unset, CustomDomainSpecTxtRecords]): Map of TXT record names to values for domain
             verification
         verification_error (Union[Unset, str]): Error message if verification failed
@@ -29,7 +31,7 @@ class CustomDomainSpec:
     cname_records: Union[Unset, str] = UNSET
     last_verified_at: Union[Unset, str] = UNSET
     region: Union[Unset, str] = UNSET
-    status: Union[Unset, str] = UNSET
+    status: Union[Unset, CustomDomainSpecStatus] = UNSET
     txt_records: Union[Unset, "CustomDomainSpecTxtRecords"] = UNSET
     verification_error: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -41,7 +43,9 @@ class CustomDomainSpec:
 
         region = self.region
 
-        status = self.status
+        status: Union[Unset, str] = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
 
         txt_records: Union[Unset, dict[str, Any]] = UNSET
         if (
@@ -86,7 +90,12 @@ class CustomDomainSpec:
 
         region = d.pop("region", UNSET)
 
-        status = d.pop("status", UNSET)
+        _status = d.pop("status", UNSET)
+        status: Union[Unset, CustomDomainSpecStatus]
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = CustomDomainSpecStatus(_status)
 
         _txt_records = d.pop("txtRecords", d.pop("txt_records", UNSET))
         txt_records: Union[Unset, CustomDomainSpecTxtRecords]

blaxel/core/client/models/custom_domain_spec_status.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class CustomDomainSpecStatus(str, Enum):
+    FAILED = "failed"
+    PENDING = "pending"
+    VERIFIED = "verified"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "CustomDomainSpecStatus | None":
+        if isinstance(value, str):
+            upper_value = value.upper()
+            for member in cls:
+                if member.value.upper() == upper_value:
+                    return member
+        return None