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

ibm_platform_services/case_management_v1.py

@@ -0,0 +1,2414 @@
+# coding: utf-8
+
+# (C) Copyright IBM Corp. 2021, 2022.
+#
+# 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.60.0-13f6e1ba-20221019-164457
+
+"""
+Case management API for creating cases, getting case statuses, adding comments to a case,
+adding and removing users from a case watchlist, downloading and adding attachments, and
+more.
+
+API Version: 1.0.0
+"""
+
+from enum import Enum
+from typing import BinaryIO, Dict, List
+import json
+import sys
+
+from ibm_cloud_sdk_core import BaseService, DetailedResponse, get_query_param
+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_list, convert_model
+
+from .common import get_sdk_headers
+
+##############################################################################
+# Service
+##############################################################################
+
+
+class CaseManagementV1(BaseService):
+    """The Case Management V1 service."""
+
+    DEFAULT_SERVICE_URL = 'https://support-center.cloud.ibm.com/case-management/v1'
+    DEFAULT_SERVICE_NAME = 'case_management'
+
+    @classmethod
+    def new_instance(
+        cls,
+        service_name: str = DEFAULT_SERVICE_NAME,
+    ) -> 'CaseManagementV1':
+        """
+        Return a new client for the Case Management 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 Case Management 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)
+
+    #########################
+    # default
+    #########################
+
+    def get_cases(
+        self,
+        *,
+        offset: int = None,
+        limit: int = None,
+        search: str = None,
+        sort: str = None,
+        status: List[str] = None,
+        fields: List[str] = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Get cases in account.
+
+        Get cases in the account that are specified by the content of the IAM token.
+
+        :param int offset: (optional) Number of cases that are skipped.
+        :param int limit: (optional) Number of cases that are returned.
+        :param str search: (optional) String that a case might contain.
+        :param str sort: (optional) Sort field and direction. If omitted, default
+               to descending of updated date. Prefix "~" signifies sort in descending.
+        :param List[str] status: (optional) Case status filter.
+        :param List[str] fields: (optional) Selected fields of interest instead of
+               all of the case information.
+        :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 `CaseList` object
+        """
+
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='get_cases'
+        )
+        headers.update(sdk_headers)
+
+        params = {
+            'offset': offset,
+            'limit': limit,
+            'search': search,
+            'sort': sort,
+            'status': convert_list(status),
+            'fields': convert_list(fields),
+        }
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        url = '/cases'
+        request = self.prepare_request(method='GET', url=url, headers=headers, params=params)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def create_case(
+        self,
+        type: str,
+        subject: str,
+        description: str,
+        *,
+        severity: int = None,
+        eu: 'CasePayloadEu' = None,
+        offering: 'Offering' = None,
+        resources: List['ResourcePayload'] = None,
+        watchlist: List['User'] = None,
+        invoice_number: str = None,
+        sla_credit_request: bool = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Create a case.
+
+        Create a support case to resolve issues in your account.
+
+        :param str type: Case type.
+        :param str subject: Short description used to identify the case.
+        :param str description: Detailed description of the issue.
+        :param int severity: (optional) Severity of the case. Smaller values mean
+               higher severity.
+        :param CasePayloadEu eu: (optional) Specify if the case should be treated
+               as EU regulated. Only one of the following properties is required. Call EU
+               support utility endpoint to determine which property must be specified for
+               your account.
+        :param Offering offering: (optional) Offering details.
+        :param List[ResourcePayload] resources: (optional) List of resources to
+               attach to case. If you attach Classic IaaS devices, use the type and id
+               fields if the Cloud Resource Name (CRN) is unavailable. Otherwise, pass the
+               resource CRN. The resource list must be consistent with the value that is
+               selected for the resource offering.
+        :param List[User] watchlist: (optional) Array of user IDs to add to the
+               watchlist.
+        :param str invoice_number: (optional) Invoice number of "Billing and
+               Invoice" case type.
+        :param bool sla_credit_request: (optional) Flag to indicate if case is for
+               an Service Level Agreement (SLA) credit request.
+        :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 `Case` object
+        """
+
+        if type is None:
+            raise ValueError('type must be provided')
+        if subject is None:
+            raise ValueError('subject must be provided')
+        if description is None:
+            raise ValueError('description must be provided')
+        if eu is not None:
+            eu = convert_model(eu)
+        if offering is not None:
+            offering = convert_model(offering)
+        if resources is not None:
+            resources = [convert_model(x) for x in resources]
+        if watchlist is not None:
+            watchlist = [convert_model(x) for x in watchlist]
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='create_case'
+        )
+        headers.update(sdk_headers)
+
+        data = {
+            'type': type,
+            'subject': subject,
+            'description': description,
+            'severity': severity,
+            'eu': eu,
+            'offering': offering,
+            'resources': resources,
+            'watchlist': watchlist,
+            'invoice_number': invoice_number,
+            'sla_credit_request': sla_credit_request,
+        }
+        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 = '/cases'
+        request = self.prepare_request(method='POST', url=url, headers=headers, data=data)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def get_case(self, case_number: str, *, fields: List[str] = None, **kwargs) -> DetailedResponse:
+        """
+        Get a case in account.
+
+        View a case in the account that is specified by the case number.
+
+        :param str case_number: Unique identifier of a case.
+        :param List[str] fields: (optional) Selected fields of interest instead of
+               all of the case information.
+        :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 `Case` object
+        """
+
+        if not case_number:
+            raise ValueError('case_number must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='get_case'
+        )
+        headers.update(sdk_headers)
+
+        params = {'fields': convert_list(fields)}
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['case_number']
+        path_param_values = self.encode_path_vars(case_number)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/cases/{case_number}'.format(**path_param_dict)
+        request = self.prepare_request(method='GET', url=url, headers=headers, params=params)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def update_case_status(self, case_number: str, status_payload: 'StatusPayload', **kwargs) -> DetailedResponse:
+        """
+        Update case status.
+
+        Mark the case as resolved or unresolved, or accept the provided resolution.
+
+        :param str case_number: Unique identifier of a case.
+        :param StatusPayload status_payload:
+        :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 `Case` object
+        """
+
+        if not case_number:
+            raise ValueError('case_number must be provided')
+        if status_payload is None:
+            raise ValueError('status_payload must be provided')
+        if isinstance(status_payload, StatusPayload):
+            status_payload = convert_model(status_payload)
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='update_case_status'
+        )
+        headers.update(sdk_headers)
+
+        data = json.dumps(status_payload)
+        headers['content-type'] = 'application/json'
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['case_number']
+        path_param_values = self.encode_path_vars(case_number)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/cases/{case_number}/status'.format(**path_param_dict)
+        request = self.prepare_request(method='PUT', url=url, headers=headers, data=data)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def add_comment(self, case_number: str, comment: str, **kwargs) -> DetailedResponse:
+        """
+        Add comment to case.
+
+        Add a comment to a case to be viewed by a support engineer.
+
+        :param str case_number: Unique identifier of a case.
+        :param str comment: Comment to add to the case.
+        :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 `Comment` object
+        """
+
+        if not case_number:
+            raise ValueError('case_number must be provided')
+        if comment is None:
+            raise ValueError('comment must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='add_comment'
+        )
+        headers.update(sdk_headers)
+
+        data = {'comment': comment}
+        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 = ['case_number']
+        path_param_values = self.encode_path_vars(case_number)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/cases/{case_number}/comments'.format(**path_param_dict)
+        request = self.prepare_request(method='PUT', url=url, headers=headers, data=data)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def add_watchlist(self, case_number: str, *, watchlist: List['User'] = None, **kwargs) -> DetailedResponse:
+        """
+        Add users to watchlist of case.
+
+        Add users to the watchlist of case. By adding a user to the watchlist of the case,
+        you are granting them read and write permissions, so the user can view the case,
+        receive updates, and make updates to the case. Note that the user must be in the
+        account to be added to the watchlist.
+
+        :param str case_number: Unique identifier of a case.
+        :param List[User] watchlist: (optional) Array of user ID objects.
+        :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 `WatchlistAddResponse` object
+        """
+
+        if not case_number:
+            raise ValueError('case_number must be provided')
+        if watchlist is not None:
+            watchlist = [convert_model(x) for x in watchlist]
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='add_watchlist'
+        )
+        headers.update(sdk_headers)
+
+        data = {'watchlist': watchlist}
+        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 = ['case_number']
+        path_param_values = self.encode_path_vars(case_number)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/cases/{case_number}/watchlist'.format(**path_param_dict)
+        request = self.prepare_request(method='PUT', url=url, headers=headers, data=data)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def remove_watchlist(self, case_number: str, *, watchlist: List['User'] = None, **kwargs) -> DetailedResponse:
+        """
+        Remove users from watchlist of case.
+
+        Remove users from the watchlist of a case if you don't want them to view the case,
+        receive updates, or make updates to the case.
+
+        :param str case_number: Unique identifier of a case.
+        :param List[User] watchlist: (optional) Array of user ID objects.
+        :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 `Watchlist` object
+        """
+
+        if not case_number:
+            raise ValueError('case_number must be provided')
+        if watchlist is not None:
+            watchlist = [convert_model(x) for x in watchlist]
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='remove_watchlist'
+        )
+        headers.update(sdk_headers)
+
+        data = {'watchlist': watchlist}
+        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 = ['case_number']
+        path_param_values = self.encode_path_vars(case_number)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/cases/{case_number}/watchlist'.format(**path_param_dict)
+        request = self.prepare_request(method='DELETE', url=url, headers=headers, data=data)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def add_resource(
+        self, case_number: str, *, crn: str = None, type: str = None, id: float = None, note: str = None, **kwargs
+    ) -> DetailedResponse:
+        """
+        Add a resource to case.
+
+        Add a resource to case by specifying the Cloud Resource Name (CRN), or id and type
+        if attaching a class iaaS resource.
+
+        :param str case_number: Unique identifier of a case.
+        :param str crn: (optional) Cloud Resource Name of the resource.
+        :param str type: (optional) Only used to attach Classic IaaS devices that
+               have no CRN.
+        :param float id: (optional) Deprecated: Only used to attach Classic IaaS
+               devices that have no CRN. Id of Classic IaaS device. This is deprecated in
+               favor of the crn field.
+        :param str note: (optional) A note about this 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 `Resource` object
+        """
+
+        if not case_number:
+            raise ValueError('case_number must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='add_resource'
+        )
+        headers.update(sdk_headers)
+
+        data = {'crn': crn, 'type': type, 'id': id, 'note': note}
+        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 = ['case_number']
+        path_param_values = self.encode_path_vars(case_number)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/cases/{case_number}/resources'.format(**path_param_dict)
+        request = self.prepare_request(method='PUT', url=url, headers=headers, data=data)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def upload_file(self, case_number: str, file: List[BinaryIO], **kwargs) -> DetailedResponse:
+        """
+        Add attachments to a support case.
+
+        You can add attachments to a case to provide more information for the support team
+        about the issue that you're experiencing.
+
+        :param str case_number: Unique identifier of a case.
+        :param list[FileWithMetadata] file: file of supported types, 8MB in size
+               limit.
+        :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 `Attachment` object
+        """
+
+        if not case_number:
+            raise ValueError('case_number must be provided')
+        if file is None:
+            raise ValueError('file must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='upload_file'
+        )
+        headers.update(sdk_headers)
+
+        form_data = []
+        for item in file:
+            item = convert_model(item)
+            _file = (item.get('filename') or None, item['data'], item.get('content_type') or 'application/octet-stream')
+            form_data.append(('file', _file))
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['case_number']
+        path_param_values = self.encode_path_vars(case_number)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/cases/{case_number}/attachments'.format(**path_param_dict)
+        request = self.prepare_request(method='PUT', url=url, headers=headers, files=form_data)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def download_file(self, case_number: str, file_id: str, **kwargs) -> DetailedResponse:
+        """
+        Download an attachment.
+
+        Download an attachment from a case.
+
+        :param str case_number: Unique identifier of a case.
+        :param str file_id: Unique identifier of a file.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse with `BinaryIO` result
+        """
+
+        if not case_number:
+            raise ValueError('case_number must be provided')
+        if not file_id:
+            raise ValueError('file_id must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='download_file'
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/octet-stream'
+
+        path_param_keys = ['case_number', 'file_id']
+        path_param_values = self.encode_path_vars(case_number, file_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/cases/{case_number}/attachments/{file_id}'.format(**path_param_dict)
+        request = self.prepare_request(method='GET', url=url, headers=headers)
+
+        response = self.send(request, **kwargs)
+        return response
+
+    def delete_file(self, case_number: str, file_id: str, **kwargs) -> DetailedResponse:
+        """
+        Remove attachment from case.
+
+        Remove an attachment from a case.
+
+        :param str case_number: Unique identifier of a case.
+        :param str file_id: Unique identifier of a file.
+        :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 `AttachmentList` object
+        """
+
+        if not case_number:
+            raise ValueError('case_number must be provided')
+        if not file_id:
+            raise ValueError('file_id must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='delete_file'
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+            del kwargs['headers']
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['case_number', 'file_id']
+        path_param_values = self.encode_path_vars(case_number, file_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/cases/{case_number}/attachments/{file_id}'.format(**path_param_dict)
+        request = self.prepare_request(method='DELETE', url=url, headers=headers)
+
+        response = self.send(request, **kwargs)
+        return response
+
+
+class GetCasesEnums:
+    """
+    Enums for get_cases parameters.
+    """
+
+    class Status(str, Enum):
+        """
+        Case status filter.
+        """
+
+        NEW = 'new'
+        IN_PROGRESS = 'in_progress'
+        WAITING_ON_CLIENT = 'waiting_on_client'
+        RESOLUTION_PROVIDED = 'resolution_provided'
+        RESOLVED = 'resolved'
+        CLOSED = 'closed'
+
+    class Fields(str, Enum):
+        """
+        Selected fields of interest instead of all of the case information.
+        """
+
+        NUMBER = 'number'
+        SHORT_DESCRIPTION = 'short_description'
+        DESCRIPTION = 'description'
+        CREATED_AT = 'created_at'
+        CREATED_BY = 'created_by'
+        UPDATED_AT = 'updated_at'
+        UPDATED_BY = 'updated_by'
+        CONTACT = 'contact'
+        CONTACT_TYPE = 'contact_type'
+        STATUS = 'status'
+        SEVERITY = 'severity'
+        SUPPORT_TIER = 'support_tier'
+        RESOLUTION = 'resolution'
+        CLOSE_NOTES = 'close_notes'
+        INVOICE_NUMBER = 'invoice_number'
+        AGENT_CLOSE_ONLY = 'agent_close_only'
+        EU = 'eu'
+        WATCHLIST = 'watchlist'
+        ATTACHMENTS = 'attachments'
+        RESOURCES = 'resources'
+        COMMENTS = 'comments'
+        OFFERING = 'offering'
+
+
+class GetCaseEnums:
+    """
+    Enums for get_case parameters.
+    """
+
+    class Fields(str, Enum):
+        """
+        Selected fields of interest instead of all of the case information.
+        """
+
+        NUMBER = 'number'
+        SHORT_DESCRIPTION = 'short_description'
+        DESCRIPTION = 'description'
+        CREATED_AT = 'created_at'
+        CREATED_BY = 'created_by'
+        UPDATED_AT = 'updated_at'
+        UPDATED_BY = 'updated_by'
+        CONTACT = 'contact'
+        CONTACT_TYPE = 'contact_type'
+        STATUS = 'status'
+        SEVERITY = 'severity'
+        SUPPORT_TIER = 'support_tier'
+        RESOLUTION = 'resolution'
+        CLOSE_NOTES = 'close_notes'
+        INVOICE_NUMBER = 'invoice_number'
+        AGENT_CLOSE_ONLY = 'agent_close_only'
+        EU = 'eu'
+        WATCHLIST = 'watchlist'
+        ATTACHMENTS = 'attachments'
+        RESOURCES = 'resources'
+        COMMENTS = 'comments'
+        OFFERING = 'offering'
+
+
+##############################################################################
+# Models
+##############################################################################
+
+
+class Attachment:
+    """
+    Details of an attachment.
+
+    :attr str id: (optional) Unique identifier of the attachment in database.
+    :attr str filename: (optional) Name of the attachment.
+    :attr int size_in_bytes: (optional) Size of the attachment in bytes.
+    :attr str created_at: (optional) Date time of uploading in UTC.
+    :attr str url: (optional) URL of the attachment used to download.
+    """
+
+    def __init__(
+        self,
+        *,
+        id: str = None,
+        filename: str = None,
+        size_in_bytes: int = None,
+        created_at: str = None,
+        url: str = None,
+    ) -> None:
+        """
+        Initialize a Attachment object.
+
+        :param str id: (optional) Unique identifier of the attachment in database.
+        :param str filename: (optional) Name of the attachment.
+        :param int size_in_bytes: (optional) Size of the attachment in bytes.
+        :param str created_at: (optional) Date time of uploading in UTC.
+        :param str url: (optional) URL of the attachment used to download.
+        """
+        self.id = id
+        self.filename = filename
+        self.size_in_bytes = size_in_bytes
+        self.created_at = created_at
+        self.url = url
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Attachment':
+        """Initialize a Attachment object from a json dictionary."""
+        args = {}
+        if 'id' in _dict:
+            args['id'] = _dict.get('id')
+        if 'filename' in _dict:
+            args['filename'] = _dict.get('filename')
+        if 'size_in_bytes' in _dict:
+            args['size_in_bytes'] = _dict.get('size_in_bytes')
+        if 'created_at' in _dict:
+            args['created_at'] = _dict.get('created_at')
+        if 'url' in _dict:
+            args['url'] = _dict.get('url')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Attachment 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, 'filename') and self.filename is not None:
+            _dict['filename'] = self.filename
+        if hasattr(self, 'size_in_bytes') and self.size_in_bytes is not None:
+            _dict['size_in_bytes'] = self.size_in_bytes
+        if hasattr(self, 'created_at') and self.created_at is not None:
+            _dict['created_at'] = self.created_at
+        if hasattr(self, 'url') and self.url is not None:
+            _dict['url'] = self.url
+        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 Attachment object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Attachment') -> 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: 'Attachment') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class AttachmentList:
+    """
+    List of attachments in the case.
+
+    :attr List[Attachment] attachments: (optional) New attachments array.
+    """
+
+    def __init__(self, *, attachments: List['Attachment'] = None) -> None:
+        """
+        Initialize a AttachmentList object.
+
+        :param List[Attachment] attachments: (optional) New attachments array.
+        """
+        self.attachments = attachments
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'AttachmentList':
+        """Initialize a AttachmentList object from a json dictionary."""
+        args = {}
+        if 'attachments' in _dict:
+            args['attachments'] = [Attachment.from_dict(x) for x in _dict.get('attachments')]
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a AttachmentList 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, 'attachments') and self.attachments is not None:
+            _dict['attachments'] = [x.to_dict() for x in self.attachments]
+        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 AttachmentList object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'AttachmentList') -> 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: 'AttachmentList') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Case:
+    """
+    The support case.
+
+    :attr str number: (optional) Identifying number of a created case.
+    :attr str short_description: (optional) Short description of what the case is
+          about.
+    :attr str description: (optional) Full description of what the case is about.
+    :attr str created_at: (optional) Date and time of case creation in UTC.
+    :attr User created_by: (optional) User info in a case.
+    :attr str updated_at: (optional) Date and time of the last update on the case in
+          UTC.
+    :attr User updated_by: (optional) User info in a case.
+    :attr str contact_type: (optional) Name of the console to interact with the
+          contact.
+    :attr User contact: (optional) User info in a case.
+    :attr str status: (optional) Status type of the case.
+    :attr float severity: (optional) Severity level of the case.
+    :attr str support_tier: (optional) Support tier of the account.
+    :attr str resolution: (optional) Standard reasons of resolving case.
+    :attr str close_notes: (optional) Notes of case closing.
+    :attr CaseEu eu: (optional) EU support.
+    :attr List[User] watchlist: (optional) List of users in the case watchlist.
+    :attr List[Attachment] attachments: (optional) List of files that are attached
+          to the case.
+    :attr Offering offering: (optional) Offering details.
+    :attr List[Resource] resources: (optional) List of attached resources.
+    :attr List[Comment] comments: (optional) List of comments and updates that are
+          sorted in chronological order.
+    """
+
+    def __init__(
+        self,
+        *,
+        number: str = None,
+        short_description: str = None,
+        description: str = None,
+        created_at: str = None,
+        created_by: 'User' = None,
+        updated_at: str = None,
+        updated_by: 'User' = None,
+        contact_type: str = None,
+        contact: 'User' = None,
+        status: str = None,
+        severity: float = None,
+        support_tier: str = None,
+        resolution: str = None,
+        close_notes: str = None,
+        eu: 'CaseEu' = None,
+        watchlist: List['User'] = None,
+        attachments: List['Attachment'] = None,
+        offering: 'Offering' = None,
+        resources: List['Resource'] = None,
+        comments: List['Comment'] = None,
+    ) -> None:
+        """
+        Initialize a Case object.
+
+        :param str number: (optional) Identifying number of a created case.
+        :param str short_description: (optional) Short description of what the case
+               is about.
+        :param str description: (optional) Full description of what the case is
+               about.
+        :param str created_at: (optional) Date and time of case creation in UTC.
+        :param User created_by: (optional) User info in a case.
+        :param str updated_at: (optional) Date and time of the last update on the
+               case in UTC.
+        :param User updated_by: (optional) User info in a case.
+        :param str contact_type: (optional) Name of the console to interact with
+               the contact.
+        :param User contact: (optional) User info in a case.
+        :param str status: (optional) Status type of the case.
+        :param float severity: (optional) Severity level of the case.
+        :param str support_tier: (optional) Support tier of the account.
+        :param str resolution: (optional) Standard reasons of resolving case.
+        :param str close_notes: (optional) Notes of case closing.
+        :param CaseEu eu: (optional) EU support.
+        :param List[User] watchlist: (optional) List of users in the case
+               watchlist.
+        :param List[Attachment] attachments: (optional) List of files that are
+               attached to the case.
+        :param Offering offering: (optional) Offering details.
+        :param List[Resource] resources: (optional) List of attached resources.
+        :param List[Comment] comments: (optional) List of comments and updates that
+               are sorted in chronological order.
+        """
+        self.number = number
+        self.short_description = short_description
+        self.description = description
+        self.created_at = created_at
+        self.created_by = created_by
+        self.updated_at = updated_at
+        self.updated_by = updated_by
+        self.contact_type = contact_type
+        self.contact = contact
+        self.status = status
+        self.severity = severity
+        self.support_tier = support_tier
+        self.resolution = resolution
+        self.close_notes = close_notes
+        self.eu = eu
+        self.watchlist = watchlist
+        self.attachments = attachments
+        self.offering = offering
+        self.resources = resources
+        self.comments = comments
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Case':
+        """Initialize a Case object from a json dictionary."""
+        args = {}
+        if 'number' in _dict:
+            args['number'] = _dict.get('number')
+        if 'short_description' in _dict:
+            args['short_description'] = _dict.get('short_description')
+        if 'description' in _dict:
+            args['description'] = _dict.get('description')
+        if 'created_at' in _dict:
+            args['created_at'] = _dict.get('created_at')
+        if 'created_by' in _dict:
+            args['created_by'] = User.from_dict(_dict.get('created_by'))
+        if 'updated_at' in _dict:
+            args['updated_at'] = _dict.get('updated_at')
+        if 'updated_by' in _dict:
+            args['updated_by'] = User.from_dict(_dict.get('updated_by'))
+        if 'contact_type' in _dict:
+            args['contact_type'] = _dict.get('contact_type')
+        if 'contact' in _dict:
+            args['contact'] = User.from_dict(_dict.get('contact'))
+        if 'status' in _dict:
+            args['status'] = _dict.get('status')
+        if 'severity' in _dict:
+            args['severity'] = _dict.get('severity')
+        if 'support_tier' in _dict:
+            args['support_tier'] = _dict.get('support_tier')
+        if 'resolution' in _dict:
+            args['resolution'] = _dict.get('resolution')
+        if 'close_notes' in _dict:
+            args['close_notes'] = _dict.get('close_notes')
+        if 'eu' in _dict:
+            args['eu'] = CaseEu.from_dict(_dict.get('eu'))
+        if 'watchlist' in _dict:
+            args['watchlist'] = [User.from_dict(x) for x in _dict.get('watchlist')]
+        if 'attachments' in _dict:
+            args['attachments'] = [Attachment.from_dict(x) for x in _dict.get('attachments')]
+        if 'offering' in _dict:
+            args['offering'] = Offering.from_dict(_dict.get('offering'))
+        if 'resources' in _dict:
+            args['resources'] = [Resource.from_dict(x) for x in _dict.get('resources')]
+        if 'comments' in _dict:
+            args['comments'] = [Comment.from_dict(x) for x in _dict.get('comments')]
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Case 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, 'number') and self.number is not None:
+            _dict['number'] = self.number
+        if hasattr(self, 'short_description') and self.short_description is not None:
+            _dict['short_description'] = self.short_description
+        if hasattr(self, 'description') and self.description is not None:
+            _dict['description'] = self.description
+        if hasattr(self, 'created_at') and self.created_at is not None:
+            _dict['created_at'] = self.created_at
+        if hasattr(self, 'created_by') and self.created_by is not None:
+            _dict['created_by'] = self.created_by.to_dict()
+        if hasattr(self, 'updated_at') and self.updated_at is not None:
+            _dict['updated_at'] = self.updated_at
+        if hasattr(self, 'updated_by') and self.updated_by is not None:
+            _dict['updated_by'] = self.updated_by.to_dict()
+        if hasattr(self, 'contact_type') and self.contact_type is not None:
+            _dict['contact_type'] = self.contact_type
+        if hasattr(self, 'contact') and self.contact is not None:
+            _dict['contact'] = self.contact.to_dict()
+        if hasattr(self, 'status') and self.status is not None:
+            _dict['status'] = self.status
+        if hasattr(self, 'severity') and self.severity is not None:
+            _dict['severity'] = self.severity
+        if hasattr(self, 'support_tier') and self.support_tier is not None:
+            _dict['support_tier'] = self.support_tier
+        if hasattr(self, 'resolution') and self.resolution is not None:
+            _dict['resolution'] = self.resolution
+        if hasattr(self, 'close_notes') and self.close_notes is not None:
+            _dict['close_notes'] = self.close_notes
+        if hasattr(self, 'eu') and self.eu is not None:
+            _dict['eu'] = self.eu.to_dict()
+        if hasattr(self, 'watchlist') and self.watchlist is not None:
+            _dict['watchlist'] = [x.to_dict() for x in self.watchlist]
+        if hasattr(self, 'attachments') and self.attachments is not None:
+            _dict['attachments'] = [x.to_dict() for x in self.attachments]
+        if hasattr(self, 'offering') and self.offering is not None:
+            _dict['offering'] = self.offering.to_dict()
+        if hasattr(self, 'resources') and self.resources is not None:
+            _dict['resources'] = [x.to_dict() for x in self.resources]
+        if hasattr(self, 'comments') and self.comments is not None:
+            _dict['comments'] = [x.to_dict() for x in self.comments]
+        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 Case object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Case') -> 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: 'Case') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class ContactTypeEnum(str, Enum):
+        """
+        Name of the console to interact with the contact.
+        """
+
+        CLOUD_SUPPORT_CENTER = 'Cloud Support Center'
+        IMS_CONSOLE = 'IMS Console'
+
+    class SupportTierEnum(str, Enum):
+        """
+        Support tier of the account.
+        """
+
+        FREE = 'Free'
+        BASIC = 'Basic'
+        STANDARD = 'Standard'
+        PREMIUM = 'Premium'
+
+
+class CaseEu:
+    """
+    EU support.
+
+    :attr bool support: (optional) Identifying whether the case has EU Support.
+    :attr str data_center: (optional) Information about the data center.
+    """
+
+    def __init__(self, *, support: bool = None, data_center: str = None) -> None:
+        """
+        Initialize a CaseEu object.
+
+        :param bool support: (optional) Identifying whether the case has EU
+               Support.
+        :param str data_center: (optional) Information about the data center.
+        """
+        self.support = support
+        self.data_center = data_center
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'CaseEu':
+        """Initialize a CaseEu object from a json dictionary."""
+        args = {}
+        if 'support' in _dict:
+            args['support'] = _dict.get('support')
+        if 'data_center' in _dict:
+            args['data_center'] = _dict.get('data_center')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a CaseEu 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, 'support') and self.support is not None:
+            _dict['support'] = self.support
+        if hasattr(self, 'data_center') and self.data_center is not None:
+            _dict['data_center'] = self.data_center
+        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 CaseEu object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'CaseEu') -> 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: 'CaseEu') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class CaseList:
+    """
+    Response of a GET /cases request.
+
+    :attr int total_count: (optional) Total number of cases that satisfy the query.
+    :attr PaginationLink first: (optional) Container for URL pointer to related
+          pages of cases.
+    :attr PaginationLink next: (optional) Container for URL pointer to related pages
+          of cases.
+    :attr PaginationLink previous: (optional) Container for URL pointer to related
+          pages of cases.
+    :attr PaginationLink last: (optional) Container for URL pointer to related pages
+          of cases.
+    :attr List[Case] cases: (optional) List of cases.
+    """
+
+    def __init__(
+        self,
+        *,
+        total_count: int = None,
+        first: 'PaginationLink' = None,
+        next: 'PaginationLink' = None,
+        previous: 'PaginationLink' = None,
+        last: 'PaginationLink' = None,
+        cases: List['Case'] = None,
+    ) -> None:
+        """
+        Initialize a CaseList object.
+
+        :param int total_count: (optional) Total number of cases that satisfy the
+               query.
+        :param PaginationLink first: (optional) Container for URL pointer to
+               related pages of cases.
+        :param PaginationLink next: (optional) Container for URL pointer to related
+               pages of cases.
+        :param PaginationLink previous: (optional) Container for URL pointer to
+               related pages of cases.
+        :param PaginationLink last: (optional) Container for URL pointer to related
+               pages of cases.
+        :param List[Case] cases: (optional) List of cases.
+        """
+        self.total_count = total_count
+        self.first = first
+        self.next = next
+        self.previous = previous
+        self.last = last
+        self.cases = cases
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'CaseList':
+        """Initialize a CaseList object from a json dictionary."""
+        args = {}
+        if 'total_count' in _dict:
+            args['total_count'] = _dict.get('total_count')
+        if 'first' in _dict:
+            args['first'] = PaginationLink.from_dict(_dict.get('first'))
+        if 'next' in _dict:
+            args['next'] = PaginationLink.from_dict(_dict.get('next'))
+        if 'previous' in _dict:
+            args['previous'] = PaginationLink.from_dict(_dict.get('previous'))
+        if 'last' in _dict:
+            args['last'] = PaginationLink.from_dict(_dict.get('last'))
+        if 'cases' in _dict:
+            args['cases'] = [Case.from_dict(x) for x in _dict.get('cases')]
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a CaseList 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, 'total_count') and self.total_count is not None:
+            _dict['total_count'] = self.total_count
+        if hasattr(self, 'first') and self.first is not None:
+            _dict['first'] = self.first.to_dict()
+        if hasattr(self, 'next') and self.next is not None:
+            _dict['next'] = self.next.to_dict()
+        if hasattr(self, 'previous') and self.previous is not None:
+            _dict['previous'] = self.previous.to_dict()
+        if hasattr(self, 'last') and self.last is not None:
+            _dict['last'] = self.last.to_dict()
+        if hasattr(self, 'cases') and self.cases is not None:
+            _dict['cases'] = [x.to_dict() for x in self.cases]
+        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 CaseList object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'CaseList') -> 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: 'CaseList') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class CasePayloadEu:
+    """
+    Specify if the case should be treated as EU regulated. Only one of the following
+    properties is required. Call EU support utility endpoint to determine which property
+    must be specified for your account.
+
+    :attr bool supported: (optional) indicating whether the case is EU supported.
+    :attr int data_center: (optional) If EU supported utility endpoint specifies
+          data center, then pass the data center id to mark a case as EU supported.
+    """
+
+    def __init__(self, *, supported: bool = None, data_center: int = None) -> None:
+        """
+        Initialize a CasePayloadEu object.
+
+        :param bool supported: (optional) indicating whether the case is EU
+               supported.
+        :param int data_center: (optional) If EU supported utility endpoint
+               specifies data center, then pass the data center id to mark a case as EU
+               supported.
+        """
+        self.supported = supported
+        self.data_center = data_center
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'CasePayloadEu':
+        """Initialize a CasePayloadEu object from a json dictionary."""
+        args = {}
+        if 'supported' in _dict:
+            args['supported'] = _dict.get('supported')
+        if 'data_center' in _dict:
+            args['data_center'] = _dict.get('data_center')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a CasePayloadEu 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, 'supported') and self.supported is not None:
+            _dict['supported'] = self.supported
+        if hasattr(self, 'data_center') and self.data_center is not None:
+            _dict['data_center'] = self.data_center
+        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 CasePayloadEu object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'CasePayloadEu') -> 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: 'CasePayloadEu') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Comment:
+    """
+    A comment in a case.
+
+    :attr str value: (optional) The comment.
+    :attr str added_at: (optional) Date time when comment was added in UTC.
+    :attr User added_by: (optional) User info in a case.
+    """
+
+    def __init__(self, *, value: str = None, added_at: str = None, added_by: 'User' = None) -> None:
+        """
+        Initialize a Comment object.
+
+        :param str value: (optional) The comment.
+        :param str added_at: (optional) Date time when comment was added in UTC.
+        :param User added_by: (optional) User info in a case.
+        """
+        self.value = value
+        self.added_at = added_at
+        self.added_by = added_by
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Comment':
+        """Initialize a Comment object from a json dictionary."""
+        args = {}
+        if 'value' in _dict:
+            args['value'] = _dict.get('value')
+        if 'added_at' in _dict:
+            args['added_at'] = _dict.get('added_at')
+        if 'added_by' in _dict:
+            args['added_by'] = User.from_dict(_dict.get('added_by'))
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Comment 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, 'value') and self.value is not None:
+            _dict['value'] = self.value
+        if hasattr(self, 'added_at') and self.added_at is not None:
+            _dict['added_at'] = self.added_at
+        if hasattr(self, 'added_by') and self.added_by is not None:
+            _dict['added_by'] = self.added_by.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 Comment object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Comment') -> 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: 'Comment') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Offering:
+    """
+    Offering details.
+
+    :attr str name: Name of the offering.
+    :attr OfferingType type: Offering type.
+    """
+
+    def __init__(self, name: str, type: 'OfferingType') -> None:
+        """
+        Initialize a Offering object.
+
+        :param str name: Name of the offering.
+        :param OfferingType type: Offering type.
+        """
+        self.name = name
+        self.type = type
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Offering':
+        """Initialize a Offering object from a json dictionary."""
+        args = {}
+        if 'name' in _dict:
+            args['name'] = _dict.get('name')
+        else:
+            raise ValueError('Required property \'name\' not present in Offering JSON')
+        if 'type' in _dict:
+            args['type'] = OfferingType.from_dict(_dict.get('type'))
+        else:
+            raise ValueError('Required property \'type\' not present in Offering JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Offering 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, 'type') and self.type is not None:
+            _dict['type'] = self.type.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 Offering object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Offering') -> 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: 'Offering') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class OfferingType:
+    """
+    Offering type.
+
+    :attr str group: Offering type group. "crn_service_name" is preferred over
+          "category" as the latter is legacy and will be deprecated in the future.
+    :attr str key: CRN service name of the offering.
+    :attr str kind: (optional) Optional. Platform kind of the offering.
+    :attr str id: (optional) Offering id in the catalog. This alone is enough to
+          identify the offering.
+    """
+
+    def __init__(self, group: str, key: str, *, kind: str = None, id: str = None) -> None:
+        """
+        Initialize a OfferingType object.
+
+        :param str group: Offering type group. "crn_service_name" is preferred over
+               "category" as the latter is legacy and will be deprecated in the future.
+        :param str key: CRN service name of the offering.
+        :param str kind: (optional) Optional. Platform kind of the offering.
+        :param str id: (optional) Offering id in the catalog. This alone is enough
+               to identify the offering.
+        """
+        self.group = group
+        self.key = key
+        self.kind = kind
+        self.id = id
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'OfferingType':
+        """Initialize a OfferingType object from a json dictionary."""
+        args = {}
+        if 'group' in _dict:
+            args['group'] = _dict.get('group')
+        else:
+            raise ValueError('Required property \'group\' not present in OfferingType JSON')
+        if 'key' in _dict:
+            args['key'] = _dict.get('key')
+        else:
+            raise ValueError('Required property \'key\' not present in OfferingType JSON')
+        if 'kind' in _dict:
+            args['kind'] = _dict.get('kind')
+        if 'id' in _dict:
+            args['id'] = _dict.get('id')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a OfferingType 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, 'group') and self.group is not None:
+            _dict['group'] = self.group
+        if hasattr(self, 'key') and self.key is not None:
+            _dict['key'] = self.key
+        if hasattr(self, 'kind') and self.kind is not None:
+            _dict['kind'] = self.kind
+        if hasattr(self, 'id') and self.id is not None:
+            _dict['id'] = self.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 OfferingType object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'OfferingType') -> 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: 'OfferingType') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class GroupEnum(str, Enum):
+        """
+        Offering type group. "crn_service_name" is preferred over "category" as the latter
+        is legacy and will be deprecated in the future.
+        """
+
+        CRN_SERVICE_NAME = 'crn_service_name'
+        CATEGORY = 'category'
+
+
+class PaginationLink:
+    """
+    Container for URL pointer to related pages of cases.
+
+    :attr str href: (optional) URL to related pages of cases.
+    """
+
+    def __init__(self, *, href: str = None) -> None:
+        """
+        Initialize a PaginationLink object.
+
+        :param str href: (optional) URL to related pages of cases.
+        """
+        self.href = href
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'PaginationLink':
+        """Initialize a PaginationLink object from a json dictionary."""
+        args = {}
+        if 'href' in _dict:
+            args['href'] = _dict.get('href')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a PaginationLink 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, 'href') and self.href is not None:
+            _dict['href'] = self.href
+        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 PaginationLink object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'PaginationLink') -> 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: 'PaginationLink') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Resource:
+    """
+    A resource record of a case.
+
+    :attr str crn: (optional) ID of the resource.
+    :attr str name: (optional) Name of the resource.
+    :attr str type: (optional) Type of resource.
+    :attr str url: (optional) URL of resource.
+    :attr str note: (optional) Note about resource.
+    """
+
+    def __init__(
+        self, *, crn: str = None, name: str = None, type: str = None, url: str = None, note: str = None
+    ) -> None:
+        """
+        Initialize a Resource object.
+
+        :param str crn: (optional) ID of the resource.
+        :param str name: (optional) Name of the resource.
+        :param str type: (optional) Type of resource.
+        :param str url: (optional) URL of resource.
+        :param str note: (optional) Note about resource.
+        """
+        self.crn = crn
+        self.name = name
+        self.type = type
+        self.url = url
+        self.note = note
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Resource':
+        """Initialize a Resource object from a json dictionary."""
+        args = {}
+        if 'crn' in _dict:
+            args['crn'] = _dict.get('crn')
+        if 'name' in _dict:
+            args['name'] = _dict.get('name')
+        if 'type' in _dict:
+            args['type'] = _dict.get('type')
+        if 'url' in _dict:
+            args['url'] = _dict.get('url')
+        if 'note' in _dict:
+            args['note'] = _dict.get('note')
+        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, '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, 'type') and self.type is not None:
+            _dict['type'] = self.type
+        if hasattr(self, 'url') and self.url is not None:
+            _dict['url'] = self.url
+        if hasattr(self, 'note') and self.note is not None:
+            _dict['note'] = self.note
+        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 ResourcePayload:
+    """
+    Payload to add a resource to a case.
+
+    :attr str crn: (optional) Cloud Resource Name of the resource.
+    :attr str type: (optional) Only used to attach Classic IaaS devices that have no
+          CRN.
+    :attr float id: (optional) Deprecated: Only used to attach Classic IaaS devices
+          that have no CRN. Id of Classic IaaS device. This is deprecated in favor of the
+          crn field.
+    :attr str note: (optional) A note about this resource.
+    """
+
+    def __init__(self, *, crn: str = None, type: str = None, id: float = None, note: str = None) -> None:
+        """
+        Initialize a ResourcePayload object.
+
+        :param str crn: (optional) Cloud Resource Name of the resource.
+        :param str type: (optional) Only used to attach Classic IaaS devices that
+               have no CRN.
+        :param float id: (optional) Deprecated: Only used to attach Classic IaaS
+               devices that have no CRN. Id of Classic IaaS device. This is deprecated in
+               favor of the crn field.
+        :param str note: (optional) A note about this resource.
+        """
+        self.crn = crn
+        self.type = type
+        self.id = id
+        self.note = note
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ResourcePayload':
+        """Initialize a ResourcePayload object from a json dictionary."""
+        args = {}
+        if 'crn' in _dict:
+            args['crn'] = _dict.get('crn')
+        if 'type' in _dict:
+            args['type'] = _dict.get('type')
+        if 'id' in _dict:
+            args['id'] = _dict.get('id')
+        if 'note' in _dict:
+            args['note'] = _dict.get('note')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ResourcePayload 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, 'crn') and self.crn is not None:
+            _dict['crn'] = self.crn
+        if hasattr(self, 'type') and self.type is not None:
+            _dict['type'] = self.type
+        if hasattr(self, 'id') and self.id is not None:
+            _dict['id'] = self.id
+        if hasattr(self, 'note') and self.note is not None:
+            _dict['note'] = self.note
+        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 ResourcePayload object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ResourcePayload') -> 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: 'ResourcePayload') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class StatusPayload:
+    """
+    Payload to update status of the case.
+
+    :attr str action: action to perform on the case.
+    """
+
+    def __init__(self, action: str) -> None:
+        """
+        Initialize a StatusPayload object.
+
+        :param str action: action to perform on the case.
+        """
+        msg = "Cannot instantiate base class. Instead, instantiate one of the defined subclasses: {0}".format(
+            ", ".join(['ResolvePayload', 'UnresolvePayload', 'AcceptPayload'])
+        )
+        raise Exception(msg)
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'StatusPayload':
+        """Initialize a StatusPayload 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 'StatusPayload'. "
+            + "The discriminator value should map to a valid subclass: {1}"
+        ).format(", ".join(['ResolvePayload', 'UnresolvePayload', 'AcceptPayload']))
+        raise Exception(msg)
+
+    @classmethod
+    def _from_dict(cls, _dict: Dict):
+        """Initialize a StatusPayload object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    @classmethod
+    def _get_class_by_discriminator(cls, _dict: Dict) -> object:
+        mapping = {}
+        mapping['resolve'] = 'ResolvePayload'
+        mapping['unresolve'] = 'UnresolvePayload'
+        mapping['accept'] = 'AcceptPayload'
+        disc_value = _dict.get('action')
+        if disc_value is None:
+            raise ValueError('Discriminator property \'action\' not found in StatusPayload 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 ActionEnum(str, Enum):
+        """
+        action to perform on the case.
+        """
+
+        RESOLVE = 'resolve'
+        UNRESOLVE = 'unresolve'
+        ACCEPT = 'accept'
+
+
+class User:
+    """
+    User info in a case.
+
+    :attr str name: (optional) Full name of the user.
+    :attr str realm: the ID realm.
+    :attr str user_id: unique user ID in the realm specified by the type.
+    """
+
+    def __init__(self, realm: str, user_id: str, *, name: str = None) -> None:
+        """
+        Initialize a User object.
+
+        :param str realm: the ID realm.
+        :param str user_id: unique user ID in the realm specified by the type.
+        """
+        self.name = name
+        self.realm = realm
+        self.user_id = user_id
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'User':
+        """Initialize a User object from a json dictionary."""
+        args = {}
+        if 'name' in _dict:
+            args['name'] = _dict.get('name')
+        if 'realm' in _dict:
+            args['realm'] = _dict.get('realm')
+        else:
+            raise ValueError('Required property \'realm\' not present in User JSON')
+        if 'user_id' in _dict:
+            args['user_id'] = _dict.get('user_id')
+        else:
+            raise ValueError('Required property \'user_id\' not present in User JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a User 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 getattr(self, 'name') is not None:
+            _dict['name'] = getattr(self, 'name')
+        if hasattr(self, 'realm') and self.realm is not None:
+            _dict['realm'] = self.realm
+        if hasattr(self, 'user_id') and self.user_id is not None:
+            _dict['user_id'] = self.user_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 User object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'User') -> 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: 'User') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class RealmEnum(str, Enum):
+        """
+        the ID realm.
+        """
+
+        IBMID = 'IBMid'
+        SL = 'SL'
+        BSS = 'BSS'
+
+
+class Watchlist:
+    """
+    Payload to add/remove users to/from the case watchlist.
+
+    :attr List[User] watchlist: (optional) Array of user ID objects.
+    """
+
+    def __init__(self, *, watchlist: List['User'] = None) -> None:
+        """
+        Initialize a Watchlist object.
+
+        :param List[User] watchlist: (optional) Array of user ID objects.
+        """
+        self.watchlist = watchlist
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Watchlist':
+        """Initialize a Watchlist object from a json dictionary."""
+        args = {}
+        if 'watchlist' in _dict:
+            args['watchlist'] = [User.from_dict(x) for x in _dict.get('watchlist')]
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Watchlist 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, 'watchlist') and self.watchlist is not None:
+            _dict['watchlist'] = [x.to_dict() for x in self.watchlist]
+        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 Watchlist object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Watchlist') -> 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: 'Watchlist') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class WatchlistAddResponse:
+    """
+    Response of a request when adding to watchlist.
+
+    :attr List[User] added: (optional) List of added user.
+    :attr List[User] failed: (optional) List of failed to add user.
+    """
+
+    def __init__(self, *, added: List['User'] = None, failed: List['User'] = None) -> None:
+        """
+        Initialize a WatchlistAddResponse object.
+
+        :param List[User] added: (optional) List of added user.
+        :param List[User] failed: (optional) List of failed to add user.
+        """
+        self.added = added
+        self.failed = failed
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'WatchlistAddResponse':
+        """Initialize a WatchlistAddResponse object from a json dictionary."""
+        args = {}
+        if 'added' in _dict:
+            args['added'] = [User.from_dict(x) for x in _dict.get('added')]
+        if 'failed' in _dict:
+            args['failed'] = [User.from_dict(x) for x in _dict.get('failed')]
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a WatchlistAddResponse 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, 'added') and self.added is not None:
+            _dict['added'] = [x.to_dict() for x in self.added]
+        if hasattr(self, 'failed') and self.failed is not None:
+            _dict['failed'] = [x.to_dict() for x in self.failed]
+        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 WatchlistAddResponse object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'WatchlistAddResponse') -> 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: 'WatchlistAddResponse') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class AcceptPayload(StatusPayload):
+    """
+    Payload to accept the proposed resolution of the case.
+
+    :attr str action: action to perform on the case.
+    :attr str comment: (optional) Comment about accepting the proposed resolution.
+    """
+
+    def __init__(self, action: str, *, comment: str = None) -> None:
+        """
+        Initialize a AcceptPayload object.
+
+        :param str action: action to perform on the case.
+        :param str comment: (optional) Comment about accepting the proposed
+               resolution.
+        """
+        # pylint: disable=super-init-not-called
+        self.action = action
+        self.comment = comment
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'AcceptPayload':
+        """Initialize a AcceptPayload object from a json dictionary."""
+        args = {}
+        if 'action' in _dict:
+            args['action'] = _dict.get('action')
+        else:
+            raise ValueError('Required property \'action\' not present in AcceptPayload JSON')
+        if 'comment' in _dict:
+            args['comment'] = _dict.get('comment')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a AcceptPayload 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') and self.action is not None:
+            _dict['action'] = self.action
+        if hasattr(self, 'comment') and self.comment is not None:
+            _dict['comment'] = self.comment
+        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 AcceptPayload object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'AcceptPayload') -> 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: 'AcceptPayload') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class ActionEnum(str, Enum):
+        """
+        action to perform on the case.
+        """
+
+        RESOLVE = 'resolve'
+        UNRESOLVE = 'unresolve'
+        ACCEPT = 'accept'
+
+
+class ResolvePayload(StatusPayload):
+    """
+    Payload to resolve the case.
+
+    :attr str action: action to perform on the case.
+    :attr str comment: (optional) comment of resolution.
+    :attr int resolution_code: * 1: Client error
+          * 2: Defect found with Component/Service
+          * 3: Documentation Error
+          * 4: Solution found in forums
+          * 5: Solution found in public Documentation
+          * 6: Solution no longer required
+          * 7: Solution provided by IBM outside of support case
+          * 8: Solution provided by IBM support engineer.
+    """
+
+    def __init__(self, action: str, resolution_code: int, *, comment: str = None) -> None:
+        """
+        Initialize a ResolvePayload object.
+
+        :param str action: action to perform on the case.
+        :param int resolution_code: * 1: Client error
+               * 2: Defect found with Component/Service
+               * 3: Documentation Error
+               * 4: Solution found in forums
+               * 5: Solution found in public Documentation
+               * 6: Solution no longer required
+               * 7: Solution provided by IBM outside of support case
+               * 8: Solution provided by IBM support engineer.
+        :param str comment: (optional) comment of resolution.
+        """
+        # pylint: disable=super-init-not-called
+        self.action = action
+        self.comment = comment
+        self.resolution_code = resolution_code
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'ResolvePayload':
+        """Initialize a ResolvePayload object from a json dictionary."""
+        args = {}
+        if 'action' in _dict:
+            args['action'] = _dict.get('action')
+        else:
+            raise ValueError('Required property \'action\' not present in ResolvePayload JSON')
+        if 'comment' in _dict:
+            args['comment'] = _dict.get('comment')
+        if 'resolution_code' in _dict:
+            args['resolution_code'] = _dict.get('resolution_code')
+        else:
+            raise ValueError('Required property \'resolution_code\' not present in ResolvePayload JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a ResolvePayload 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') and self.action is not None:
+            _dict['action'] = self.action
+        if hasattr(self, 'comment') and self.comment is not None:
+            _dict['comment'] = self.comment
+        if hasattr(self, 'resolution_code') and self.resolution_code is not None:
+            _dict['resolution_code'] = self.resolution_code
+        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 ResolvePayload object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'ResolvePayload') -> 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: 'ResolvePayload') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class ActionEnum(str, Enum):
+        """
+        action to perform on the case.
+        """
+
+        RESOLVE = 'resolve'
+        UNRESOLVE = 'unresolve'
+        ACCEPT = 'accept'
+
+
+class UnresolvePayload(StatusPayload):
+    """
+    Payload to unresolve the case.
+
+    :attr str action: action to perform on the case.
+    :attr str comment: Comment why the case should be unresolved.
+    """
+
+    def __init__(self, action: str, comment: str) -> None:
+        """
+        Initialize a UnresolvePayload object.
+
+        :param str action: action to perform on the case.
+        :param str comment: Comment why the case should be unresolved.
+        """
+        # pylint: disable=super-init-not-called
+        self.action = action
+        self.comment = comment
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'UnresolvePayload':
+        """Initialize a UnresolvePayload object from a json dictionary."""
+        args = {}
+        if 'action' in _dict:
+            args['action'] = _dict.get('action')
+        else:
+            raise ValueError('Required property \'action\' not present in UnresolvePayload JSON')
+        if 'comment' in _dict:
+            args['comment'] = _dict.get('comment')
+        else:
+            raise ValueError('Required property \'comment\' not present in UnresolvePayload JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a UnresolvePayload 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') and self.action is not None:
+            _dict['action'] = self.action
+        if hasattr(self, 'comment') and self.comment is not None:
+            _dict['comment'] = self.comment
+        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 UnresolvePayload object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'UnresolvePayload') -> 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: 'UnresolvePayload') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+    class ActionEnum(str, Enum):
+        """
+        action to perform on the case.
+        """
+
+        RESOLVE = 'resolve'
+        UNRESOLVE = 'unresolve'
+        ACCEPT = 'accept'
+
+
+class FileWithMetadata:
+    """
+    A file with its associated metadata.
+
+    :attr BinaryIO data: The data / content for the file.
+    :attr str filename: (optional) The filename of the file.
+    :attr str content_type: (optional) The content type of the file.
+    """
+
+    def __init__(self, data: BinaryIO, *, filename: str = None, content_type: str = None) -> None:
+        """
+        Initialize a FileWithMetadata object.
+
+        :param BinaryIO data: The data / content for the file.
+        :param str filename: (optional) The filename of the file.
+        :param str content_type: (optional) The content type of the file.
+        """
+        self.data = data
+        self.filename = filename
+        self.content_type = content_type
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'FileWithMetadata':
+        """Initialize a FileWithMetadata object from a json dictionary."""
+        args = {}
+        if 'data' in _dict:
+            args['data'] = _dict.get('data')
+        else:
+            raise ValueError('Required property \'data\' not present in FileWithMetadata JSON')
+        if 'filename' in _dict:
+            args['filename'] = _dict.get('filename')
+        if 'content_type' in _dict:
+            args['content_type'] = _dict.get('content_type')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a FileWithMetadata 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, 'data') and self.data is not None:
+            _dict['data'] = self.data
+        if hasattr(self, 'filename') and self.filename is not None:
+            _dict['filename'] = self.filename
+        if hasattr(self, 'content_type') and self.content_type is not None:
+            _dict['content_type'] = self.content_type
+        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 FileWithMetadata object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'FileWithMetadata') -> 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: 'FileWithMetadata') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+##############################################################################
+# Pagers
+##############################################################################
+
+
+class GetCasesPager:
+    """
+    GetCasesPager can be used to simplify the use of the "get_cases" method.
+    """
+
+    def __init__(
+        self,
+        *,
+        client: CaseManagementV1,
+        limit: int = None,
+        search: str = None,
+        sort: str = None,
+        status: List[str] = None,
+        fields: List[str] = None,
+    ) -> None:
+        """
+        Initialize a GetCasesPager object.
+        :param int limit: (optional) Number of cases that are returned.
+        :param str search: (optional) String that a case might contain.
+        :param str sort: (optional) Sort field and direction. If omitted, default
+               to descending of updated date. Prefix "~" signifies sort in descending.
+        :param List[str] status: (optional) Case status filter.
+        :param List[str] fields: (optional) Selected fields of interest instead of
+               all of the case information.
+        """
+        self._has_next = True
+        self._client = client
+        self._page_context = {'next': None}
+        self._limit = limit
+        self._search = search
+        self._sort = sort
+        self._status = status
+        self._fields = fields
+
+    def has_next(self) -> bool:
+        """
+        Returns true if there are potentially more results to be retrieved.
+        """
+        return self._has_next
+
+    def get_next(self) -> List[dict]:
+        """
+        Returns the next page of results.
+        :return: A List[dict], where each element is a dict that represents an instance of Case.
+        :rtype: List[dict]
+        """
+        if not self.has_next():
+            raise StopIteration(message='No more results available')
+
+        result = self._client.get_cases(
+            limit=self._limit,
+            search=self._search,
+            sort=self._sort,
+            status=self._status,
+            fields=self._fields,
+            offset=self._page_context.get('next'),
+        ).get_result()
+
+        next = None
+        next_page_link = result.get('next')
+        if next_page_link is not None:
+            next = get_query_param(next_page_link.get('href'), 'offset')
+        self._page_context['next'] = next
+        if next is None:
+            self._has_next = False
+
+        return result.get('cases')
+
+    def get_all(self) -> List[dict]:
+        """
+        Returns all results by invoking get_next() repeatedly
+        until all pages of results have been retrieved.
+        :return: A List[dict], where each element is a dict that represents an instance of Case.
+        :rtype: List[dict]
+        """
+        results = []
+        while self.has_next():
+            next_page = self.get_next()
+            results.extend(next_page)
+        return results