duplocloud-sdk 0.0.1__py3-none-any.whl

duplocloud_sdk/models/azure_virtual_machine_network_interface_configuration.py

@@ -0,0 +1,126 @@
+# coding: utf-8
+
+"""
+    Duplo Client
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from duplocloud_sdk.models.azure_sub_resource2 import AzureSubResource2
+from duplocloud_sdk.models.azure_virtual_machine_network_interface_dns_settings_configuration import AzureVirtualMachineNetworkInterfaceDnsSettingsConfiguration
+from duplocloud_sdk.models.azure_virtual_machine_network_interface_ip_configuration import AzureVirtualMachineNetworkInterfaceIPConfiguration
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AzureVirtualMachineNetworkInterfaceConfiguration(BaseModel):
+    """
+    Describes a virtual machine network interface configurations.
+    """ # noqa: E501
+    name: Optional[StrictStr] = Field(default=None, description="Gets or sets the network interface configuration name.")
+    properties_primary: Optional[StrictBool] = Field(default=None, description="Gets or sets specifies the primary network interface in case the virtual machine has more than 1 network interface.", alias="properties.primary")
+    properties_delete_option: Optional[StrictStr] = Field(default=None, description="Gets or sets specify what happens to the network interface when the VM is deleted. Possible values include: 'Delete', 'Detach'", alias="properties.deleteOption")
+    properties_enable_accelerated_networking: Optional[StrictBool] = Field(default=None, description="Gets or sets specifies whether the network interface is accelerated networking-enabled.", alias="properties.enableAcceleratedNetworking")
+    properties_disable_tcp_state_tracking: Optional[StrictBool] = Field(default=None, description="Gets or sets specifies whether the network interface is disabled for tcp state tracking.", alias="properties.disableTcpStateTracking")
+    properties_enable_fpga: Optional[StrictBool] = Field(default=None, description="Gets or sets specifies whether the network interface is FPGA networking-enabled.", alias="properties.enableFpga")
+    properties_enable_ip_forwarding: Optional[StrictBool] = Field(default=None, description="Gets or sets whether IP forwarding enabled on this NIC.", alias="properties.enableIPForwarding")
+    properties_network_security_group: Optional[AzureSubResource2] = Field(default=None, description="Gets or sets the network security group.", alias="properties.networkSecurityGroup")
+    properties_dns_settings: Optional[AzureVirtualMachineNetworkInterfaceDnsSettingsConfiguration] = Field(default=None, description="Gets or sets the dns settings to be applied on the network interfaces.", alias="properties.dnsSettings")
+    properties_ip_configurations: Optional[List[AzureVirtualMachineNetworkInterfaceIPConfiguration]] = Field(default=None, description="Gets or sets specifies the IP configurations of the network interface.", alias="properties.ipConfigurations")
+    properties_dscp_configuration: Optional[AzureSubResource2] = Field(default=None, alias="properties.dscpConfiguration")
+    __properties: ClassVar[List[str]] = ["name", "properties.primary", "properties.deleteOption", "properties.enableAcceleratedNetworking", "properties.disableTcpStateTracking", "properties.enableFpga", "properties.enableIPForwarding", "properties.networkSecurityGroup", "properties.dnsSettings", "properties.ipConfigurations", "properties.dscpConfiguration"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachineNetworkInterfaceConfiguration from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of properties_network_security_group
+        if self.properties_network_security_group:
+            _dict['properties.networkSecurityGroup'] = self.properties_network_security_group.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of properties_dns_settings
+        if self.properties_dns_settings:
+            _dict['properties.dnsSettings'] = self.properties_dns_settings.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in properties_ip_configurations (list)
+        _items = []
+        if self.properties_ip_configurations:
+            for _item_properties_ip_configurations in self.properties_ip_configurations:
+                if _item_properties_ip_configurations:
+                    _items.append(_item_properties_ip_configurations.to_dict())
+            _dict['properties.ipConfigurations'] = _items
+        # override the default output from pydantic by calling `to_dict()` of properties_dscp_configuration
+        if self.properties_dscp_configuration:
+            _dict['properties.dscpConfiguration'] = self.properties_dscp_configuration.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachineNetworkInterfaceConfiguration from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "properties.primary": obj.get("properties.primary"),
+            "properties.deleteOption": obj.get("properties.deleteOption"),
+            "properties.enableAcceleratedNetworking": obj.get("properties.enableAcceleratedNetworking"),
+            "properties.disableTcpStateTracking": obj.get("properties.disableTcpStateTracking"),
+            "properties.enableFpga": obj.get("properties.enableFpga"),
+            "properties.enableIPForwarding": obj.get("properties.enableIPForwarding"),
+            "properties.networkSecurityGroup": AzureSubResource2.from_dict(obj["properties.networkSecurityGroup"]) if obj.get("properties.networkSecurityGroup") is not None else None,
+            "properties.dnsSettings": AzureVirtualMachineNetworkInterfaceDnsSettingsConfiguration.from_dict(obj["properties.dnsSettings"]) if obj.get("properties.dnsSettings") is not None else None,
+            "properties.ipConfigurations": [AzureVirtualMachineNetworkInterfaceIPConfiguration.from_dict(_item) for _item in obj["properties.ipConfigurations"]] if obj.get("properties.ipConfigurations") is not None else None,
+            "properties.dscpConfiguration": AzureSubResource2.from_dict(obj["properties.dscpConfiguration"]) if obj.get("properties.dscpConfiguration") is not None else None
+        })
+        return _obj
+
+

duplocloud_sdk/models/azure_virtual_machine_network_interface_dns_settings_configuration.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    Duplo Client
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AzureVirtualMachineNetworkInterfaceDnsSettingsConfiguration(BaseModel):
+    """
+    Describes a virtual machines network configuration's DNS settings.
+    """ # noqa: E501
+    dns_servers: Optional[List[StrictStr]] = Field(default=None, description="Gets or sets list of DNS servers IP addresses", alias="dnsServers")
+    __properties: ClassVar[List[str]] = ["dnsServers"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachineNetworkInterfaceDnsSettingsConfiguration from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachineNetworkInterfaceDnsSettingsConfiguration from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "dnsServers": obj.get("dnsServers")
+        })
+        return _obj
+
+

duplocloud_sdk/models/azure_virtual_machine_network_interface_ip_configuration.py

@@ -0,0 +1,130 @@
+# coding: utf-8
+
+"""
+    Duplo Client
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from duplocloud_sdk.models.azure_sub_resource2 import AzureSubResource2
+from duplocloud_sdk.models.azure_virtual_machine_public_ip_address_configuration import AzureVirtualMachinePublicIPAddressConfiguration
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AzureVirtualMachineNetworkInterfaceIPConfiguration(BaseModel):
+    """
+    Describes a virtual machine network profile's IP configuration.
+    """ # noqa: E501
+    name: Optional[StrictStr] = Field(default=None, description="Gets or sets the IP configuration name.")
+    properties_subnet: Optional[AzureSubResource2] = Field(default=None, description="Gets or sets specifies the identifier of the subnet.", alias="properties.subnet")
+    properties_primary: Optional[StrictBool] = Field(default=None, description="Gets or sets specifies the primary network interface in case the virtual machine has more than 1 network interface.", alias="properties.primary")
+    properties_public_ip_address_configuration: Optional[AzureVirtualMachinePublicIPAddressConfiguration] = Field(default=None, description="Gets or sets the publicIPAddressConfiguration.", alias="properties.publicIPAddressConfiguration")
+    properties_private_ip_address_version: Optional[StrictStr] = Field(default=None, description="Gets or sets available from Api-Version 2017-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4.  Possible values are: 'IPv4' and 'IPv6'. Possible values include: 'IPv4', 'IPv6'", alias="properties.privateIPAddressVersion")
+    properties_application_security_groups: Optional[List[AzureSubResource2]] = Field(default=None, description="Gets or sets specifies an array of references to application security group.", alias="properties.applicationSecurityGroups")
+    properties_application_gateway_backend_address_pools: Optional[List[AzureSubResource2]] = Field(default=None, description="Gets or sets specifies an array of references to backend address pools of application gateways. A virtual machine can reference backend address pools of multiple application gateways. Multiple virtual machines cannot use the same application gateway.", alias="properties.applicationGatewayBackendAddressPools")
+    properties_load_balancer_backend_address_pools: Optional[List[AzureSubResource2]] = Field(default=None, description="Gets or sets specifies an array of references to backend address pools of load balancers. A virtual machine can reference backend address pools of one public and one internal load balancer. [Multiple virtual machines cannot use the same basic sku load balancer].", alias="properties.loadBalancerBackendAddressPools")
+    __properties: ClassVar[List[str]] = ["name", "properties.subnet", "properties.primary", "properties.publicIPAddressConfiguration", "properties.privateIPAddressVersion", "properties.applicationSecurityGroups", "properties.applicationGatewayBackendAddressPools", "properties.loadBalancerBackendAddressPools"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachineNetworkInterfaceIPConfiguration from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of properties_subnet
+        if self.properties_subnet:
+            _dict['properties.subnet'] = self.properties_subnet.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of properties_public_ip_address_configuration
+        if self.properties_public_ip_address_configuration:
+            _dict['properties.publicIPAddressConfiguration'] = self.properties_public_ip_address_configuration.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in properties_application_security_groups (list)
+        _items = []
+        if self.properties_application_security_groups:
+            for _item_properties_application_security_groups in self.properties_application_security_groups:
+                if _item_properties_application_security_groups:
+                    _items.append(_item_properties_application_security_groups.to_dict())
+            _dict['properties.applicationSecurityGroups'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in properties_application_gateway_backend_address_pools (list)
+        _items = []
+        if self.properties_application_gateway_backend_address_pools:
+            for _item_properties_application_gateway_backend_address_pools in self.properties_application_gateway_backend_address_pools:
+                if _item_properties_application_gateway_backend_address_pools:
+                    _items.append(_item_properties_application_gateway_backend_address_pools.to_dict())
+            _dict['properties.applicationGatewayBackendAddressPools'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in properties_load_balancer_backend_address_pools (list)
+        _items = []
+        if self.properties_load_balancer_backend_address_pools:
+            for _item_properties_load_balancer_backend_address_pools in self.properties_load_balancer_backend_address_pools:
+                if _item_properties_load_balancer_backend_address_pools:
+                    _items.append(_item_properties_load_balancer_backend_address_pools.to_dict())
+            _dict['properties.loadBalancerBackendAddressPools'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachineNetworkInterfaceIPConfiguration from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "properties.subnet": AzureSubResource2.from_dict(obj["properties.subnet"]) if obj.get("properties.subnet") is not None else None,
+            "properties.primary": obj.get("properties.primary"),
+            "properties.publicIPAddressConfiguration": AzureVirtualMachinePublicIPAddressConfiguration.from_dict(obj["properties.publicIPAddressConfiguration"]) if obj.get("properties.publicIPAddressConfiguration") is not None else None,
+            "properties.privateIPAddressVersion": obj.get("properties.privateIPAddressVersion"),
+            "properties.applicationSecurityGroups": [AzureSubResource2.from_dict(_item) for _item in obj["properties.applicationSecurityGroups"]] if obj.get("properties.applicationSecurityGroups") is not None else None,
+            "properties.applicationGatewayBackendAddressPools": [AzureSubResource2.from_dict(_item) for _item in obj["properties.applicationGatewayBackendAddressPools"]] if obj.get("properties.applicationGatewayBackendAddressPools") is not None else None,
+            "properties.loadBalancerBackendAddressPools": [AzureSubResource2.from_dict(_item) for _item in obj["properties.loadBalancerBackendAddressPools"]] if obj.get("properties.loadBalancerBackendAddressPools") is not None else None
+        })
+        return _obj
+
+

duplocloud_sdk/models/azure_virtual_machine_patch_status.py

@@ -0,0 +1,107 @@
+# coding: utf-8
+
+"""
+    Duplo Client
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from duplocloud_sdk.models.azure_available_patch_summary import AzureAvailablePatchSummary
+from duplocloud_sdk.models.azure_instance_view_status import AzureInstanceViewStatus
+from duplocloud_sdk.models.azure_last_patch_installation_summary import AzureLastPatchInstallationSummary
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AzureVirtualMachinePatchStatus(BaseModel):
+    """
+    The status of virtual machine patch operations.
+    """ # noqa: E501
+    available_patch_summary: Optional[AzureAvailablePatchSummary] = Field(default=None, description="Gets or sets the available patch summary of the latest assessment operation for the virtual machine.", alias="availablePatchSummary")
+    last_patch_installation_summary: Optional[AzureLastPatchInstallationSummary] = Field(default=None, description="Gets or sets the installation summary of the latest installation operation for the virtual machine.", alias="lastPatchInstallationSummary")
+    configuration_statuses: Optional[List[AzureInstanceViewStatus]] = Field(default=None, description="Gets the enablement status of the specified patchMode", alias="configurationStatuses")
+    __properties: ClassVar[List[str]] = ["availablePatchSummary", "lastPatchInstallationSummary", "configurationStatuses"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachinePatchStatus from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of available_patch_summary
+        if self.available_patch_summary:
+            _dict['availablePatchSummary'] = self.available_patch_summary.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of last_patch_installation_summary
+        if self.last_patch_installation_summary:
+            _dict['lastPatchInstallationSummary'] = self.last_patch_installation_summary.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in configuration_statuses (list)
+        _items = []
+        if self.configuration_statuses:
+            for _item_configuration_statuses in self.configuration_statuses:
+                if _item_configuration_statuses:
+                    _items.append(_item_configuration_statuses.to_dict())
+            _dict['configurationStatuses'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachinePatchStatus from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "availablePatchSummary": AzureAvailablePatchSummary.from_dict(obj["availablePatchSummary"]) if obj.get("availablePatchSummary") is not None else None,
+            "lastPatchInstallationSummary": AzureLastPatchInstallationSummary.from_dict(obj["lastPatchInstallationSummary"]) if obj.get("lastPatchInstallationSummary") is not None else None,
+            "configurationStatuses": [AzureInstanceViewStatus.from_dict(_item) for _item in obj["configurationStatuses"]] if obj.get("configurationStatuses") is not None else None
+        })
+        return _obj
+
+

duplocloud_sdk/models/azure_virtual_machine_public_ip_address_configuration.py

@@ -0,0 +1,123 @@
+# coding: utf-8
+
+"""
+    Duplo Client
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from duplocloud_sdk.models.azure_public_ip_address_sku2 import AzurePublicIPAddressSku2
+from duplocloud_sdk.models.azure_sub_resource2 import AzureSubResource2
+from duplocloud_sdk.models.azure_virtual_machine_ip_tag import AzureVirtualMachineIpTag
+from duplocloud_sdk.models.azure_virtual_machine_public_ip_address_dns_settings_configuration import AzureVirtualMachinePublicIPAddressDnsSettingsConfiguration
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AzureVirtualMachinePublicIPAddressConfiguration(BaseModel):
+    """
+    Describes a virtual machines IP Configuration's PublicIPAddress configuration
+    """ # noqa: E501
+    name: Optional[StrictStr] = Field(default=None, description="Gets or sets the publicIP address configuration name.")
+    properties_idle_timeout_in_minutes: Optional[StrictInt] = Field(default=None, description="Gets or sets the idle timeout of the public IP address.", alias="properties.idleTimeoutInMinutes")
+    properties_delete_option: Optional[StrictStr] = Field(default=None, description="Gets or sets specify what happens to the public IP address when the VM is deleted. Possible values include: 'Delete', 'Detach'", alias="properties.deleteOption")
+    properties_dns_settings: Optional[AzureVirtualMachinePublicIPAddressDnsSettingsConfiguration] = Field(default=None, description="Gets or sets the dns settings to be applied on the publicIP addresses .", alias="properties.dnsSettings")
+    properties_ip_tags: Optional[List[AzureVirtualMachineIpTag]] = Field(default=None, description="Gets or sets the list of IP tags associated with the public IP address.", alias="properties.ipTags")
+    properties_public_ip_prefix: Optional[AzureSubResource2] = Field(default=None, description="Gets or sets the PublicIPPrefix from which to allocate publicIP addresses.", alias="properties.publicIPPrefix")
+    properties_public_ip_address_version: Optional[StrictStr] = Field(default=None, description="Gets or sets available from Api-Version 2019-07-01 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'. Possible values include: 'IPv4', 'IPv6'", alias="properties.publicIPAddressVersion")
+    properties_public_ip_allocation_method: Optional[StrictStr] = Field(default=None, description="Gets or sets specify the public IP allocation type. Possible values include: 'Dynamic', 'Static'", alias="properties.publicIPAllocationMethod")
+    sku: Optional[AzurePublicIPAddressSku2] = None
+    __properties: ClassVar[List[str]] = ["name", "properties.idleTimeoutInMinutes", "properties.deleteOption", "properties.dnsSettings", "properties.ipTags", "properties.publicIPPrefix", "properties.publicIPAddressVersion", "properties.publicIPAllocationMethod", "sku"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachinePublicIPAddressConfiguration from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of properties_dns_settings
+        if self.properties_dns_settings:
+            _dict['properties.dnsSettings'] = self.properties_dns_settings.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in properties_ip_tags (list)
+        _items = []
+        if self.properties_ip_tags:
+            for _item_properties_ip_tags in self.properties_ip_tags:
+                if _item_properties_ip_tags:
+                    _items.append(_item_properties_ip_tags.to_dict())
+            _dict['properties.ipTags'] = _items
+        # override the default output from pydantic by calling `to_dict()` of properties_public_ip_prefix
+        if self.properties_public_ip_prefix:
+            _dict['properties.publicIPPrefix'] = self.properties_public_ip_prefix.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of sku
+        if self.sku:
+            _dict['sku'] = self.sku.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachinePublicIPAddressConfiguration from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "properties.idleTimeoutInMinutes": obj.get("properties.idleTimeoutInMinutes"),
+            "properties.deleteOption": obj.get("properties.deleteOption"),
+            "properties.dnsSettings": AzureVirtualMachinePublicIPAddressDnsSettingsConfiguration.from_dict(obj["properties.dnsSettings"]) if obj.get("properties.dnsSettings") is not None else None,
+            "properties.ipTags": [AzureVirtualMachineIpTag.from_dict(_item) for _item in obj["properties.ipTags"]] if obj.get("properties.ipTags") is not None else None,
+            "properties.publicIPPrefix": AzureSubResource2.from_dict(obj["properties.publicIPPrefix"]) if obj.get("properties.publicIPPrefix") is not None else None,
+            "properties.publicIPAddressVersion": obj.get("properties.publicIPAddressVersion"),
+            "properties.publicIPAllocationMethod": obj.get("properties.publicIPAllocationMethod"),
+            "sku": AzurePublicIPAddressSku2.from_dict(obj["sku"]) if obj.get("sku") is not None else None
+        })
+        return _obj
+
+

duplocloud_sdk/models/azure_virtual_machine_public_ip_address_dns_settings_configuration.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    Duplo Client
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AzureVirtualMachinePublicIPAddressDnsSettingsConfiguration(BaseModel):
+    """
+    Describes a virtual machines network configuration's DNS settings.
+    """ # noqa: E501
+    domain_name_label: Optional[StrictStr] = Field(default=None, description="Gets or sets the Domain name label prefix of the PublicIPAddress resources that will be created. The generated name label is the concatenation of the domain name label and vm network profile unique ID.", alias="domainNameLabel")
+    __properties: ClassVar[List[str]] = ["domainNameLabel"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachinePublicIPAddressDnsSettingsConfiguration from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AzureVirtualMachinePublicIPAddressDnsSettingsConfiguration from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "domainNameLabel": obj.get("domainNameLabel")
+        })
+        return _obj
+
+