waldur-api-client 7.8.3__py3-none-any.whl → 7.8.5__py3-none-any.whl

waldur_api_client/models/onboarding_justification_documentation_request_multipart.py

@@ -0,0 +1,98 @@
+from collections.abc import Mapping
+from io import BytesIO
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from .. import types
+from ..types import UNSET, File, Unset
+
+T = TypeVar("T", bound="OnboardingJustificationDocumentationRequestMultipart")
+
+
+@_attrs_define
+class OnboardingJustificationDocumentationRequestMultipart:
+    """
+    Attributes:
+        file (Union[File, None, Unset]): Upload supporting documentation.
+    """
+
+    file: Union[File, None, Unset] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        file: Union[None, Unset, types.FileTypes]
+        if isinstance(self.file, Unset):
+            file = UNSET
+        elif isinstance(self.file, File):
+            file = self.file.to_tuple()
+
+        else:
+            file = self.file
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if file is not UNSET:
+            field_dict["file"] = file
+
+        return field_dict
+
+    def to_multipart(self) -> types.RequestFiles:
+        files: types.RequestFiles = []
+
+        if not isinstance(self.file, Unset):
+            if isinstance(self.file, File):
+                files.append(("file", self.file.to_tuple()))
+            else:
+                files.append(("file", (None, str(self.file).encode(), "text/plain")))
+
+        for prop_name, prop in self.additional_properties.items():
+            files.append((prop_name, (None, str(prop).encode(), "text/plain")))
+
+        return files
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_file(data: object) -> Union[File, None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, bytes):
+                    raise TypeError()
+                file_type_0 = File(payload=BytesIO(data))
+
+                return file_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[File, None, Unset], data)
+
+        file = _parse_file(d.pop("file", UNSET))
+
+        onboarding_justification_documentation_request_multipart = cls(
+            file=file,
+        )
+
+        onboarding_justification_documentation_request_multipart.additional_properties = d
+        return onboarding_justification_documentation_request_multipart
+
+    @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

waldur_api_client/models/onboarding_justification_request.py

@@ -0,0 +1,89 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OnboardingJustificationRequest")
+
+
+@_attrs_define
+class OnboardingJustificationRequest:
+    """
+    Attributes:
+        verification (int):
+        user (int):
+        user_justification (Union[None, Unset, str]): User's explanation for why they should be authorized
+    """
+
+    verification: int
+    user: int
+    user_justification: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        verification = self.verification
+
+        user = self.user
+
+        user_justification: Union[None, Unset, str]
+        if isinstance(self.user_justification, Unset):
+            user_justification = UNSET
+        else:
+            user_justification = self.user_justification
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "verification": verification,
+                "user": user,
+            }
+        )
+        if user_justification is not UNSET:
+            field_dict["user_justification"] = user_justification
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        verification = d.pop("verification")
+
+        user = d.pop("user")
+
+        def _parse_user_justification(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        user_justification = _parse_user_justification(d.pop("user_justification", UNSET))
+
+        onboarding_justification_request = cls(
+            verification=verification,
+            user=user,
+            user_justification=user_justification,
+        )
+
+        onboarding_justification_request.additional_properties = d
+        return onboarding_justification_request
+
+    @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

waldur_api_client/models/onboarding_justification_review_request.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OnboardingJustificationReviewRequest")
+
+
+@_attrs_define
+class OnboardingJustificationReviewRequest:
+    """
+    Attributes:
+        staff_notes (Union[Unset, str]): Administrator notes about the review decision
+    """
+
+    staff_notes: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        staff_notes = self.staff_notes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if staff_notes is not UNSET:
+            field_dict["staff_notes"] = staff_notes
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        staff_notes = d.pop("staff_notes", UNSET)
+
+        onboarding_justification_review_request = cls(
+            staff_notes=staff_notes,
+        )
+
+        onboarding_justification_review_request.additional_properties = d
+        return onboarding_justification_review_request
+
+    @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

waldur_api_client/models/onboarding_verification.py

@@ -0,0 +1,250 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.onboarding_verification_status_enum import OnboardingVerificationStatusEnum
+from ..models.validation_method_enum import ValidationMethodEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OnboardingVerification")
+
+
+@_attrs_define
+class OnboardingVerification:
+    """
+    Attributes:
+        uuid (UUID):
+        user (int): User requesting company onboarding
+        country (str): ISO country code (e.g., 'EE' for Estonia)
+        legal_person_identifier (str): Official company registration code
+        status (OnboardingVerificationStatusEnum):
+        validation_method (ValidationMethodEnum):
+        verified_user_roles (Any): Roles the user has in the company
+        verified_company_data (Any): Company information retrieved during validation
+        raw_response (Any): Raw API response for debugging and auditing
+        error_traceback (str):
+        error_message (str):
+        validated_at (Union[None, datetime.datetime]): When validation was completed
+        customer (Union[None, int]): Customer created after successful validation
+        created (datetime.datetime):
+        modified (datetime.datetime):
+        legal_name (Union[Unset, str]): Claimed company name (optional, for reference)
+        user_submitted_customer_metadata (Union[Unset, Any]): Additional customer metadata submitted by user for manual
+            verification cases. Should contain valid Customer model fields.
+        expires_at (Union[None, Unset, datetime.datetime]): When this verification expires
+    """
+
+    uuid: UUID
+    user: int
+    country: str
+    legal_person_identifier: str
+    status: OnboardingVerificationStatusEnum
+    validation_method: ValidationMethodEnum
+    verified_user_roles: Any
+    verified_company_data: Any
+    raw_response: Any
+    error_traceback: str
+    error_message: str
+    validated_at: Union[None, datetime.datetime]
+    customer: Union[None, int]
+    created: datetime.datetime
+    modified: datetime.datetime
+    legal_name: Union[Unset, str] = UNSET
+    user_submitted_customer_metadata: Union[Unset, Any] = UNSET
+    expires_at: Union[None, Unset, datetime.datetime] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid = str(self.uuid)
+
+        user = self.user
+
+        country = self.country
+
+        legal_person_identifier = self.legal_person_identifier
+
+        status = self.status.value
+
+        validation_method = self.validation_method.value
+
+        verified_user_roles = self.verified_user_roles
+
+        verified_company_data = self.verified_company_data
+
+        raw_response = self.raw_response
+
+        error_traceback = self.error_traceback
+
+        error_message = self.error_message
+
+        validated_at: Union[None, str]
+        if isinstance(self.validated_at, datetime.datetime):
+            validated_at = self.validated_at.isoformat()
+        else:
+            validated_at = self.validated_at
+
+        customer: Union[None, int]
+        customer = self.customer
+
+        created = self.created.isoformat()
+
+        modified = self.modified.isoformat()
+
+        legal_name = self.legal_name
+
+        user_submitted_customer_metadata = self.user_submitted_customer_metadata
+
+        expires_at: Union[None, Unset, str]
+        if isinstance(self.expires_at, Unset):
+            expires_at = UNSET
+        elif isinstance(self.expires_at, datetime.datetime):
+            expires_at = self.expires_at.isoformat()
+        else:
+            expires_at = self.expires_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuid": uuid,
+                "user": user,
+                "country": country,
+                "legal_person_identifier": legal_person_identifier,
+                "status": status,
+                "validation_method": validation_method,
+                "verified_user_roles": verified_user_roles,
+                "verified_company_data": verified_company_data,
+                "raw_response": raw_response,
+                "error_traceback": error_traceback,
+                "error_message": error_message,
+                "validated_at": validated_at,
+                "customer": customer,
+                "created": created,
+                "modified": modified,
+            }
+        )
+        if legal_name is not UNSET:
+            field_dict["legal_name"] = legal_name
+        if user_submitted_customer_metadata is not UNSET:
+            field_dict["user_submitted_customer_metadata"] = user_submitted_customer_metadata
+        if expires_at is not UNSET:
+            field_dict["expires_at"] = expires_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        uuid = UUID(d.pop("uuid"))
+
+        user = d.pop("user")
+
+        country = d.pop("country")
+
+        legal_person_identifier = d.pop("legal_person_identifier")
+
+        status = OnboardingVerificationStatusEnum(d.pop("status"))
+
+        validation_method = ValidationMethodEnum(d.pop("validation_method"))
+
+        verified_user_roles = d.pop("verified_user_roles")
+
+        verified_company_data = d.pop("verified_company_data")
+
+        raw_response = d.pop("raw_response")
+
+        error_traceback = d.pop("error_traceback")
+
+        error_message = d.pop("error_message")
+
+        def _parse_validated_at(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                validated_at_type_0 = isoparse(data)
+
+                return validated_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        validated_at = _parse_validated_at(d.pop("validated_at"))
+
+        def _parse_customer(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        customer = _parse_customer(d.pop("customer"))
+
+        created = isoparse(d.pop("created"))
+
+        modified = isoparse(d.pop("modified"))
+
+        legal_name = d.pop("legal_name", UNSET)
+
+        user_submitted_customer_metadata = d.pop("user_submitted_customer_metadata", UNSET)
+
+        def _parse_expires_at(data: object) -> Union[None, Unset, datetime.datetime]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                expires_at_type_0 = isoparse(data)
+
+                return expires_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.datetime], data)
+
+        expires_at = _parse_expires_at(d.pop("expires_at", UNSET))
+
+        onboarding_verification = cls(
+            uuid=uuid,
+            user=user,
+            country=country,
+            legal_person_identifier=legal_person_identifier,
+            status=status,
+            validation_method=validation_method,
+            verified_user_roles=verified_user_roles,
+            verified_company_data=verified_company_data,
+            raw_response=raw_response,
+            error_traceback=error_traceback,
+            error_message=error_message,
+            validated_at=validated_at,
+            customer=customer,
+            created=created,
+            modified=modified,
+            legal_name=legal_name,
+            user_submitted_customer_metadata=user_submitted_customer_metadata,
+            expires_at=expires_at,
+        )
+
+        onboarding_verification.additional_properties = d
+        return onboarding_verification
+
+    @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

waldur_api_client/models/onboarding_verification_request.py

@@ -0,0 +1,128 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="OnboardingVerificationRequest")
+
+
+@_attrs_define
+class OnboardingVerificationRequest:
+    """
+    Attributes:
+        user (int): User requesting company onboarding
+        country (str): ISO country code (e.g., 'EE' for Estonia)
+        legal_person_identifier (str): Official company registration code
+        legal_name (Union[Unset, str]): Claimed company name (optional, for reference)
+        user_submitted_customer_metadata (Union[Unset, Any]): Additional customer metadata submitted by user for manual
+            verification cases. Should contain valid Customer model fields.
+        expires_at (Union[None, Unset, datetime.datetime]): When this verification expires
+    """
+
+    user: int
+    country: str
+    legal_person_identifier: str
+    legal_name: Union[Unset, str] = UNSET
+    user_submitted_customer_metadata: Union[Unset, Any] = UNSET
+    expires_at: Union[None, Unset, datetime.datetime] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        user = self.user
+
+        country = self.country
+
+        legal_person_identifier = self.legal_person_identifier
+
+        legal_name = self.legal_name
+
+        user_submitted_customer_metadata = self.user_submitted_customer_metadata
+
+        expires_at: Union[None, Unset, str]
+        if isinstance(self.expires_at, Unset):
+            expires_at = UNSET
+        elif isinstance(self.expires_at, datetime.datetime):
+            expires_at = self.expires_at.isoformat()
+        else:
+            expires_at = self.expires_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "user": user,
+                "country": country,
+                "legal_person_identifier": legal_person_identifier,
+            }
+        )
+        if legal_name is not UNSET:
+            field_dict["legal_name"] = legal_name
+        if user_submitted_customer_metadata is not UNSET:
+            field_dict["user_submitted_customer_metadata"] = user_submitted_customer_metadata
+        if expires_at is not UNSET:
+            field_dict["expires_at"] = expires_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        user = d.pop("user")
+
+        country = d.pop("country")
+
+        legal_person_identifier = d.pop("legal_person_identifier")
+
+        legal_name = d.pop("legal_name", UNSET)
+
+        user_submitted_customer_metadata = d.pop("user_submitted_customer_metadata", UNSET)
+
+        def _parse_expires_at(data: object) -> Union[None, Unset, datetime.datetime]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                expires_at_type_0 = isoparse(data)
+
+                return expires_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.datetime], data)
+
+        expires_at = _parse_expires_at(d.pop("expires_at", UNSET))
+
+        onboarding_verification_request = cls(
+            user=user,
+            country=country,
+            legal_person_identifier=legal_person_identifier,
+            legal_name=legal_name,
+            user_submitted_customer_metadata=user_submitted_customer_metadata,
+            expires_at=expires_at,
+        )
+
+        onboarding_verification_request.additional_properties = d
+        return onboarding_verification_request
+
+    @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

waldur_api_client/models/onboarding_verification_status_enum.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class OnboardingVerificationStatusEnum(str, Enum):
+    ESCALATED = "escalated"
+    EXPIRED = "expired"
+    FAILED = "failed"
+    PENDING = "pending"
+    VERIFIED = "verified"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/open_stack_create_floating_ip_request.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union
+from typing import Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -15,10 +15,13 @@ class OpenStackCreateFloatingIPRequest:
     Attributes:
         subnet (str):
         url (Union[Unset, str]):
+        ip_address (Union[Unset, str]): Existing floating IP address in selected OpenStack tenant to be assigned to new
+            virtual machine
     """
 
     subnet: str
     url: Union[Unset, str] = UNSET
+    ip_address: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -26,6 +29,12 @@ class OpenStackCreateFloatingIPRequest:
 
         url = self.url
 
+        ip_address: Union[Unset, str]
+        if isinstance(self.ip_address, Unset):
+            ip_address = UNSET
+        else:
+            ip_address = self.ip_address
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -35,6 +44,8 @@ class OpenStackCreateFloatingIPRequest:
         )
         if url is not UNSET:
             field_dict["url"] = url
+        if ip_address is not UNSET:
+            field_dict["ip_address"] = ip_address
 
         return field_dict
 
@@ -45,9 +56,17 @@ class OpenStackCreateFloatingIPRequest:
 
         url = d.pop("url", UNSET)
 
+        def _parse_ip_address(data: object) -> Union[Unset, str]:
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[Unset, str], data)
+
+        ip_address = _parse_ip_address(d.pop("ip_address", UNSET))
+
         open_stack_create_floating_ip_request = cls(
             subnet=subnet,
             url=url,
+            ip_address=ip_address,
         )
 
         open_stack_create_floating_ip_request.additional_properties = d