waldur-api-client 7.7.7__py3-none-any.whl → 7.7.8__py3-none-any.whl

waldur_api_client/models/managed_rancher_cluster_resources_list_field_item.py

@@ -0,0 +1,82 @@
+from enum import Enum
+
+
+class ManagedRancherClusterResourcesListFieldItem(str, Enum):
+    ATTRIBUTES = "attributes"
+    AVAILABLE_ACTIONS = "available_actions"
+    BACKEND_ID = "backend_id"
+    BACKEND_METADATA = "backend_metadata"
+    CAN_TERMINATE = "can_terminate"
+    CATEGORY_ICON = "category_icon"
+    CATEGORY_TITLE = "category_title"
+    CATEGORY_UUID = "category_uuid"
+    CREATED = "created"
+    CREATION_ORDER = "creation_order"
+    CURRENT_USAGES = "current_usages"
+    CUSTOMER_NAME = "customer_name"
+    CUSTOMER_SLUG = "customer_slug"
+    CUSTOMER_UUID = "customer_uuid"
+    DESCRIPTION = "description"
+    DOWNSCALED = "downscaled"
+    EFFECTIVE_ID = "effective_id"
+    ENDPOINTS = "endpoints"
+    END_DATE = "end_date"
+    END_DATE_REQUESTED_BY = "end_date_requested_by"
+    ERROR_MESSAGE = "error_message"
+    ERROR_TRACEBACK = "error_traceback"
+    IS_LIMIT_BASED = "is_limit_based"
+    IS_USAGE_BASED = "is_usage_based"
+    LAST_SYNC = "last_sync"
+    LIMITS = "limits"
+    LIMIT_USAGE = "limit_usage"
+    MODIFIED = "modified"
+    NAME = "name"
+    OFFERING = "offering"
+    OFFERING_BILLABLE = "offering_billable"
+    OFFERING_CUSTOMER_UUID = "offering_customer_uuid"
+    OFFERING_DESCRIPTION = "offering_description"
+    OFFERING_IMAGE = "offering_image"
+    OFFERING_NAME = "offering_name"
+    OFFERING_PLUGIN_OPTIONS = "offering_plugin_options"
+    OFFERING_SHARED = "offering_shared"
+    OFFERING_SLUG = "offering_slug"
+    OFFERING_THUMBNAIL = "offering_thumbnail"
+    OFFERING_TYPE = "offering_type"
+    OFFERING_UUID = "offering_uuid"
+    OPTIONS = "options"
+    ORDER_IN_PROGRESS = "order_in_progress"
+    PARENT_NAME = "parent_name"
+    PARENT_OFFERING_NAME = "parent_offering_name"
+    PARENT_OFFERING_SLUG = "parent_offering_slug"
+    PARENT_OFFERING_UUID = "parent_offering_uuid"
+    PARENT_UUID = "parent_uuid"
+    PAUSED = "paused"
+    PLAN = "plan"
+    PLAN_DESCRIPTION = "plan_description"
+    PLAN_NAME = "plan_name"
+    PLAN_UNIT = "plan_unit"
+    PLAN_UUID = "plan_uuid"
+    PROJECT = "project"
+    PROJECT_DESCRIPTION = "project_description"
+    PROJECT_END_DATE = "project_end_date"
+    PROJECT_END_DATE_REQUESTED_BY = "project_end_date_requested_by"
+    PROJECT_NAME = "project_name"
+    PROJECT_SLUG = "project_slug"
+    PROJECT_UUID = "project_uuid"
+    PROVIDER_NAME = "provider_name"
+    PROVIDER_UUID = "provider_uuid"
+    REPORT = "report"
+    RESOURCE_TYPE = "resource_type"
+    RESOURCE_UUID = "resource_uuid"
+    RESTRICT_MEMBER_ACCESS = "restrict_member_access"
+    SCOPE = "scope"
+    SERVICE_SETTINGS_UUID = "service_settings_uuid"
+    SLUG = "slug"
+    STATE = "state"
+    URL = "url"
+    USERNAME = "username"
+    USER_REQUIRES_RECONSENT = "user_requires_reconsent"
+    UUID = "uuid"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/managed_rancher_cluster_resources_retrieve_field_item.py

@@ -0,0 +1,82 @@
+from enum import Enum
+
+
+class ManagedRancherClusterResourcesRetrieveFieldItem(str, Enum):
+    ATTRIBUTES = "attributes"
+    AVAILABLE_ACTIONS = "available_actions"
+    BACKEND_ID = "backend_id"
+    BACKEND_METADATA = "backend_metadata"
+    CAN_TERMINATE = "can_terminate"
+    CATEGORY_ICON = "category_icon"
+    CATEGORY_TITLE = "category_title"
+    CATEGORY_UUID = "category_uuid"
+    CREATED = "created"
+    CREATION_ORDER = "creation_order"
+    CURRENT_USAGES = "current_usages"
+    CUSTOMER_NAME = "customer_name"
+    CUSTOMER_SLUG = "customer_slug"
+    CUSTOMER_UUID = "customer_uuid"
+    DESCRIPTION = "description"
+    DOWNSCALED = "downscaled"
+    EFFECTIVE_ID = "effective_id"
+    ENDPOINTS = "endpoints"
+    END_DATE = "end_date"
+    END_DATE_REQUESTED_BY = "end_date_requested_by"
+    ERROR_MESSAGE = "error_message"
+    ERROR_TRACEBACK = "error_traceback"
+    IS_LIMIT_BASED = "is_limit_based"
+    IS_USAGE_BASED = "is_usage_based"
+    LAST_SYNC = "last_sync"
+    LIMITS = "limits"
+    LIMIT_USAGE = "limit_usage"
+    MODIFIED = "modified"
+    NAME = "name"
+    OFFERING = "offering"
+    OFFERING_BILLABLE = "offering_billable"
+    OFFERING_CUSTOMER_UUID = "offering_customer_uuid"
+    OFFERING_DESCRIPTION = "offering_description"
+    OFFERING_IMAGE = "offering_image"
+    OFFERING_NAME = "offering_name"
+    OFFERING_PLUGIN_OPTIONS = "offering_plugin_options"
+    OFFERING_SHARED = "offering_shared"
+    OFFERING_SLUG = "offering_slug"
+    OFFERING_THUMBNAIL = "offering_thumbnail"
+    OFFERING_TYPE = "offering_type"
+    OFFERING_UUID = "offering_uuid"
+    OPTIONS = "options"
+    ORDER_IN_PROGRESS = "order_in_progress"
+    PARENT_NAME = "parent_name"
+    PARENT_OFFERING_NAME = "parent_offering_name"
+    PARENT_OFFERING_SLUG = "parent_offering_slug"
+    PARENT_OFFERING_UUID = "parent_offering_uuid"
+    PARENT_UUID = "parent_uuid"
+    PAUSED = "paused"
+    PLAN = "plan"
+    PLAN_DESCRIPTION = "plan_description"
+    PLAN_NAME = "plan_name"
+    PLAN_UNIT = "plan_unit"
+    PLAN_UUID = "plan_uuid"
+    PROJECT = "project"
+    PROJECT_DESCRIPTION = "project_description"
+    PROJECT_END_DATE = "project_end_date"
+    PROJECT_END_DATE_REQUESTED_BY = "project_end_date_requested_by"
+    PROJECT_NAME = "project_name"
+    PROJECT_SLUG = "project_slug"
+    PROJECT_UUID = "project_uuid"
+    PROVIDER_NAME = "provider_name"
+    PROVIDER_UUID = "provider_uuid"
+    REPORT = "report"
+    RESOURCE_TYPE = "resource_type"
+    RESOURCE_UUID = "resource_uuid"
+    RESTRICT_MEMBER_ACCESS = "restrict_member_access"
+    SCOPE = "scope"
+    SERVICE_SETTINGS_UUID = "service_settings_uuid"
+    SLUG = "slug"
+    STATE = "state"
+    URL = "url"
+    USERNAME = "username"
+    USER_REQUIRES_RECONSENT = "user_requires_reconsent"
+    UUID = "uuid"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/managed_rancher_create_node_request.py

@@ -0,0 +1,186 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.role_enum import RoleEnum
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.data_volume_request import DataVolumeRequest
+
+
+T = TypeVar("T", bound="ManagedRancherCreateNodeRequest")
+
+
+@_attrs_define
+class ManagedRancherCreateNodeRequest:
+    """
+    Attributes:
+        role (RoleEnum):
+        subnet (Union[None, str]):
+        system_volume_size (Union[Unset, int]):
+        system_volume_type (Union[None, Unset, str]):
+        memory (Union[Unset, int]):
+        cpu (Union[Unset, int]):
+        flavor (Union[None, Unset, str]):
+        data_volumes (Union[Unset, list['DataVolumeRequest']]):
+        ssh_public_key (Union[Unset, str]):
+        tenant (Union[Unset, str]):
+    """
+
+    role: RoleEnum
+    subnet: Union[None, str]
+    system_volume_size: Union[Unset, int] = UNSET
+    system_volume_type: Union[None, Unset, str] = UNSET
+    memory: Union[Unset, int] = UNSET
+    cpu: Union[Unset, int] = UNSET
+    flavor: Union[None, Unset, str] = UNSET
+    data_volumes: Union[Unset, list["DataVolumeRequest"]] = UNSET
+    ssh_public_key: Union[Unset, str] = UNSET
+    tenant: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        role = self.role.value
+
+        subnet: Union[None, str]
+        subnet = self.subnet
+
+        system_volume_size = self.system_volume_size
+
+        system_volume_type: Union[None, Unset, str]
+        if isinstance(self.system_volume_type, Unset):
+            system_volume_type = UNSET
+        else:
+            system_volume_type = self.system_volume_type
+
+        memory = self.memory
+
+        cpu = self.cpu
+
+        flavor: Union[None, Unset, str]
+        if isinstance(self.flavor, Unset):
+            flavor = UNSET
+        else:
+            flavor = self.flavor
+
+        data_volumes: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.data_volumes, Unset):
+            data_volumes = []
+            for data_volumes_item_data in self.data_volumes:
+                data_volumes_item = data_volumes_item_data.to_dict()
+                data_volumes.append(data_volumes_item)
+
+        ssh_public_key = self.ssh_public_key
+
+        tenant = self.tenant
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+                "subnet": subnet,
+            }
+        )
+        if system_volume_size is not UNSET:
+            field_dict["system_volume_size"] = system_volume_size
+        if system_volume_type is not UNSET:
+            field_dict["system_volume_type"] = system_volume_type
+        if memory is not UNSET:
+            field_dict["memory"] = memory
+        if cpu is not UNSET:
+            field_dict["cpu"] = cpu
+        if flavor is not UNSET:
+            field_dict["flavor"] = flavor
+        if data_volumes is not UNSET:
+            field_dict["data_volumes"] = data_volumes
+        if ssh_public_key is not UNSET:
+            field_dict["ssh_public_key"] = ssh_public_key
+        if tenant is not UNSET:
+            field_dict["tenant"] = tenant
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.data_volume_request import DataVolumeRequest
+
+        d = dict(src_dict)
+        role = RoleEnum(d.pop("role"))
+
+        def _parse_subnet(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        subnet = _parse_subnet(d.pop("subnet"))
+
+        system_volume_size = d.pop("system_volume_size", UNSET)
+
+        def _parse_system_volume_type(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)
+
+        system_volume_type = _parse_system_volume_type(d.pop("system_volume_type", UNSET))
+
+        memory = d.pop("memory", UNSET)
+
+        cpu = d.pop("cpu", UNSET)
+
+        def _parse_flavor(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)
+
+        flavor = _parse_flavor(d.pop("flavor", UNSET))
+
+        data_volumes = []
+        _data_volumes = d.pop("data_volumes", UNSET)
+        for data_volumes_item_data in _data_volumes or []:
+            data_volumes_item = DataVolumeRequest.from_dict(data_volumes_item_data)
+
+            data_volumes.append(data_volumes_item)
+
+        ssh_public_key = d.pop("ssh_public_key", UNSET)
+
+        tenant = d.pop("tenant", UNSET)
+
+        managed_rancher_create_node_request = cls(
+            role=role,
+            subnet=subnet,
+            system_volume_size=system_volume_size,
+            system_volume_type=system_volume_type,
+            memory=memory,
+            cpu=cpu,
+            flavor=flavor,
+            data_volumes=data_volumes,
+            ssh_public_key=ssh_public_key,
+            tenant=tenant,
+        )
+
+        managed_rancher_create_node_request.additional_properties = d
+        return managed_rancher_create_node_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/marketplace_course_accounts_count_state_item.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MarketplaceCourseAccountsCountStateItem(str, Enum):
+    CLOSED = "Closed"
+    ERRED = "Erred"
+    OK = "OK"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/marketplace_course_accounts_list_state_item.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MarketplaceCourseAccountsListStateItem(str, Enum):
+    CLOSED = "Closed"
+    ERRED = "Erred"
+    OK = "OK"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/marketplace_customer_service_accounts_count_state_item.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MarketplaceCustomerServiceAccountsCountStateItem(str, Enum):
+    CLOSED = "Closed"
+    ERRED = "Erred"
+    OK = "OK"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/marketplace_customer_service_accounts_list_state_item.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MarketplaceCustomerServiceAccountsListStateItem(str, Enum):
+    CLOSED = "Closed"
+    ERRED = "Erred"
+    OK = "OK"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/marketplace_project_service_accounts_count_state_item.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MarketplaceProjectServiceAccountsCountStateItem(str, Enum):
+    CLOSED = "Closed"
+    ERRED = "Erred"
+    OK = "OK"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/marketplace_project_service_accounts_list_state_item.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MarketplaceProjectServiceAccountsListStateItem(str, Enum):
+    CLOSED = "Closed"
+    ERRED = "Erred"
+    OK = "OK"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/marketplace_service_providers_course_accounts_list_state_item.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MarketplaceServiceProvidersCourseAccountsListStateItem(str, Enum):
+    CLOSED = "Closed"
+    ERRED = "Erred"
+    OK = "OK"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/marketplace_service_providers_project_service_accounts_list_state_item.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MarketplaceServiceProvidersProjectServiceAccountsListStateItem(str, Enum):
+    CLOSED = "Closed"
+    ERRED = "Erred"
+    OK = "OK"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/marketplace_service_providers_projects_list_field_item.py

@@ -16,6 +16,7 @@ class MarketplaceServiceProvidersProjectsListFieldItem(str, Enum):
     END_DATE_REQUESTED_BY = "end_date_requested_by"
     IMAGE = "image"
     IS_INDUSTRY = "is_industry"
+    KIND = "kind"
     MARKETPLACE_RESOURCE_COUNT = "marketplace_resource_count"
     MAX_SERVICE_ACCOUNTS = "max_service_accounts"
     NAME = "name"

waldur_api_client/models/nested_security_group_rule.py

@@ -0,0 +1,223 @@
+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 ..models.blank_enum import BlankEnum
+from ..models.direction_enum import DirectionEnum
+from ..models.ethertype_enum import EthertypeEnum
+from ..models.protocol_enum import ProtocolEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="NestedSecurityGroupRule")
+
+
+@_attrs_define
+class NestedSecurityGroupRule:
+    """
+    Attributes:
+        ethertype (Union[Unset, EthertypeEnum]):
+        direction (Union[Unset, DirectionEnum]):
+        protocol (Union[BlankEnum, ProtocolEnum, Unset]): The network protocol (TCP, UDP, ICMP, or empty for any
+            protocol)
+        from_port (Union[None, Unset, int]): Starting port number in the range (1-65535)
+        to_port (Union[None, Unset, int]): Ending port number in the range (1-65535)
+        cidr (Union[None, Unset, str]): CIDR notation for the source/destination network address range
+        description (Union[Unset, str]):
+        remote_group_name (Union[Unset, str]):
+        remote_group_uuid (Union[Unset, UUID]):
+        id (Union[Unset, int]):
+    """
+
+    ethertype: Union[Unset, EthertypeEnum] = UNSET
+    direction: Union[Unset, DirectionEnum] = UNSET
+    protocol: Union[BlankEnum, ProtocolEnum, Unset] = UNSET
+    from_port: Union[None, Unset, int] = UNSET
+    to_port: Union[None, Unset, int] = UNSET
+    cidr: Union[None, Unset, str] = UNSET
+    description: Union[Unset, str] = UNSET
+    remote_group_name: Union[Unset, str] = UNSET
+    remote_group_uuid: Union[Unset, UUID] = UNSET
+    id: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ethertype: Union[Unset, str] = UNSET
+        if not isinstance(self.ethertype, Unset):
+            ethertype = self.ethertype.value
+
+        direction: Union[Unset, str] = UNSET
+        if not isinstance(self.direction, Unset):
+            direction = self.direction.value
+
+        protocol: Union[Unset, str]
+        if isinstance(self.protocol, Unset):
+            protocol = UNSET
+        elif isinstance(self.protocol, ProtocolEnum):
+            protocol = self.protocol.value
+        else:
+            protocol = self.protocol.value
+
+        from_port: Union[None, Unset, int]
+        if isinstance(self.from_port, Unset):
+            from_port = UNSET
+        else:
+            from_port = self.from_port
+
+        to_port: Union[None, Unset, int]
+        if isinstance(self.to_port, Unset):
+            to_port = UNSET
+        else:
+            to_port = self.to_port
+
+        cidr: Union[None, Unset, str]
+        if isinstance(self.cidr, Unset):
+            cidr = UNSET
+        else:
+            cidr = self.cidr
+
+        description = self.description
+
+        remote_group_name = self.remote_group_name
+
+        remote_group_uuid: Union[Unset, str] = UNSET
+        if not isinstance(self.remote_group_uuid, Unset):
+            remote_group_uuid = str(self.remote_group_uuid)
+
+        id = self.id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if ethertype is not UNSET:
+            field_dict["ethertype"] = ethertype
+        if direction is not UNSET:
+            field_dict["direction"] = direction
+        if protocol is not UNSET:
+            field_dict["protocol"] = protocol
+        if from_port is not UNSET:
+            field_dict["from_port"] = from_port
+        if to_port is not UNSET:
+            field_dict["to_port"] = to_port
+        if cidr is not UNSET:
+            field_dict["cidr"] = cidr
+        if description is not UNSET:
+            field_dict["description"] = description
+        if remote_group_name is not UNSET:
+            field_dict["remote_group_name"] = remote_group_name
+        if remote_group_uuid is not UNSET:
+            field_dict["remote_group_uuid"] = remote_group_uuid
+        if id is not UNSET:
+            field_dict["id"] = id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _ethertype = d.pop("ethertype", UNSET)
+        ethertype: Union[Unset, EthertypeEnum]
+        if isinstance(_ethertype, Unset):
+            ethertype = UNSET
+        else:
+            ethertype = EthertypeEnum(_ethertype)
+
+        _direction = d.pop("direction", UNSET)
+        direction: Union[Unset, DirectionEnum]
+        if isinstance(_direction, Unset):
+            direction = UNSET
+        else:
+            direction = DirectionEnum(_direction)
+
+        def _parse_protocol(data: object) -> Union[BlankEnum, ProtocolEnum, Unset]:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                protocol_type_0 = ProtocolEnum(data)
+
+                return protocol_type_0
+            except:  # noqa: E722
+                pass
+            if not isinstance(data, str):
+                raise TypeError()
+            protocol_type_1 = BlankEnum(data)
+
+            return protocol_type_1
+
+        protocol = _parse_protocol(d.pop("protocol", UNSET))
+
+        def _parse_from_port(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        from_port = _parse_from_port(d.pop("from_port", UNSET))
+
+        def _parse_to_port(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        to_port = _parse_to_port(d.pop("to_port", UNSET))
+
+        def _parse_cidr(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)
+
+        cidr = _parse_cidr(d.pop("cidr", UNSET))
+
+        description = d.pop("description", UNSET)
+
+        remote_group_name = d.pop("remote_group_name", UNSET)
+
+        _remote_group_uuid = d.pop("remote_group_uuid", UNSET)
+        remote_group_uuid: Union[Unset, UUID]
+        if isinstance(_remote_group_uuid, Unset):
+            remote_group_uuid = UNSET
+        else:
+            remote_group_uuid = UUID(_remote_group_uuid)
+
+        id = d.pop("id", UNSET)
+
+        nested_security_group_rule = cls(
+            ethertype=ethertype,
+            direction=direction,
+            protocol=protocol,
+            from_port=from_port,
+            to_port=to_port,
+            cidr=cidr,
+            description=description,
+            remote_group_name=remote_group_name,
+            remote_group_uuid=remote_group_uuid,
+            id=id,
+        )
+
+        nested_security_group_rule.additional_properties = d
+        return nested_security_group_rule
+
+    @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