ibm-platform-services 0.55.3__py3-none-any.whl

ibm_platform_services/context_based_restrictions_v1.py

@@ -0,0 +1,3633 @@
+# coding: utf-8
+
+# (C) Copyright IBM Corp. 2024.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# IBM OpenAPI SDK Code Generator Version: 3.86.0-bc6f14b3-20240221-193958
+
+"""
+With the Context Based Restrictions API, you can:
+* Create, list, get, replace, and delete network zones
+* Create, list, get, replace, and delete context-based restriction rules
+* Get account settings
+
+API Version: 1.0.1
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import Dict, List, Optional
+import json
+import sys
+
+from ibm_cloud_sdk_core import BaseService, DetailedResponse
+from ibm_cloud_sdk_core.authenticators.authenticator import Authenticator
+from ibm_cloud_sdk_core.get_authenticator import get_authenticator_from_environment
+from ibm_cloud_sdk_core.utils import convert_model, datetime_to_string, string_to_datetime
+
+from .common import get_sdk_headers
+
+##############################################################################
+# Service
+##############################################################################
+
+
+class ContextBasedRestrictionsV1(BaseService):
+    """The Context Based Restrictions V1 service."""
+
+    DEFAULT_SERVICE_URL = 'https://cbr.cloud.ibm.com'
+    DEFAULT_SERVICE_NAME = 'context_based_restrictions'
+
+    @classmethod
+    def new_instance(
+        cls,
+        service_name: str = DEFAULT_SERVICE_NAME,
+    ) -> 'ContextBasedRestrictionsV1':
+        """
+        Return a new client for the Context Based Restrictions service using the
+               specified parameters and external configuration.
+        """
+        authenticator = get_authenticator_from_environment(service_name)
+        service = cls(authenticator)
+        service.configure_service(service_name)
+        return service
+
+    def __init__(
+        self,
+        authenticator: Authenticator = None,
+    ) -> None:
+        """
+        Construct a new client for the Context Based Restrictions service.
+
+        :param Authenticator authenticator: The authenticator specifies the authentication mechanism.
+               Get up to date information from https://github.com/IBM/python-sdk-core/blob/main/README.md
+               about initializing the authenticator of your choice.
+        """
+        BaseService.__init__(self, service_url=self.DEFAULT_SERVICE_URL, authenticator=authenticator)
+
+    #########################
+    # Zones
+    #########################
+
+    def create_zone(
+        self,
+        *,
+        name: Optional[str] = None,
+        account_id: Optional[str] = None,
+        addresses: Optional[List['Address']] = None,
+        description: Optional[str] = None,
+        excluded: Optional[List['Address']] = None,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Create a network zone.
+
+        This operation creates a network zone for the specified account.
+
+        :param str name: (optional) The name of the zone.
+        :param str account_id: (optional) The id of the account owning this zone.
+        :param List[Address] addresses: (optional) The list of addresses in the
+               zone.
+        :param str description: (optional) The description of the zone.
+        :param List[Address] excluded: (optional) The list of excluded addresses in
+               the zone. Only addresses of type `ipAddress`, `ipRange`, and `subnet` can
+               be excluded.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `Zone` object
+        """
+
+        if addresses is not None:
+            addresses = [convert_model(x) for x in addresses]
+        if excluded is not None:
+            excluded = [convert_model(x) for x in excluded]
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='create_zone',
+        )
+        headers.update(sdk_headers)
+
+        data = {
+            'name': name,
+            'account_id': account_id,
+            'addresses': addresses,
+            'description': description,
+            'excluded': excluded,
+        }
+        data = {k: v for (k, v) in data.items() if v is not None}
+        data = json.dumps(data)
+        headers['content-type'] = 'application/json'
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        url = '/v1/zones'
+        request = self.prepare_request(
+            method='POST',
+            url=url,
+            headers=headers,
+            data=data,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def list_zones(
+        self,
+        account_id: str,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        name: Optional[str] = None,
+        sort: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        List network zones.
+
+        This operation lists network zones in the specified account.
+
+        :param str account_id: The ID of the managing account.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param str name: (optional) The name of the zone.
+        :param str sort: (optional) Sorts results by using a valid sort field. To
+               learn more, see
+               [Sorting](https://cloud.ibm.com/docs/api-handbook?topic=api-handbook-sorting).
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `ZoneList` object
+        """
+
+        if not account_id:
+            raise ValueError('account_id must be provided')
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='list_zones',
+        )
+        headers.update(sdk_headers)
+
+        params = {
+            'account_id': account_id,
+            'name': name,
+            'sort': sort,
+        }
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        url = '/v1/zones'
+        request = self.prepare_request(
+            method='GET',
+            url=url,
+            headers=headers,
+            params=params,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def get_zone(
+        self,
+        zone_id: str,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Get a network zone.
+
+        This operation retrieves the network zone identified by the specified zone ID.
+
+        :param str zone_id: The ID of a zone.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `Zone` object
+        """
+
+        if not zone_id:
+            raise ValueError('zone_id must be provided')
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='get_zone',
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['zone_id']
+        path_param_values = self.encode_path_vars(zone_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v1/zones/{zone_id}'.format(**path_param_dict)
+        request = self.prepare_request(
+            method='GET',
+            url=url,
+            headers=headers,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def replace_zone(
+        self,
+        zone_id: str,
+        if_match: str,
+        *,
+        name: Optional[str] = None,
+        account_id: Optional[str] = None,
+        addresses: Optional[List['Address']] = None,
+        description: Optional[str] = None,
+        excluded: Optional[List['Address']] = None,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Replace a network zone.
+
+        This operation replaces the network zone identified by the specified zone ID.
+        Partial updates are not supported. The entire network zone object must be
+        replaced.
+
+        :param str zone_id: The ID of a zone.
+        :param str if_match: The current revision of the resource being updated.
+               This can be found in the Create/Get/Update resource response ETag header.
+        :param str name: (optional) The name of the zone.
+        :param str account_id: (optional) The id of the account owning this zone.
+        :param List[Address] addresses: (optional) The list of addresses in the
+               zone.
+        :param str description: (optional) The description of the zone.
+        :param List[Address] excluded: (optional) The list of excluded addresses in
+               the zone. Only addresses of type `ipAddress`, `ipRange`, and `subnet` can
+               be excluded.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `Zone` object
+        """
+
+        if not zone_id:
+            raise ValueError('zone_id must be provided')
+        if not if_match:
+            raise ValueError('if_match must be provided')
+        if addresses is not None:
+            addresses = [convert_model(x) for x in addresses]
+        if excluded is not None:
+            excluded = [convert_model(x) for x in excluded]
+        headers = {
+            'If-Match': if_match,
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='replace_zone',
+        )
+        headers.update(sdk_headers)
+
+        data = {
+            'name': name,
+            'account_id': account_id,
+            'addresses': addresses,
+            'description': description,
+            'excluded': excluded,
+        }
+        data = {k: v for (k, v) in data.items() if v is not None}
+        data = json.dumps(data)
+        headers['content-type'] = 'application/json'
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['zone_id']
+        path_param_values = self.encode_path_vars(zone_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v1/zones/{zone_id}'.format(**path_param_dict)
+        request = self.prepare_request(
+            method='PUT',
+            url=url,
+            headers=headers,
+            data=data,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def delete_zone(
+        self,
+        zone_id: str,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Delete a network zone.
+
+        This operation deletes the network zone identified by the specified zone ID.
+
+        :param str zone_id: The ID of a zone.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse
+        """
+
+        if not zone_id:
+            raise ValueError('zone_id must be provided')
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='delete_zone',
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+
+        path_param_keys = ['zone_id']
+        path_param_values = self.encode_path_vars(zone_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v1/zones/{zone_id}'.format(**path_param_dict)
+        request = self.prepare_request(
+            method='DELETE',
+            url=url,
+            headers=headers,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def list_available_serviceref_targets(
+        self,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        type: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        List available service reference targets.
+
+        This operation lists all available service reference targets.
+
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param str type: (optional) Specifies the types of services to retrieve.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `ServiceRefTargetList` object
+        """
+
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='list_available_serviceref_targets',
+        )
+        headers.update(sdk_headers)
+
+        params = {
+            'type': type,
+        }
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        url = '/v1/zones/serviceref_targets'
+        request = self.prepare_request(
+            method='GET',
+            url=url,
+            headers=headers,
+            params=params,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def get_serviceref_target(
+        self,
+        service_name: str,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Get service reference target for a specified service name.
+
+        This operation gets the service reference target for a specified service name.
+
+        :param str service_name: The name of a service.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `ServiceRefTarget` object
+        """
+
+        if not service_name:
+            raise ValueError('service_name must be provided')
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='get_serviceref_target',
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['service_name']
+        path_param_values = self.encode_path_vars(service_name)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v1/zones/serviceref_targets/{service_name}'.format(**path_param_dict)
+        request = self.prepare_request(
+            method='GET',
+            url=url,
+            headers=headers,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    #########################
+    # Rules
+    #########################
+
+    def create_rule(
+        self,
+        *,
+        contexts: Optional[List['RuleContext']] = None,
+        resources: Optional[List['Resource']] = None,
+        description: Optional[str] = None,
+        operations: Optional['NewRuleOperations'] = None,
+        enforcement_mode: Optional[str] = None,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Create a rule.
+
+        This operation creates a rule for the specified account.
+
+        :param List[RuleContext] contexts: (optional) The contexts this rule
+               applies to.
+        :param List[Resource] resources: (optional) The resources this rule apply
+               to.
+        :param str description: (optional) The description of the rule.
+        :param NewRuleOperations operations: (optional) The operations this rule
+               applies to.
+        :param str enforcement_mode: (optional) The rule enforcement mode:
+                * `enabled` - The restrictions are enforced and reported. This is the
+               default.
+                * `disabled` - The restrictions are disabled. Nothing is enforced or
+               reported.
+                * `report` - The restrictions are evaluated and reported, but not
+               enforced.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `Rule` object
+        """
+
+        if contexts is not None:
+            contexts = [convert_model(x) for x in contexts]
+        if resources is not None:
+            resources = [convert_model(x) for x in resources]
+        if operations is not None:
+            operations = convert_model(operations)
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='create_rule',
+        )
+        headers.update(sdk_headers)
+
+        data = {
+            'contexts': contexts,
+            'resources': resources,
+            'description': description,
+            'operations': operations,
+            'enforcement_mode': enforcement_mode,
+        }
+        data = {k: v for (k, v) in data.items() if v is not None}
+        data = json.dumps(data)
+        headers['content-type'] = 'application/json'
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        url = '/v1/rules'
+        request = self.prepare_request(
+            method='POST',
+            url=url,
+            headers=headers,
+            data=data,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def list_rules(
+        self,
+        account_id: str,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        region: Optional[str] = None,
+        resource: Optional[str] = None,
+        resource_type: Optional[str] = None,
+        service_instance: Optional[str] = None,
+        service_name: Optional[str] = None,
+        service_type: Optional[str] = None,
+        service_group_id: Optional[str] = None,
+        zone_id: Optional[str] = None,
+        sort: Optional[str] = None,
+        enforcement_mode: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        List rules.
+
+        This operation lists rules in the specified account.
+
+        :param str account_id: The ID of the managing account.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param str region: (optional) The `region` resource attribute.
+        :param str resource: (optional) The `resource` resource attribute.
+        :param str resource_type: (optional) The `resourceType` resource attribute.
+        :param str service_instance: (optional) The `serviceInstance` resource
+               attribute.
+        :param str service_name: (optional) The `serviceName` resource attribute.
+        :param str service_type: (optional) The rule's `serviceType` resource
+               attribute.
+        :param str service_group_id: (optional) The rule's `service_group_id`
+               resource attribute.
+        :param str zone_id: (optional) The globally unique ID of the zone.
+        :param str sort: (optional) Sorts results by using a valid sort field. To
+               learn more, see
+               [Sorting](https://cloud.ibm.com/docs/api-handbook?topic=api-handbook-sorting).
+        :param str enforcement_mode: (optional) The rule's `enforcement_mode`
+               attribute.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `RuleList` object
+        """
+
+        if not account_id:
+            raise ValueError('account_id must be provided')
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='list_rules',
+        )
+        headers.update(sdk_headers)
+
+        params = {
+            'account_id': account_id,
+            'region': region,
+            'resource': resource,
+            'resource_type': resource_type,
+            'service_instance': service_instance,
+            'service_name': service_name,
+            'service_type': service_type,
+            'service_group_id': service_group_id,
+            'zone_id': zone_id,
+            'sort': sort,
+            'enforcement_mode': enforcement_mode,
+        }
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        url = '/v1/rules'
+        request = self.prepare_request(
+            method='GET',
+            url=url,
+            headers=headers,
+            params=params,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def get_rule(
+        self,
+        rule_id: str,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Get a rule.
+
+        This operation retrieves the rule identified by the specified rule ID.
+
+        :param str rule_id: The ID of a rule.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `Rule` object
+        """
+
+        if not rule_id:
+            raise ValueError('rule_id must be provided')
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='get_rule',
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['rule_id']
+        path_param_values = self.encode_path_vars(rule_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v1/rules/{rule_id}'.format(**path_param_dict)
+        request = self.prepare_request(
+            method='GET',
+            url=url,
+            headers=headers,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def replace_rule(
+        self,
+        rule_id: str,
+        if_match: str,
+        *,
+        contexts: Optional[List['RuleContext']] = None,
+        resources: Optional[List['Resource']] = None,
+        description: Optional[str] = None,
+        operations: Optional['NewRuleOperations'] = None,
+        enforcement_mode: Optional[str] = None,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Replace a rule.
+
+        This operation replaces the rule identified by the specified rule ID. Partial
+        updates are not supported. The entire rule object must be replaced.
+
+        :param str rule_id: The ID of a rule.
+        :param str if_match: The current revision of the resource being updated.
+               This can be found in the Create/Get/Update resource response ETag header.
+        :param List[RuleContext] contexts: (optional) The contexts this rule
+               applies to.
+        :param List[Resource] resources: (optional) The resources this rule apply
+               to.
+        :param str description: (optional) The description of the rule.
+        :param NewRuleOperations operations: (optional) The operations this rule
+               applies to.
+        :param str enforcement_mode: (optional) The rule enforcement mode:
+                * `enabled` - The restrictions are enforced and reported. This is the
+               default.
+                * `disabled` - The restrictions are disabled. Nothing is enforced or
+               reported.
+                * `report` - The restrictions are evaluated and reported, but not
+               enforced.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `Rule` object
+        """
+
+        if not rule_id:
+            raise ValueError('rule_id must be provided')
+        if not if_match:
+            raise ValueError('if_match must be provided')
+        if contexts is not None:
+            contexts = [convert_model(x) for x in contexts]
+        if resources is not None:
+            resources = [convert_model(x) for x in resources]
+        if operations is not None:
+            operations = convert_model(operations)
+        headers = {
+            'If-Match': if_match,
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='replace_rule',
+        )
+        headers.update(sdk_headers)
+
+        data = {
+            'contexts': contexts,
+            'resources': resources,
+            'description': description,
+            'operations': operations,
+            'enforcement_mode': enforcement_mode,
+        }
+        data = {k: v for (k, v) in data.items() if v is not None}
+        data = json.dumps(data)
+        headers['content-type'] = 'application/json'
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['rule_id']
+        path_param_values = self.encode_path_vars(rule_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v1/rules/{rule_id}'.format(**path_param_dict)
+        request = self.prepare_request(
+            method='PUT',
+            url=url,
+            headers=headers,
+            data=data,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def delete_rule(
+        self,
+        rule_id: str,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Delete a rule.
+
+        This operation deletes the rule identified by the specified rule ID.
+
+        :param str rule_id: The ID of a rule.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse
+        """
+
+        if not rule_id:
+            raise ValueError('rule_id must be provided')
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='delete_rule',
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+
+        path_param_keys = ['rule_id']
+        path_param_values = self.encode_path_vars(rule_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v1/rules/{rule_id}'.format(**path_param_dict)
+        request = self.prepare_request(
+            method='DELETE',
+            url=url,
+            headers=headers,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    #########################
+    # Account settings
+    #########################
+
+    def get_account_settings(
+        self,
+        account_id: str,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Get account settings.
+
+        This operation retrieves the settings for the specified account ID.
+
+        :param str account_id: The ID of the account the settings are for.
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `AccountSettings` object
+        """
+
+        if not account_id:
+            raise ValueError('account_id must be provided')
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='get_account_settings',
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['account_id']
+        path_param_values = self.encode_path_vars(account_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v1/account_settings/{account_id}'.format(**path_param_dict)
+        request = self.prepare_request(
+            method='GET',
+            url=url,
+            headers=headers,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+    #########################
+    # operations
+    #########################
+
+    def list_available_service_operations(
+        self,
+        *,
+        x_correlation_id: Optional[str] = None,
+        transaction_id: Optional[str] = None,
+        service_name: Optional[str] = None,
+        service_group_id: Optional[str] = None,
+        resource_type: Optional[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        List available service operations.
+
+        This operation lists all available service operations.
+
+        :param str x_correlation_id: (optional) The supplied or generated value of
+               this header is logged for a request and repeated in a response header for
+               the corresponding response. The same value is used for downstream requests
+               and retries of those requests. If a value of this headers is not supplied
+               in a request, the service generates a random (version 4) UUID.
+        :param str transaction_id: (optional) Deprecated: The `Transaction-Id`
+               header behaves as the `X-Correlation-Id` header. It is supported for
+               backward compatibility with other IBM platform services that support the
+               `Transaction-Id` header only. If both `X-Correlation-Id` and
+               `Transaction-Id` are provided, `X-Correlation-Id` has the precedence over
+               `Transaction-Id`.
+        :param str service_name: (optional) The name of the service.
+        :param str service_group_id: (optional) The id of the service group.
+        :param str resource_type: (optional) The type of resource.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `dict` result representing a `OperationsList` object
+        """
+
+        headers = {
+            'X-Correlation-Id': x_correlation_id,
+            'Transaction-Id': transaction_id,
+        }
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME,
+            service_version='V1',
+            operation_id='list_available_service_operations',
+        )
+        headers.update(sdk_headers)
+
+        params = {
+            'service_name': service_name,
+            'service_group_id': service_group_id,
+            'resource_type': resource_type,
+        }
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        url = '/v1/operations'
+        request = self.prepare_request(
+            method='GET',
+            url=url,
+            headers=headers,
+            params=params,
+        )
+
+        response = self.send(request, **kwargs)
+        return response
+
+
+class ListAvailableServicerefTargetsEnums:
+    """
+    Enums for list_available_serviceref_targets parameters.
+    """
+
+    class Type(str, Enum):
+        """
+        Specifies the types of services to retrieve.
+        """
+
+        ALL = 'all'
+        PLATFORM_SERVICE = 'platform_service'
+
+
+class ListRulesEnums:
+    """
+    Enums for list_rules parameters.
+    """
+
+    class EnforcementMode(str, Enum):
+        """
+        The rule's `enforcement_mode` attribute.
+        """
+
+        ENABLED = 'enabled'
+        DISABLED = 'disabled'
+        REPORT = 'report'
+
+
+##############################################################################
+# Models
+##############################################################################
+
+
+class APIType:
+    """
+    Service API Type details.
+
+    :param str api_type_id: The id of the API type.
+    :param str display_name: The displayed name of the API type.
+    :param str description: The description of the API type.
+    :param str type: The type of the API type.
+    :param List[Action] actions: The actions available for the API type.
+    :param List[str] enforcement_modes: (optional) The enforcement modes supported
+          by the API type.
+    """
+
+    def __init__(
+        self,
+        api_type_id: str,
+        display_name: str,
+        description: str,
+        type: str,
+        actions: List['Action'],
+        *,
+        enforcement_modes: Optional[List[str]] = None,
+    ) -> None:
+        """
+        Initialize a APIType object.
+
+        :param str api_type_id: The id of the API type.
+        :param str display_name: The displayed name of the API type.
+        :param str description: The description of the API type.
+        :param str type: The type of the API type.
+        :param List[Action] actions: The actions available for the API type.
+        :param List[str] enforcement_modes: (optional) The enforcement modes
+               supported by the API type.
+        """
+        self.api_type_id = api_type_id
+        self.display_name = display_name
+        self.description = description
+        self.type = type
+        self.actions = actions
+        self.enforcement_modes = enforcement_modes
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'APIType':
+        """Initialize a APIType object from a json dictionary."""
+        args = {}
+        if (api_type_id := _dict.get('api_type_id')) is not None:
+            args['api_type_id'] = api_type_id
+        else:
+            raise ValueError('Required property \'api_type_id\' not present in APIType JSON')
+        if (display_name := _dict.get('display_name')) is not None:
+            args['display_name'] = display_name
+        else:
+            raise ValueError('Required property \'display_name\' not present in APIType JSON')
+        if (description := _dict.get('description')) is not None:
+            args['description'] = description
+        else:
+            raise ValueError('Required property \'description\' not present in APIType JSON')
+        if (type := _dict.get('type')) is not None:
+            args['type'] = type
+        else:
+            raise ValueError('Required property \'type\' not present in APIType JSON')
+        if (actions := _dict.get('actions')) is not None:
+            args['actions'] = [Action.from_dict(v) for v in actions]
+        else:
+            raise ValueError('Required property \'actions\' not present in APIType JSON')
+        if (enforcement_modes := _dict.get('enforcement_modes')) is not None:
+            args['enforcement_modes'] = enforcement_modes
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a APIType object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'api_type_id') and self.api_type_id is not None:
+            _dict['api_type_id'] = self.api_type_id
+        if hasattr(self, 'display_name') and self.display_name is not None:
+            _dict['display_name'] = self.display_name
+        if hasattr(self, 'description') and self.description is not None:
+            _dict['description'] = self.description
+        if hasattr(self, 'type') and self.type is not None:
+            _dict['type'] = self.type
+        if hasattr(self, 'actions') and self.actions is not None:
+            actions_list = []
+            for v in self.actions:
+                if isinstance(v, dict):
+                    actions_list.append(v)
+                else:
+                    actions_list.append(v.to_dict())
+            _dict['actions'] = actions_list
+        if hasattr(self, 'enforcement_modes') and self.enforcement_modes is not None:
+            _dict['enforcement_modes'] = self.enforcement_modes
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this APIType object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'APIType') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'APIType') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class AccountSettings:
+    """
+    An output account settings.
+
+    :param str id: The globally unique ID of the account settings.
+    :param str crn: The account settings CRN.
+    :param int rule_count_limit: the max number of rules allowed for the account.
+    :param int zone_count_limit: the max number of zones allowed for the account.
+    :param int tags_rule_count_limit: (optional) the max number of rules with tags
+          allowed for the account.
+    :param int current_rule_count: the current number of rules used by the account.
+    :param int current_zone_count: the current number of zones used by the account.
+    :param int current_tags_rule_count: (optional) the current number of rules with
+          tags used by the account.
+    :param str href: The href link to the resource.
+    :param datetime created_at: The time the resource was created.
+    :param str created_by_id: IAM ID of the user or service which created the
+          resource.
+    :param datetime last_modified_at: The last time the resource was modified.
+    :param str last_modified_by_id: IAM ID of the user or service which modified the
+          resource.
+    """
+
+    def __init__(
+        self,
+        id: str,
+        crn: str,
+        rule_count_limit: int,
+        zone_count_limit: int,
+        current_rule_count: int,
+        current_zone_count: int,
+        href: str,
+        created_at: datetime,
+        created_by_id: str,
+        last_modified_at: datetime,
+        last_modified_by_id: str,
+        *,
+        tags_rule_count_limit: Optional[int] = None,
+        current_tags_rule_count: Optional[int] = None,
+    ) -> None:
+        """
+        Initialize a AccountSettings object.
+
+        :param str id: The globally unique ID of the account settings.
+        :param str crn: The account settings CRN.
+        :param int rule_count_limit: the max number of rules allowed for the
+               account.
+        :param int zone_count_limit: the max number of zones allowed for the
+               account.
+        :param int current_rule_count: the current number of rules used by the
+               account.
+        :param int current_zone_count: the current number of zones used by the
+               account.
+        :param str href: The href link to the resource.
+        :param datetime created_at: The time the resource was created.
+        :param str created_by_id: IAM ID of the user or service which created the
+               resource.
+        :param datetime last_modified_at: The last time the resource was modified.
+        :param str last_modified_by_id: IAM ID of the user or service which
+               modified the resource.
+        :param int tags_rule_count_limit: (optional) the max number of rules with
+               tags allowed for the account.
+        :param int current_tags_rule_count: (optional) the current number of rules
+               with tags used by the account.
+        """
+        self.id = id
+        self.crn = crn
+        self.rule_count_limit = rule_count_limit
+        self.zone_count_limit = zone_count_limit
+        self.tags_rule_count_limit = tags_rule_count_limit
+        self.current_rule_count = current_rule_count
+        self.current_zone_count = current_zone_count
+        self.current_tags_rule_count = current_tags_rule_count
+        self.href = href
+        self.created_at = created_at
+        self.created_by_id = created_by_id
+        self.last_modified_at = last_modified_at
+        self.last_modified_by_id = last_modified_by_id
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'AccountSettings':
+        """Initialize a AccountSettings object from a json dictionary."""
+        args = {}
+        if (id := _dict.get('id')) is not None:
+            args['id'] = id
+        else:
+            raise ValueError('Required property \'id\' not present in AccountSettings JSON')
+        if (crn := _dict.get('crn')) is not None:
+            args['crn'] = crn
+        else:
+            raise ValueError('Required property \'crn\' not present in AccountSettings JSON')
+        if (rule_count_limit := _dict.get('rule_count_limit')) is not None:
+            args['rule_count_limit'] = rule_count_limit
+        else:
+            raise ValueError('Required property \'rule_count_limit\' not present in AccountSettings JSON')
+        if (zone_count_limit := _dict.get('zone_count_limit')) is not None:
+            args['zone_count_limit'] = zone_count_limit
+        else:
+            raise ValueError('Required property \'zone_count_limit\' not present in AccountSettings JSON')
+        if (tags_rule_count_limit := _dict.get('tags_rule_count_limit')) is not None:
+            args['tags_rule_count_limit'] = tags_rule_count_limit
+        if (current_rule_count := _dict.get('current_rule_count')) is not None:
+            args['current_rule_count'] = current_rule_count
+        else:
+            raise ValueError('Required property \'current_rule_count\' not present in AccountSettings JSON')
+        if (current_zone_count := _dict.get('current_zone_count')) is not None:
+            args['current_zone_count'] = current_zone_count
+        else:
+            raise ValueError('Required property \'current_zone_count\' not present in AccountSettings JSON')
+        if (current_tags_rule_count := _dict.get('current_tags_rule_count')) is not None:
+            args['current_tags_rule_count'] = current_tags_rule_count
+        if (href := _dict.get('href')) is not None:
+            args['href'] = href
+        else:
+            raise ValueError('Required property \'href\' not present in AccountSettings JSON')
+        if (created_at := _dict.get('created_at')) is not None:
+            args['created_at'] = string_to_datetime(created_at)
+        else:
+            raise ValueError('Required property \'created_at\' not present in AccountSettings JSON')
+        if (created_by_id := _dict.get('created_by_id')) is not None:
+            args['created_by_id'] = created_by_id
+        else:
+            raise ValueError('Required property \'created_by_id\' not present in AccountSettings JSON')
+        if (last_modified_at := _dict.get('last_modified_at')) is not None:
+            args['last_modified_at'] = string_to_datetime(last_modified_at)
+        else:
+            raise ValueError('Required property \'last_modified_at\' not present in AccountSettings JSON')
+        if (last_modified_by_id := _dict.get('last_modified_by_id')) is not None:
+            args['last_modified_by_id'] = last_modified_by_id
+        else:
+            raise ValueError('Required property \'last_modified_by_id\' not present in AccountSettings JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a AccountSettings object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'id') and self.id is not None:
+            _dict['id'] = self.id
+        if hasattr(self, 'crn') and self.crn is not None:
+            _dict['crn'] = self.crn
+        if hasattr(self, 'rule_count_limit') and self.rule_count_limit is not None:
+            _dict['rule_count_limit'] = self.rule_count_limit
+        if hasattr(self, 'zone_count_limit') and self.zone_count_limit is not None:
+            _dict['zone_count_limit'] = self.zone_count_limit
+        if hasattr(self, 'tags_rule_count_limit') and self.tags_rule_count_limit is not None:
+            _dict['tags_rule_count_limit'] = self.tags_rule_count_limit
+        if hasattr(self, 'current_rule_count') and self.current_rule_count is not None:
+            _dict['current_rule_count'] = self.current_rule_count
+        if hasattr(self, 'current_zone_count') and self.current_zone_count is not None:
+            _dict['current_zone_count'] = self.current_zone_count
+        if hasattr(self, 'current_tags_rule_count') and self.current_tags_rule_count is not None:
+            _dict['current_tags_rule_count'] = self.current_tags_rule_count
+        if hasattr(self, 'href') and self.href is not None:
+            _dict['href'] = self.href
+        if hasattr(self, 'created_at') and self.created_at is not None:
+            _dict['created_at'] = datetime_to_string(self.created_at)
+        if hasattr(self, 'created_by_id') and self.created_by_id is not None:
+            _dict['created_by_id'] = self.created_by_id
+        if hasattr(self, 'last_modified_at') and self.last_modified_at is not None:
+            _dict['last_modified_at'] = datetime_to_string(self.last_modified_at)
+        if hasattr(self, 'last_modified_by_id') and self.last_modified_by_id is not None:
+            _dict['last_modified_by_id'] = self.last_modified_by_id
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this AccountSettings object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'AccountSettings') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'AccountSettings') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Action:
+    """
+    Service API Type actions.
+
+    :param str action_id: The id of the action.
+    :param str description: The description of the action.
+    """
+
+    def __init__(
+        self,
+        action_id: str,
+        description: str,
+    ) -> None:
+        """
+        Initialize a Action object.
+
+        :param str action_id: The id of the action.
+        :param str description: The description of the action.
+        """
+        self.action_id = action_id
+        self.description = description
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Action':
+        """Initialize a Action object from a json dictionary."""
+        args = {}
+        if (action_id := _dict.get('action_id')) is not None:
+            args['action_id'] = action_id
+        else:
+            raise ValueError('Required property \'action_id\' not present in Action JSON')
+        if (description := _dict.get('description')) is not None:
+            args['description'] = description
+        else:
+            raise ValueError('Required property \'description\' not present in Action JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Action object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'action_id') and self.action_id is not None:
+            _dict['action_id'] = self.action_id
+        if hasattr(self, 'description') and self.description is not None:
+            _dict['description'] = self.description
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this Action object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Action') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'Action') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Address:
+    """
+    A zone address.
+
+    :param str type: (optional) The type of address.
+    """
+
+    def __init__(
+        self,
+        *,
+        type: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize a Address object.
+
+        :param str type: (optional) The type of address.
+        """
+        msg = "Cannot instantiate base class. Instead, instantiate one of the defined subclasses: {0}".format(
+            ", ".join(['AddressIPAddress', 'AddressIPAddressRange', 'AddressSubnet', 'AddressVPC', 'AddressServiceRef'])
+        )
+        raise Exception(msg)
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Address':
+        """Initialize a Address object from a json dictionary."""
+        disc_class = cls._get_class_by_discriminator(_dict)
+        if disc_class != cls:
+            return disc_class.from_dict(_dict)
+        msg = "Cannot convert dictionary into an instance of base class 'Address'. The discriminator value should map to a valid subclass: {1}".format(
+            ", ".join(['AddressIPAddress', 'AddressIPAddressRange', 'AddressSubnet', 'AddressVPC', 'AddressServiceRef'])
+        )
+        raise Exception(msg)
+
+    @classmethod
+    def _from_dict(cls, _dict: Dict):
+        """Initialize a Address object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    @classmethod
+    def _get_class_by_discriminator(cls, _dict: Dict) -> object:
+        mapping = {}
+        mapping['ipAddress'] = 'AddressIPAddress'
+        mapping['ipRange'] = 'AddressIPAddressRange'
+        mapping['subnet'] = 'AddressSubnet'
+        mapping['vpc'] = 'AddressVPC'
+        mapping['serviceRef'] = 'AddressServiceRef'
+        disc_value = _dict.get('type')
+        if disc_value is None:
+            raise ValueError('Discriminator property \'type\' not found in Address JSON')
+        class_name = mapping.get(disc_value, disc_value)
+        try:
+            disc_class = getattr(sys.modules[__name__], class_name)
+        except AttributeError:
+            disc_class = cls
+        if isinstance(disc_class, object):
+            return disc_class
+        raise TypeError('%s is not a discriminator class' % class_name)
+
+    class TypeEnum(str, Enum):
+        """
+        The type of address.
+        """
+
+        IPADDRESS = 'ipAddress'
+        IPRANGE = 'ipRange'
+        SUBNET = 'subnet'
+        VPC = 'vpc'
+        SERVICEREF = 'serviceRef'
+
+
+class NewRuleOperations:
+    """
+    The operations this rule applies to.
+
+    :param List[NewRuleOperationsApiTypesItem] api_types: The API types this rule
+          applies to.
+    """
+
+    def __init__(
+        self,
+        api_types: List['NewRuleOperationsApiTypesItem'],
+    ) -> None:
+        """
+        Initialize a NewRuleOperations object.
+
+        :param List[NewRuleOperationsApiTypesItem] api_types: The API types this
+               rule applies to.
+        """
+        self.api_types = api_types
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'NewRuleOperations':
+        """Initialize a NewRuleOperations object from a json dictionary."""
+        args = {}
+        if (api_types := _dict.get('api_types')) is not None:
+            args['api_types'] = [NewRuleOperationsApiTypesItem.from_dict(v) for v in api_types]
+        else:
+            raise ValueError('Required property \'api_types\' not present in NewRuleOperations JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a NewRuleOperations object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'api_types') and self.api_types is not None:
+            api_types_list = []
+            for v in self.api_types:
+                if isinstance(v, dict):
+                    api_types_list.append(v)
+                else:
+                    api_types_list.append(v.to_dict())
+            _dict['api_types'] = api_types_list
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this NewRuleOperations object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'NewRuleOperations') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'NewRuleOperations') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class NewRuleOperationsApiTypesItem:
+    """
+    NewRuleOperationsApiTypesItem.
+
+    :param str api_type_id:
+    """
+
+    def __init__(
+        self,
+        api_type_id: str,
+    ) -> None:
+        """
+        Initialize a NewRuleOperationsApiTypesItem object.
+
+        :param str api_type_id:
+        """
+        self.api_type_id = api_type_id
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'NewRuleOperationsApiTypesItem':
+        """Initialize a NewRuleOperationsApiTypesItem object from a json dictionary."""
+        args = {}
+        if (api_type_id := _dict.get('api_type_id')) is not None:
+            args['api_type_id'] = api_type_id
+        else:
+            raise ValueError('Required property \'api_type_id\' not present in NewRuleOperationsApiTypesItem JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a NewRuleOperationsApiTypesItem object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'api_type_id') and self.api_type_id is not None:
+            _dict['api_type_id'] = self.api_type_id
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this NewRuleOperationsApiTypesItem object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'NewRuleOperationsApiTypesItem') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'NewRuleOperationsApiTypesItem') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class OperationsList:
+    """
+    The response object of the `list_available_service_operations` operation.
+
+    :param List[APIType] api_types: The returned API types.
+    """
+
+    def __init__(
+        self,
+        api_types: List['APIType'],
+    ) -> None:
+        """
+        Initialize a OperationsList object.
+
+        :param List[APIType] api_types: The returned API types.
+        """
+        self.api_types = api_types
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'OperationsList':
+        """Initialize a OperationsList object from a json dictionary."""
+        args = {}
+        if (api_types := _dict.get('api_types')) is not None:
+            args['api_types'] = [APIType.from_dict(v) for v in api_types]
+        else:
+            raise ValueError('Required property \'api_types\' not present in OperationsList JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a OperationsList object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'api_types') and self.api_types is not None:
+            api_types_list = []
+            for v in self.api_types:
+                if isinstance(v, dict):
+                    api_types_list.append(v)
+                else:
+                    api_types_list.append(v.to_dict())
+            _dict['api_types'] = api_types_list
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this OperationsList object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'OperationsList') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'OperationsList') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Resource:
+    """
+    An rule resource.
+
+    :param List[ResourceAttribute] attributes: The resource attributes.
+    :param List[ResourceTagAttribute] tags: (optional) The optional resource tags.
+    """
+
+    def __init__(
+        self,
+        attributes: List['ResourceAttribute'],
+        *,
+        tags: Optional[List['ResourceTagAttribute']] = None,
+    ) -> None:
+        """
+        Initialize a Resource object.
+
+        :param List[ResourceAttribute] attributes: The resource attributes.
+        :param List[ResourceTagAttribute] tags: (optional) The optional resource
+               tags.
+        """
+        self.attributes = attributes
+        self.tags = tags
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Resource':
+        """Initialize a Resource object from a json dictionary."""
+        args = {}
+        if (attributes := _dict.get('attributes')) is not None:
+            args['attributes'] = [ResourceAttribute.from_dict(v) for v in attributes]
+        else:
+            raise ValueError('Required property \'attributes\' not present in Resource JSON')
+        if (tags := _dict.get('tags')) is not None:
+            args['tags'] = [ResourceTagAttribute.from_dict(v) for v in tags]
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Resource object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'attributes') and self.attributes is not None:
+            attributes_list = []
+            for v in self.attributes:
+                if isinstance(v, dict):
+                    attributes_list.append(v)
+                else:
+                    attributes_list.append(v.to_dict())
+            _dict['attributes'] = attributes_list
+        if hasattr(self, 'tags') and self.tags is not None:
+            tags_list = []
+            for v in self.tags:
+                if isinstance(v, dict):
+                    tags_list.append(v)
+                else:
+                    tags_list.append(v.to_dict())
+            _dict['tags'] = tags_list
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this Resource object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Resource') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'Resource') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class ResourceAttribute:
+    """
+    A rule resource attribute.
+
+    :param str name: The attribute name.
+    :param str value: The attribute value.
+    :param str operator: (optional) The attribute operator.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        value: str,
+        *,
+        operator: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize a ResourceAttribute object.
+
+        :param str name: The attribute name.
+        :param str value: The attribute value.
+        :param str operator: (optional) The attribute operator.
+        """
+        self.name = name
+        self.value = value
+        self.operator = operator
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ResourceAttribute':
+        """Initialize a ResourceAttribute object from a json dictionary."""
+        args = {}
+        if (name := _dict.get('name')) is not None:
+            args['name'] = name
+        else:
+            raise ValueError('Required property \'name\' not present in ResourceAttribute JSON')
+        if (value := _dict.get('value')) is not None:
+            args['value'] = value
+        else:
+            raise ValueError('Required property \'value\' not present in ResourceAttribute JSON')
+        if (operator := _dict.get('operator')) is not None:
+            args['operator'] = operator
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ResourceAttribute object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'name') and self.name is not None:
+            _dict['name'] = self.name
+        if hasattr(self, 'value') and self.value is not None:
+            _dict['value'] = self.value
+        if hasattr(self, 'operator') and self.operator is not None:
+            _dict['operator'] = self.operator
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this ResourceAttribute object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ResourceAttribute') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'ResourceAttribute') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class ResourceTagAttribute:
+    """
+    A rule resource tag attribute.
+
+    :param str name: The tag attribute name.
+    :param str value: The tag attribute value.
+    :param str operator: (optional) The attribute operator.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        value: str,
+        *,
+        operator: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize a ResourceTagAttribute object.
+
+        :param str name: The tag attribute name.
+        :param str value: The tag attribute value.
+        :param str operator: (optional) The attribute operator.
+        """
+        self.name = name
+        self.value = value
+        self.operator = operator
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ResourceTagAttribute':
+        """Initialize a ResourceTagAttribute object from a json dictionary."""
+        args = {}
+        if (name := _dict.get('name')) is not None:
+            args['name'] = name
+        else:
+            raise ValueError('Required property \'name\' not present in ResourceTagAttribute JSON')
+        if (value := _dict.get('value')) is not None:
+            args['value'] = value
+        else:
+            raise ValueError('Required property \'value\' not present in ResourceTagAttribute JSON')
+        if (operator := _dict.get('operator')) is not None:
+            args['operator'] = operator
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ResourceTagAttribute object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'name') and self.name is not None:
+            _dict['name'] = self.name
+        if hasattr(self, 'value') and self.value is not None:
+            _dict['value'] = self.value
+        if hasattr(self, 'operator') and self.operator is not None:
+            _dict['operator'] = self.operator
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this ResourceTagAttribute object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ResourceTagAttribute') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'ResourceTagAttribute') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Rule:
+    """
+    An output rule.
+
+    :param str id: The globally unique ID of the rule.
+    :param str crn: The rule CRN.
+    :param str description: The description of the rule.
+    :param List[RuleContext] contexts: The contexts this rule applies to.
+    :param List[Resource] resources: The resources this rule apply to.
+    :param NewRuleOperations operations: (optional) The operations this rule applies
+          to.
+    :param str enforcement_mode: (optional) The rule enforcement mode:
+           * `enabled` - The restrictions are enforced and reported. This is the default.
+           * `disabled` - The restrictions are disabled. Nothing is enforced or reported.
+           * `report` - The restrictions are evaluated and reported, but not enforced.
+    :param str href: The href link to the resource.
+    :param datetime created_at: The time the resource was created.
+    :param str created_by_id: IAM ID of the user or service which created the
+          resource.
+    :param datetime last_modified_at: The last time the resource was modified.
+    :param str last_modified_by_id: IAM ID of the user or service which modified the
+          resource.
+    """
+
+    def __init__(
+        self,
+        id: str,
+        crn: str,
+        description: str,
+        contexts: List['RuleContext'],
+        resources: List['Resource'],
+        href: str,
+        created_at: datetime,
+        created_by_id: str,
+        last_modified_at: datetime,
+        last_modified_by_id: str,
+        *,
+        operations: Optional['NewRuleOperations'] = None,
+        enforcement_mode: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize a Rule object.
+
+        :param str id: The globally unique ID of the rule.
+        :param str crn: The rule CRN.
+        :param str description: The description of the rule.
+        :param List[RuleContext] contexts: The contexts this rule applies to.
+        :param List[Resource] resources: The resources this rule apply to.
+        :param str href: The href link to the resource.
+        :param datetime created_at: The time the resource was created.
+        :param str created_by_id: IAM ID of the user or service which created the
+               resource.
+        :param datetime last_modified_at: The last time the resource was modified.
+        :param str last_modified_by_id: IAM ID of the user or service which
+               modified the resource.
+        :param NewRuleOperations operations: (optional) The operations this rule
+               applies to.
+        :param str enforcement_mode: (optional) The rule enforcement mode:
+                * `enabled` - The restrictions are enforced and reported. This is the
+               default.
+                * `disabled` - The restrictions are disabled. Nothing is enforced or
+               reported.
+                * `report` - The restrictions are evaluated and reported, but not
+               enforced.
+        """
+        self.id = id
+        self.crn = crn
+        self.description = description
+        self.contexts = contexts
+        self.resources = resources
+        self.operations = operations
+        self.enforcement_mode = enforcement_mode
+        self.href = href
+        self.created_at = created_at
+        self.created_by_id = created_by_id
+        self.last_modified_at = last_modified_at
+        self.last_modified_by_id = last_modified_by_id
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Rule':
+        """Initialize a Rule object from a json dictionary."""
+        args = {}
+        if (id := _dict.get('id')) is not None:
+            args['id'] = id
+        else:
+            raise ValueError('Required property \'id\' not present in Rule JSON')
+        if (crn := _dict.get('crn')) is not None:
+            args['crn'] = crn
+        else:
+            raise ValueError('Required property \'crn\' not present in Rule JSON')
+        if (description := _dict.get('description')) is not None:
+            args['description'] = description
+        else:
+            raise ValueError('Required property \'description\' not present in Rule JSON')
+        if (contexts := _dict.get('contexts')) is not None:
+            args['contexts'] = [RuleContext.from_dict(v) for v in contexts]
+        else:
+            raise ValueError('Required property \'contexts\' not present in Rule JSON')
+        if (resources := _dict.get('resources')) is not None:
+            args['resources'] = [Resource.from_dict(v) for v in resources]
+        else:
+            raise ValueError('Required property \'resources\' not present in Rule JSON')
+        if (operations := _dict.get('operations')) is not None:
+            args['operations'] = NewRuleOperations.from_dict(operations)
+        if (enforcement_mode := _dict.get('enforcement_mode')) is not None:
+            args['enforcement_mode'] = enforcement_mode
+        if (href := _dict.get('href')) is not None:
+            args['href'] = href
+        else:
+            raise ValueError('Required property \'href\' not present in Rule JSON')
+        if (created_at := _dict.get('created_at')) is not None:
+            args['created_at'] = string_to_datetime(created_at)
+        else:
+            raise ValueError('Required property \'created_at\' not present in Rule JSON')
+        if (created_by_id := _dict.get('created_by_id')) is not None:
+            args['created_by_id'] = created_by_id
+        else:
+            raise ValueError('Required property \'created_by_id\' not present in Rule JSON')
+        if (last_modified_at := _dict.get('last_modified_at')) is not None:
+            args['last_modified_at'] = string_to_datetime(last_modified_at)
+        else:
+            raise ValueError('Required property \'last_modified_at\' not present in Rule JSON')
+        if (last_modified_by_id := _dict.get('last_modified_by_id')) is not None:
+            args['last_modified_by_id'] = last_modified_by_id
+        else:
+            raise ValueError('Required property \'last_modified_by_id\' not present in Rule JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Rule object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'id') and self.id is not None:
+            _dict['id'] = self.id
+        if hasattr(self, 'crn') and self.crn is not None:
+            _dict['crn'] = self.crn
+        if hasattr(self, 'description') and self.description is not None:
+            _dict['description'] = self.description
+        if hasattr(self, 'contexts') and self.contexts is not None:
+            contexts_list = []
+            for v in self.contexts:
+                if isinstance(v, dict):
+                    contexts_list.append(v)
+                else:
+                    contexts_list.append(v.to_dict())
+            _dict['contexts'] = contexts_list
+        if hasattr(self, 'resources') and self.resources is not None:
+            resources_list = []
+            for v in self.resources:
+                if isinstance(v, dict):
+                    resources_list.append(v)
+                else:
+                    resources_list.append(v.to_dict())
+            _dict['resources'] = resources_list
+        if hasattr(self, 'operations') and self.operations is not None:
+            if isinstance(self.operations, dict):
+                _dict['operations'] = self.operations
+            else:
+                _dict['operations'] = self.operations.to_dict()
+        if hasattr(self, 'enforcement_mode') and self.enforcement_mode is not None:
+            _dict['enforcement_mode'] = self.enforcement_mode
+        if hasattr(self, 'href') and self.href is not None:
+            _dict['href'] = self.href
+        if hasattr(self, 'created_at') and self.created_at is not None:
+            _dict['created_at'] = datetime_to_string(self.created_at)
+        if hasattr(self, 'created_by_id') and self.created_by_id is not None:
+            _dict['created_by_id'] = self.created_by_id
+        if hasattr(self, 'last_modified_at') and self.last_modified_at is not None:
+            _dict['last_modified_at'] = datetime_to_string(self.last_modified_at)
+        if hasattr(self, 'last_modified_by_id') and self.last_modified_by_id is not None:
+            _dict['last_modified_by_id'] = self.last_modified_by_id
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this Rule object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Rule') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'Rule') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class EnforcementModeEnum(str, Enum):
+        """
+        The rule enforcement mode:
+         * `enabled` - The restrictions are enforced and reported. This is the default.
+         * `disabled` - The restrictions are disabled. Nothing is enforced or reported.
+         * `report` - The restrictions are evaluated and reported, but not enforced.
+        """
+
+        ENABLED = 'enabled'
+        DISABLED = 'disabled'
+        REPORT = 'report'
+
+
+class RuleContext:
+    """
+    A rule context.
+
+    :param List[RuleContextAttribute] attributes: The attributes.
+    """
+
+    def __init__(
+        self,
+        attributes: List['RuleContextAttribute'],
+    ) -> None:
+        """
+        Initialize a RuleContext object.
+
+        :param List[RuleContextAttribute] attributes: The attributes.
+        """
+        self.attributes = attributes
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'RuleContext':
+        """Initialize a RuleContext object from a json dictionary."""
+        args = {}
+        if (attributes := _dict.get('attributes')) is not None:
+            args['attributes'] = [RuleContextAttribute.from_dict(v) for v in attributes]
+        else:
+            raise ValueError('Required property \'attributes\' not present in RuleContext JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a RuleContext object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'attributes') and self.attributes is not None:
+            attributes_list = []
+            for v in self.attributes:
+                if isinstance(v, dict):
+                    attributes_list.append(v)
+                else:
+                    attributes_list.append(v.to_dict())
+            _dict['attributes'] = attributes_list
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this RuleContext object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'RuleContext') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'RuleContext') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class RuleContextAttribute:
+    """
+    An rule context attribute.
+
+    :param str name: The attribute name.
+    :param str value: The attribute value.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        value: str,
+    ) -> None:
+        """
+        Initialize a RuleContextAttribute object.
+
+        :param str name: The attribute name.
+        :param str value: The attribute value.
+        """
+        self.name = name
+        self.value = value
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'RuleContextAttribute':
+        """Initialize a RuleContextAttribute object from a json dictionary."""
+        args = {}
+        if (name := _dict.get('name')) is not None:
+            args['name'] = name
+        else:
+            raise ValueError('Required property \'name\' not present in RuleContextAttribute JSON')
+        if (value := _dict.get('value')) is not None:
+            args['value'] = value
+        else:
+            raise ValueError('Required property \'value\' not present in RuleContextAttribute JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a RuleContextAttribute object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'name') and self.name is not None:
+            _dict['name'] = self.name
+        if hasattr(self, 'value') and self.value is not None:
+            _dict['value'] = self.value
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this RuleContextAttribute object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'RuleContextAttribute') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'RuleContextAttribute') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class RuleList:
+    """
+    The response object of the ListRules operation.
+
+    :param int count: The number of returned results.
+    :param List[Rule] rules: The returned rules.
+    """
+
+    def __init__(
+        self,
+        count: int,
+        rules: List['Rule'],
+    ) -> None:
+        """
+        Initialize a RuleList object.
+
+        :param int count: The number of returned results.
+        :param List[Rule] rules: The returned rules.
+        """
+        self.count = count
+        self.rules = rules
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'RuleList':
+        """Initialize a RuleList object from a json dictionary."""
+        args = {}
+        if (count := _dict.get('count')) is not None:
+            args['count'] = count
+        else:
+            raise ValueError('Required property \'count\' not present in RuleList JSON')
+        if (rules := _dict.get('rules')) is not None:
+            args['rules'] = [Rule.from_dict(v) for v in rules]
+        else:
+            raise ValueError('Required property \'rules\' not present in RuleList JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a RuleList object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'count') and self.count is not None:
+            _dict['count'] = self.count
+        if hasattr(self, 'rules') and self.rules is not None:
+            rules_list = []
+            for v in self.rules:
+                if isinstance(v, dict):
+                    rules_list.append(v)
+                else:
+                    rules_list.append(v.to_dict())
+            _dict['rules'] = rules_list
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this RuleList object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'RuleList') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'RuleList') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class ServiceRefTarget:
+    """
+    Summary information about a service reference target.
+
+    :param str service_name: The name of the service.
+    :param str service_type: (optional) The type of the service.
+    :param List[ServiceRefTargetLocationsItem] locations: (optional) The locations
+          the service is available.
+    """
+
+    def __init__(
+        self,
+        service_name: str,
+        *,
+        service_type: Optional[str] = None,
+        locations: Optional[List['ServiceRefTargetLocationsItem']] = None,
+    ) -> None:
+        """
+        Initialize a ServiceRefTarget object.
+
+        :param str service_name: The name of the service.
+        :param str service_type: (optional) The type of the service.
+        :param List[ServiceRefTargetLocationsItem] locations: (optional) The
+               locations the service is available.
+        """
+        self.service_name = service_name
+        self.service_type = service_type
+        self.locations = locations
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ServiceRefTarget':
+        """Initialize a ServiceRefTarget object from a json dictionary."""
+        args = {}
+        if (service_name := _dict.get('service_name')) is not None:
+            args['service_name'] = service_name
+        else:
+            raise ValueError('Required property \'service_name\' not present in ServiceRefTarget JSON')
+        if (service_type := _dict.get('service_type')) is not None:
+            args['service_type'] = service_type
+        if (locations := _dict.get('locations')) is not None:
+            args['locations'] = [ServiceRefTargetLocationsItem.from_dict(v) for v in locations]
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ServiceRefTarget object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'service_name') and self.service_name is not None:
+            _dict['service_name'] = self.service_name
+        if hasattr(self, 'service_type') and self.service_type is not None:
+            _dict['service_type'] = self.service_type
+        if hasattr(self, 'locations') and self.locations is not None:
+            locations_list = []
+            for v in self.locations:
+                if isinstance(v, dict):
+                    locations_list.append(v)
+                else:
+                    locations_list.append(v.to_dict())
+            _dict['locations'] = locations_list
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this ServiceRefTarget object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ServiceRefTarget') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'ServiceRefTarget') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class ServiceRefTargetList:
+    """
+    A list of service reference targets.
+
+    :param int count: The number of returned results.
+    :param List[ServiceRefTarget] targets: The list of service reference targets.
+    """
+
+    def __init__(
+        self,
+        count: int,
+        targets: List['ServiceRefTarget'],
+    ) -> None:
+        """
+        Initialize a ServiceRefTargetList object.
+
+        :param int count: The number of returned results.
+        :param List[ServiceRefTarget] targets: The list of service reference
+               targets.
+        """
+        self.count = count
+        self.targets = targets
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ServiceRefTargetList':
+        """Initialize a ServiceRefTargetList object from a json dictionary."""
+        args = {}
+        if (count := _dict.get('count')) is not None:
+            args['count'] = count
+        else:
+            raise ValueError('Required property \'count\' not present in ServiceRefTargetList JSON')
+        if (targets := _dict.get('targets')) is not None:
+            args['targets'] = [ServiceRefTarget.from_dict(v) for v in targets]
+        else:
+            raise ValueError('Required property \'targets\' not present in ServiceRefTargetList JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ServiceRefTargetList object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'count') and self.count is not None:
+            _dict['count'] = self.count
+        if hasattr(self, 'targets') and self.targets is not None:
+            targets_list = []
+            for v in self.targets:
+                if isinstance(v, dict):
+                    targets_list.append(v)
+                else:
+                    targets_list.append(v.to_dict())
+            _dict['targets'] = targets_list
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this ServiceRefTargetList object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ServiceRefTargetList') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'ServiceRefTargetList') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class ServiceRefTargetLocationsItem:
+    """
+    ServiceRefTargetLocationsItem.
+
+    :param str display_name: (optional) The location display name.
+    :param str kind: (optional) The location kind.
+    :param str name: The location name.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        display_name: Optional[str] = None,
+        kind: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize a ServiceRefTargetLocationsItem object.
+
+        :param str name: The location name.
+        :param str display_name: (optional) The location display name.
+        :param str kind: (optional) The location kind.
+        """
+        self.display_name = display_name
+        self.kind = kind
+        self.name = name
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ServiceRefTargetLocationsItem':
+        """Initialize a ServiceRefTargetLocationsItem object from a json dictionary."""
+        args = {}
+        if (display_name := _dict.get('display_name')) is not None:
+            args['display_name'] = display_name
+        if (kind := _dict.get('kind')) is not None:
+            args['kind'] = kind
+        if (name := _dict.get('name')) is not None:
+            args['name'] = name
+        else:
+            raise ValueError('Required property \'name\' not present in ServiceRefTargetLocationsItem JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ServiceRefTargetLocationsItem object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'display_name') and self.display_name is not None:
+            _dict['display_name'] = self.display_name
+        if hasattr(self, 'kind') and self.kind is not None:
+            _dict['kind'] = self.kind
+        if hasattr(self, 'name') and self.name is not None:
+            _dict['name'] = self.name
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this ServiceRefTargetLocationsItem object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ServiceRefTargetLocationsItem') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'ServiceRefTargetLocationsItem') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class ServiceRefValue:
+    """
+    A service reference value.
+
+    :param str account_id: The id of the account owning the service.
+    :param str service_type: (optional) The service type.
+    :param str service_name: (optional) The service name.
+    :param str service_instance: (optional) The service instance.
+    :param str location: (optional) The location.
+    """
+
+    def __init__(
+        self,
+        account_id: str,
+        *,
+        service_type: Optional[str] = None,
+        service_name: Optional[str] = None,
+        service_instance: Optional[str] = None,
+        location: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize a ServiceRefValue object.
+
+        :param str account_id: The id of the account owning the service.
+        :param str service_type: (optional) The service type.
+        :param str service_name: (optional) The service name.
+        :param str service_instance: (optional) The service instance.
+        :param str location: (optional) The location.
+        """
+        self.account_id = account_id
+        self.service_type = service_type
+        self.service_name = service_name
+        self.service_instance = service_instance
+        self.location = location
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ServiceRefValue':
+        """Initialize a ServiceRefValue object from a json dictionary."""
+        args = {}
+        if (account_id := _dict.get('account_id')) is not None:
+            args['account_id'] = account_id
+        else:
+            raise ValueError('Required property \'account_id\' not present in ServiceRefValue JSON')
+        if (service_type := _dict.get('service_type')) is not None:
+            args['service_type'] = service_type
+        if (service_name := _dict.get('service_name')) is not None:
+            args['service_name'] = service_name
+        if (service_instance := _dict.get('service_instance')) is not None:
+            args['service_instance'] = service_instance
+        if (location := _dict.get('location')) is not None:
+            args['location'] = location
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ServiceRefValue object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'account_id') and self.account_id is not None:
+            _dict['account_id'] = self.account_id
+        if hasattr(self, 'service_type') and self.service_type is not None:
+            _dict['service_type'] = self.service_type
+        if hasattr(self, 'service_name') and self.service_name is not None:
+            _dict['service_name'] = self.service_name
+        if hasattr(self, 'service_instance') and self.service_instance is not None:
+            _dict['service_instance'] = self.service_instance
+        if hasattr(self, 'location') and self.location is not None:
+            _dict['location'] = self.location
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this ServiceRefValue object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ServiceRefValue') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'ServiceRefValue') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Zone:
+    """
+    An output zone.
+
+    :param str id: The globally unique ID of the zone.
+    :param str crn: The zone CRN.
+    :param int address_count: The number of addresses in the zone.
+    :param int excluded_count: The number of excluded addresses in the zone.
+    :param str name: The name of the zone.
+    :param str account_id: The id of the account owning this zone.
+    :param str description: The description of the zone.
+    :param List[Address] addresses: The list of addresses in the zone.
+    :param List[Address] excluded: The list of excluded addresses in the zone. Only
+          addresses of type `ipAddress`, `ipRange`, and `subnet` can be excluded.
+    :param str href: The href link to the resource.
+    :param datetime created_at: The time the resource was created.
+    :param str created_by_id: IAM ID of the user or service which created the
+          resource.
+    :param datetime last_modified_at: The last time the resource was modified.
+    :param str last_modified_by_id: IAM ID of the user or service which modified the
+          resource.
+    """
+
+    def __init__(
+        self,
+        id: str,
+        crn: str,
+        address_count: int,
+        excluded_count: int,
+        name: str,
+        account_id: str,
+        description: str,
+        addresses: List['Address'],
+        excluded: List['Address'],
+        href: str,
+        created_at: datetime,
+        created_by_id: str,
+        last_modified_at: datetime,
+        last_modified_by_id: str,
+    ) -> None:
+        """
+        Initialize a Zone object.
+
+        :param str id: The globally unique ID of the zone.
+        :param str crn: The zone CRN.
+        :param int address_count: The number of addresses in the zone.
+        :param int excluded_count: The number of excluded addresses in the zone.
+        :param str name: The name of the zone.
+        :param str account_id: The id of the account owning this zone.
+        :param str description: The description of the zone.
+        :param List[Address] addresses: The list of addresses in the zone.
+        :param List[Address] excluded: The list of excluded addresses in the zone.
+               Only addresses of type `ipAddress`, `ipRange`, and `subnet` can be
+               excluded.
+        :param str href: The href link to the resource.
+        :param datetime created_at: The time the resource was created.
+        :param str created_by_id: IAM ID of the user or service which created the
+               resource.
+        :param datetime last_modified_at: The last time the resource was modified.
+        :param str last_modified_by_id: IAM ID of the user or service which
+               modified the resource.
+        """
+        self.id = id
+        self.crn = crn
+        self.address_count = address_count
+        self.excluded_count = excluded_count
+        self.name = name
+        self.account_id = account_id
+        self.description = description
+        self.addresses = addresses
+        self.excluded = excluded
+        self.href = href
+        self.created_at = created_at
+        self.created_by_id = created_by_id
+        self.last_modified_at = last_modified_at
+        self.last_modified_by_id = last_modified_by_id
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Zone':
+        """Initialize a Zone object from a json dictionary."""
+        args = {}
+        if (id := _dict.get('id')) is not None:
+            args['id'] = id
+        else:
+            raise ValueError('Required property \'id\' not present in Zone JSON')
+        if (crn := _dict.get('crn')) is not None:
+            args['crn'] = crn
+        else:
+            raise ValueError('Required property \'crn\' not present in Zone JSON')
+        if (address_count := _dict.get('address_count')) is not None:
+            args['address_count'] = address_count
+        else:
+            raise ValueError('Required property \'address_count\' not present in Zone JSON')
+        if (excluded_count := _dict.get('excluded_count')) is not None:
+            args['excluded_count'] = excluded_count
+        else:
+            raise ValueError('Required property \'excluded_count\' not present in Zone JSON')
+        if (name := _dict.get('name')) is not None:
+            args['name'] = name
+        else:
+            raise ValueError('Required property \'name\' not present in Zone JSON')
+        if (account_id := _dict.get('account_id')) is not None:
+            args['account_id'] = account_id
+        else:
+            raise ValueError('Required property \'account_id\' not present in Zone JSON')
+        if (description := _dict.get('description')) is not None:
+            args['description'] = description
+        else:
+            raise ValueError('Required property \'description\' not present in Zone JSON')
+        if (addresses := _dict.get('addresses')) is not None:
+            args['addresses'] = [Address.from_dict(v) for v in addresses]
+        else:
+            raise ValueError('Required property \'addresses\' not present in Zone JSON')
+        if (excluded := _dict.get('excluded')) is not None:
+            args['excluded'] = [Address.from_dict(v) for v in excluded]
+        else:
+            raise ValueError('Required property \'excluded\' not present in Zone JSON')
+        if (href := _dict.get('href')) is not None:
+            args['href'] = href
+        else:
+            raise ValueError('Required property \'href\' not present in Zone JSON')
+        if (created_at := _dict.get('created_at')) is not None:
+            args['created_at'] = string_to_datetime(created_at)
+        else:
+            raise ValueError('Required property \'created_at\' not present in Zone JSON')
+        if (created_by_id := _dict.get('created_by_id')) is not None:
+            args['created_by_id'] = created_by_id
+        else:
+            raise ValueError('Required property \'created_by_id\' not present in Zone JSON')
+        if (last_modified_at := _dict.get('last_modified_at')) is not None:
+            args['last_modified_at'] = string_to_datetime(last_modified_at)
+        else:
+            raise ValueError('Required property \'last_modified_at\' not present in Zone JSON')
+        if (last_modified_by_id := _dict.get('last_modified_by_id')) is not None:
+            args['last_modified_by_id'] = last_modified_by_id
+        else:
+            raise ValueError('Required property \'last_modified_by_id\' not present in Zone JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Zone object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'id') and self.id is not None:
+            _dict['id'] = self.id
+        if hasattr(self, 'crn') and self.crn is not None:
+            _dict['crn'] = self.crn
+        if hasattr(self, 'address_count') and self.address_count is not None:
+            _dict['address_count'] = self.address_count
+        if hasattr(self, 'excluded_count') and self.excluded_count is not None:
+            _dict['excluded_count'] = self.excluded_count
+        if hasattr(self, 'name') and self.name is not None:
+            _dict['name'] = self.name
+        if hasattr(self, 'account_id') and self.account_id is not None:
+            _dict['account_id'] = self.account_id
+        if hasattr(self, 'description') and self.description is not None:
+            _dict['description'] = self.description
+        if hasattr(self, 'addresses') and self.addresses is not None:
+            addresses_list = []
+            for v in self.addresses:
+                if isinstance(v, dict):
+                    addresses_list.append(v)
+                else:
+                    addresses_list.append(v.to_dict())
+            _dict['addresses'] = addresses_list
+        if hasattr(self, 'excluded') and self.excluded is not None:
+            excluded_list = []
+            for v in self.excluded:
+                if isinstance(v, dict):
+                    excluded_list.append(v)
+                else:
+                    excluded_list.append(v.to_dict())
+            _dict['excluded'] = excluded_list
+        if hasattr(self, 'href') and self.href is not None:
+            _dict['href'] = self.href
+        if hasattr(self, 'created_at') and self.created_at is not None:
+            _dict['created_at'] = datetime_to_string(self.created_at)
+        if hasattr(self, 'created_by_id') and self.created_by_id is not None:
+            _dict['created_by_id'] = self.created_by_id
+        if hasattr(self, 'last_modified_at') and self.last_modified_at is not None:
+            _dict['last_modified_at'] = datetime_to_string(self.last_modified_at)
+        if hasattr(self, 'last_modified_by_id') and self.last_modified_by_id is not None:
+            _dict['last_modified_by_id'] = self.last_modified_by_id
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this Zone object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Zone') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'Zone') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class ZoneList:
+    """
+    The response object of the ListZones operation.
+
+    :param int count: The number of returned results.
+    :param List[ZoneSummary] zones: The returned zones.
+    """
+
+    def __init__(
+        self,
+        count: int,
+        zones: List['ZoneSummary'],
+    ) -> None:
+        """
+        Initialize a ZoneList object.
+
+        :param int count: The number of returned results.
+        :param List[ZoneSummary] zones: The returned zones.
+        """
+        self.count = count
+        self.zones = zones
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ZoneList':
+        """Initialize a ZoneList object from a json dictionary."""
+        args = {}
+        if (count := _dict.get('count')) is not None:
+            args['count'] = count
+        else:
+            raise ValueError('Required property \'count\' not present in ZoneList JSON')
+        if (zones := _dict.get('zones')) is not None:
+            args['zones'] = [ZoneSummary.from_dict(v) for v in zones]
+        else:
+            raise ValueError('Required property \'zones\' not present in ZoneList JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ZoneList object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'count') and self.count is not None:
+            _dict['count'] = self.count
+        if hasattr(self, 'zones') and self.zones is not None:
+            zones_list = []
+            for v in self.zones:
+                if isinstance(v, dict):
+                    zones_list.append(v)
+                else:
+                    zones_list.append(v.to_dict())
+            _dict['zones'] = zones_list
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this ZoneList object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ZoneList') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'ZoneList') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class ZoneSummary:
+    """
+    An output zone summary.
+
+    :param str id: The globally unique ID of the zone.
+    :param str crn: The zone CRN.
+    :param str name: The name of the zone.
+    :param str description: (optional) The description of the zone.
+    :param List[Address] addresses_preview: A preview of addresses in the zone (3
+          addresses maximum).
+    :param int address_count: The number of addresses in the zone.
+    :param int excluded_count: The number of excluded addresses in the zone.
+    :param str href: The href link to the resource.
+    :param datetime created_at: The time the resource was created.
+    :param str created_by_id: IAM ID of the user or service which created the
+          resource.
+    :param datetime last_modified_at: The last time the resource was modified.
+    :param str last_modified_by_id: IAM ID of the user or service which modified the
+          resource.
+    """
+
+    def __init__(
+        self,
+        id: str,
+        crn: str,
+        name: str,
+        addresses_preview: List['Address'],
+        address_count: int,
+        excluded_count: int,
+        href: str,
+        created_at: datetime,
+        created_by_id: str,
+        last_modified_at: datetime,
+        last_modified_by_id: str,
+        *,
+        description: Optional[str] = None,
+    ) -> None:
+        """
+        Initialize a ZoneSummary object.
+
+        :param str id: The globally unique ID of the zone.
+        :param str crn: The zone CRN.
+        :param str name: The name of the zone.
+        :param List[Address] addresses_preview: A preview of addresses in the zone
+               (3 addresses maximum).
+        :param int address_count: The number of addresses in the zone.
+        :param int excluded_count: The number of excluded addresses in the zone.
+        :param str href: The href link to the resource.
+        :param datetime created_at: The time the resource was created.
+        :param str created_by_id: IAM ID of the user or service which created the
+               resource.
+        :param datetime last_modified_at: The last time the resource was modified.
+        :param str last_modified_by_id: IAM ID of the user or service which
+               modified the resource.
+        :param str description: (optional) The description of the zone.
+        """
+        self.id = id
+        self.crn = crn
+        self.name = name
+        self.description = description
+        self.addresses_preview = addresses_preview
+        self.address_count = address_count
+        self.excluded_count = excluded_count
+        self.href = href
+        self.created_at = created_at
+        self.created_by_id = created_by_id
+        self.last_modified_at = last_modified_at
+        self.last_modified_by_id = last_modified_by_id
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ZoneSummary':
+        """Initialize a ZoneSummary object from a json dictionary."""
+        args = {}
+        if (id := _dict.get('id')) is not None:
+            args['id'] = id
+        else:
+            raise ValueError('Required property \'id\' not present in ZoneSummary JSON')
+        if (crn := _dict.get('crn')) is not None:
+            args['crn'] = crn
+        else:
+            raise ValueError('Required property \'crn\' not present in ZoneSummary JSON')
+        if (name := _dict.get('name')) is not None:
+            args['name'] = name
+        else:
+            raise ValueError('Required property \'name\' not present in ZoneSummary JSON')
+        if (description := _dict.get('description')) is not None:
+            args['description'] = description
+        if (addresses_preview := _dict.get('addresses_preview')) is not None:
+            args['addresses_preview'] = [Address.from_dict(v) for v in addresses_preview]
+        else:
+            raise ValueError('Required property \'addresses_preview\' not present in ZoneSummary JSON')
+        if (address_count := _dict.get('address_count')) is not None:
+            args['address_count'] = address_count
+        else:
+            raise ValueError('Required property \'address_count\' not present in ZoneSummary JSON')
+        if (excluded_count := _dict.get('excluded_count')) is not None:
+            args['excluded_count'] = excluded_count
+        else:
+            raise ValueError('Required property \'excluded_count\' not present in ZoneSummary JSON')
+        if (href := _dict.get('href')) is not None:
+            args['href'] = href
+        else:
+            raise ValueError('Required property \'href\' not present in ZoneSummary JSON')
+        if (created_at := _dict.get('created_at')) is not None:
+            args['created_at'] = string_to_datetime(created_at)
+        else:
+            raise ValueError('Required property \'created_at\' not present in ZoneSummary JSON')
+        if (created_by_id := _dict.get('created_by_id')) is not None:
+            args['created_by_id'] = created_by_id
+        else:
+            raise ValueError('Required property \'created_by_id\' not present in ZoneSummary JSON')
+        if (last_modified_at := _dict.get('last_modified_at')) is not None:
+            args['last_modified_at'] = string_to_datetime(last_modified_at)
+        else:
+            raise ValueError('Required property \'last_modified_at\' not present in ZoneSummary JSON')
+        if (last_modified_by_id := _dict.get('last_modified_by_id')) is not None:
+            args['last_modified_by_id'] = last_modified_by_id
+        else:
+            raise ValueError('Required property \'last_modified_by_id\' not present in ZoneSummary JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ZoneSummary object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'id') and self.id is not None:
+            _dict['id'] = self.id
+        if hasattr(self, 'crn') and self.crn is not None:
+            _dict['crn'] = self.crn
+        if hasattr(self, 'name') and self.name is not None:
+            _dict['name'] = self.name
+        if hasattr(self, 'description') and self.description is not None:
+            _dict['description'] = self.description
+        if hasattr(self, 'addresses_preview') and self.addresses_preview is not None:
+            addresses_preview_list = []
+            for v in self.addresses_preview:
+                if isinstance(v, dict):
+                    addresses_preview_list.append(v)
+                else:
+                    addresses_preview_list.append(v.to_dict())
+            _dict['addresses_preview'] = addresses_preview_list
+        if hasattr(self, 'address_count') and self.address_count is not None:
+            _dict['address_count'] = self.address_count
+        if hasattr(self, 'excluded_count') and self.excluded_count is not None:
+            _dict['excluded_count'] = self.excluded_count
+        if hasattr(self, 'href') and self.href is not None:
+            _dict['href'] = self.href
+        if hasattr(self, 'created_at') and self.created_at is not None:
+            _dict['created_at'] = datetime_to_string(self.created_at)
+        if hasattr(self, 'created_by_id') and self.created_by_id is not None:
+            _dict['created_by_id'] = self.created_by_id
+        if hasattr(self, 'last_modified_at') and self.last_modified_at is not None:
+            _dict['last_modified_at'] = datetime_to_string(self.last_modified_at)
+        if hasattr(self, 'last_modified_by_id') and self.last_modified_by_id is not None:
+            _dict['last_modified_by_id'] = self.last_modified_by_id
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this ZoneSummary object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ZoneSummary') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'ZoneSummary') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class AddressIPAddress(Address):
+    """
+    A single IP address. IPv4 and IPv6 are supported.
+
+    :param str type: The type of address.
+    :param str value: The IP address.
+    """
+
+    def __init__(
+        self,
+        type: str,
+        value: str,
+    ) -> None:
+        """
+        Initialize a AddressIPAddress object.
+
+        :param str type: The type of address.
+        :param str value: The IP address.
+        """
+        # pylint: disable=super-init-not-called
+        self.type = type
+        self.value = value
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'AddressIPAddress':
+        """Initialize a AddressIPAddress object from a json dictionary."""
+        args = {}
+        if (type := _dict.get('type')) is not None:
+            args['type'] = type
+        else:
+            raise ValueError('Required property \'type\' not present in AddressIPAddress JSON')
+        if (value := _dict.get('value')) is not None:
+            args['value'] = value
+        else:
+            raise ValueError('Required property \'value\' not present in AddressIPAddress JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a AddressIPAddress object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'type') and self.type is not None:
+            _dict['type'] = self.type
+        if hasattr(self, 'value') and self.value is not None:
+            _dict['value'] = self.value
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this AddressIPAddress object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'AddressIPAddress') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'AddressIPAddress') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class TypeEnum(str, Enum):
+        """
+        The type of address.
+        """
+
+        IPADDRESS = 'ipAddress'
+
+
+class AddressIPAddressRange(Address):
+    """
+    An IP address range. IPv4 and IPv6 are supported.
+
+    :param str type: The type of address.
+    :param str value: The ip range in <first-ip>-<last-ip> format.
+    """
+
+    def __init__(
+        self,
+        type: str,
+        value: str,
+    ) -> None:
+        """
+        Initialize a AddressIPAddressRange object.
+
+        :param str type: The type of address.
+        :param str value: The ip range in <first-ip>-<last-ip> format.
+        """
+        # pylint: disable=super-init-not-called
+        self.type = type
+        self.value = value
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'AddressIPAddressRange':
+        """Initialize a AddressIPAddressRange object from a json dictionary."""
+        args = {}
+        if (type := _dict.get('type')) is not None:
+            args['type'] = type
+        else:
+            raise ValueError('Required property \'type\' not present in AddressIPAddressRange JSON')
+        if (value := _dict.get('value')) is not None:
+            args['value'] = value
+        else:
+            raise ValueError('Required property \'value\' not present in AddressIPAddressRange JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a AddressIPAddressRange object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'type') and self.type is not None:
+            _dict['type'] = self.type
+        if hasattr(self, 'value') and self.value is not None:
+            _dict['value'] = self.value
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this AddressIPAddressRange object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'AddressIPAddressRange') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'AddressIPAddressRange') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class TypeEnum(str, Enum):
+        """
+        The type of address.
+        """
+
+        IPRANGE = 'ipRange'
+
+
+class AddressServiceRef(Address):
+    """
+    A service reference.
+
+    :param str type: The type of address.
+    :param ServiceRefValue ref: A service reference value.
+    """
+
+    def __init__(
+        self,
+        type: str,
+        ref: 'ServiceRefValue',
+    ) -> None:
+        """
+        Initialize a AddressServiceRef object.
+
+        :param str type: The type of address.
+        :param ServiceRefValue ref: A service reference value.
+        """
+        # pylint: disable=super-init-not-called
+        self.type = type
+        self.ref = ref
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'AddressServiceRef':
+        """Initialize a AddressServiceRef object from a json dictionary."""
+        args = {}
+        if (type := _dict.get('type')) is not None:
+            args['type'] = type
+        else:
+            raise ValueError('Required property \'type\' not present in AddressServiceRef JSON')
+        if (ref := _dict.get('ref')) is not None:
+            args['ref'] = ServiceRefValue.from_dict(ref)
+        else:
+            raise ValueError('Required property \'ref\' not present in AddressServiceRef JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a AddressServiceRef object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'type') and self.type is not None:
+            _dict['type'] = self.type
+        if hasattr(self, 'ref') and self.ref is not None:
+            if isinstance(self.ref, dict):
+                _dict['ref'] = self.ref
+            else:
+                _dict['ref'] = self.ref.to_dict()
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this AddressServiceRef object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'AddressServiceRef') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'AddressServiceRef') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class TypeEnum(str, Enum):
+        """
+        The type of address.
+        """
+
+        SERVICEREF = 'serviceRef'
+
+
+class AddressSubnet(Address):
+    """
+    A subnet in CIDR format.
+
+    :param str type: The type of address.
+    :param str value: The subnet in CIDR format.
+    """
+
+    def __init__(
+        self,
+        type: str,
+        value: str,
+    ) -> None:
+        """
+        Initialize a AddressSubnet object.
+
+        :param str type: The type of address.
+        :param str value: The subnet in CIDR format.
+        """
+        # pylint: disable=super-init-not-called
+        self.type = type
+        self.value = value
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'AddressSubnet':
+        """Initialize a AddressSubnet object from a json dictionary."""
+        args = {}
+        if (type := _dict.get('type')) is not None:
+            args['type'] = type
+        else:
+            raise ValueError('Required property \'type\' not present in AddressSubnet JSON')
+        if (value := _dict.get('value')) is not None:
+            args['value'] = value
+        else:
+            raise ValueError('Required property \'value\' not present in AddressSubnet JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a AddressSubnet object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'type') and self.type is not None:
+            _dict['type'] = self.type
+        if hasattr(self, 'value') and self.value is not None:
+            _dict['value'] = self.value
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this AddressSubnet object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'AddressSubnet') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'AddressSubnet') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class TypeEnum(str, Enum):
+        """
+        The type of address.
+        """
+
+        SUBNET = 'subnet'
+
+
+class AddressVPC(Address):
+    """
+    A single VPC address.
+
+    :param str type: The type of address.
+    :param str value: The VPC CRN.
+    """
+
+    def __init__(
+        self,
+        type: str,
+        value: str,
+    ) -> None:
+        """
+        Initialize a AddressVPC object.
+
+        :param str type: The type of address.
+        :param str value: The VPC CRN.
+        """
+        # pylint: disable=super-init-not-called
+        self.type = type
+        self.value = value
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'AddressVPC':
+        """Initialize a AddressVPC object from a json dictionary."""
+        args = {}
+        if (type := _dict.get('type')) is not None:
+            args['type'] = type
+        else:
+            raise ValueError('Required property \'type\' not present in AddressVPC JSON')
+        if (value := _dict.get('value')) is not None:
+            args['value'] = value
+        else:
+            raise ValueError('Required property \'value\' not present in AddressVPC JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a AddressVPC object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'type') and self.type is not None:
+            _dict['type'] = self.type
+        if hasattr(self, 'value') and self.value is not None:
+            _dict['value'] = self.value
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this AddressVPC object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'AddressVPC') -> bool:
+        """Return `true` when self and other are equal, false otherwise."""
+        if not isinstance(other, self.__class__):
+            return False
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: 'AddressVPC') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class TypeEnum(str, Enum):
+        """
+        The type of address.
+        """
+
+        VPC = 'vpc'