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

ibm_platform_services/open_service_broker_v1.py

@@ -0,0 +1,1774 @@
+# coding: utf-8
+
+# (C) Copyright IBM Corp. 2020.
+#
+# 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: 99-SNAPSHOT-d753183b-20201209-163011
+
+"""
+Contribute resources to the IBM Cloud catalog by implementing a `service broker` that
+conforms to the [Open Service Broker
+API](https://github.com/openservicebrokerapi/servicebroker/blob/master/spec.md) version
+2.12  specification and provides enablement extensions for integration with IBM Cloud and
+the Resource Controller provisioning model.
+"""
+
+from typing import Dict, List
+import json
+
+from ibm_cloud_sdk_core import BaseService, DetailedResponse
+from ibm_cloud_sdk_core.authenticators.authenticator import Authenticator
+from ibm_cloud_sdk_core.get_authenticator import get_authenticator_from_environment
+from ibm_cloud_sdk_core.utils import convert_model
+
+from .common import get_sdk_headers
+
+##############################################################################
+# Service
+##############################################################################
+
+
+class OpenServiceBrokerV1(BaseService):
+    """The Open Service Broker V1 service."""
+
+    DEFAULT_SERVICE_URL = None
+    DEFAULT_SERVICE_NAME = 'open_service_broker'
+
+    @classmethod
+    def new_instance(
+        cls,
+        service_name: str = DEFAULT_SERVICE_NAME,
+    ) -> 'OpenServiceBrokerV1':
+        """
+        Return a new client for the Open Service Broker 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 Open Service Broker service.
+
+        :param Authenticator authenticator: The authenticator specifies the authentication mechanism.
+               Get up to date information from https://github.com/IBM/python-sdk-core/blob/master/README.md
+               about initializing the authenticator of your choice.
+        """
+        BaseService.__init__(self, service_url=self.DEFAULT_SERVICE_URL, authenticator=authenticator)
+
+    #########################
+    # Enable and Disable Instances
+    #########################
+
+    def get_service_instance_state(self, instance_id: str, **kwargs) -> DetailedResponse:
+        """
+        Get the current state of the service instance.
+
+        Get the current state information associated with the service instance.
+        As a service provider you need a way to manage provisioned service instances.  If
+        an account comes past due, you may need a to disable the service (without deleting
+        it), and when the account is settled re-enable the service.
+        This endpoint allows both the provider and IBM Cloud to query for the state of a
+        provisioned service instance.  For example, IBM Cloud may query the provider to
+        figure out if a given service is disabled or not and present that state to the
+        user.
+
+        :param str instance_id: The `instance_id` of a service instance is provided
+               by the IBM Cloud platform. This ID will be used for future requests to bind
+               and deprovision, so the broker can use it to correlate the resource it
+               creates.
+        :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 `Resp1874644Root` object
+        """
+
+        if instance_id is None:
+            raise ValueError('instance_id must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='get_service_instance_state'
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['instance_id']
+        path_param_values = self.encode_path_vars(instance_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/bluemix_v1/service_instances/{instance_id}'.format(**path_param_dict)
+        request = self.prepare_request(method='GET', url=url, headers=headers)
+
+        response = self.send(request)
+        return response
+
+    def replace_service_instance_state(
+        self, instance_id: str, *, enabled: bool = None, initiator_id: str = None, reason_code: str = None, **kwargs
+    ) -> DetailedResponse:
+        """
+        Update the state of a provisioned service instance.
+
+        Update (disable or enable) the state of a provisioned service instance. As a
+        service provider you need a way to manage provisioned service instances. If an
+        account comes past due, you may need a to disable the service (without deleting
+        it), and when the account is settled re-enable the service. This endpoint allows
+        the provider to enable or disable the state of a provisioned service instance. It
+        is the service provider's responsibility to disable access to the service instance
+        when the disable endpoint is invoked and to re-enable that access when the enable
+        endpoint is invoked. When your service broker receives an enable / disable
+        request, it should take whatever action is necessary to enable / disable
+        (respectively) the service.  Additionally, If a bind request comes in for a
+        disabled service, the broker should reject that request with any code other than
+        `204`, and provide a user-facing message in the description.
+
+        :param str instance_id: The `instance_id` of a service instance is provided
+               by the IBM Cloud platform. This ID will be used for future requests to bind
+               and deprovision, so the broker can use it to correlate the resource it
+               creates.
+        :param bool enabled: (optional) Indicates the current state of the service
+               instance.
+        :param str initiator_id: (optional) Optional string that shows the user ID
+               that is initiating the call.
+        :param str reason_code: (optional) Optional string that states the reason
+               code for the service instance state change. Valid values are
+               `IBMCLOUD_ACCT_ACTIVATE`, `IBMCLOUD_RECLAMATION_RESTORE`, or
+               `IBMCLOUD_SERVICE_INSTANCE_BELOW_CAP` for enable calls;
+               `IBMCLOUD_ACCT_SUSPEND`, `IBMCLOUD_RECLAMATION_SCHEDULE`, or
+               `IBMCLOUD_SERVICE_INSTANCE_ABOVE_CAP` for disable calls; and
+               `IBMCLOUD_ADMIN_REQUEST` for enable and disable calls.<br/><br/>Previously
+               accepted values had a `BMX_` prefix, such as `BMX_ACCT_ACTIVATE`. These
+               values are deprecated.
+        :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 `Resp2448145Root` object
+        """
+
+        if instance_id is None:
+            raise ValueError('instance_id must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='replace_service_instance_state'
+        )
+        headers.update(sdk_headers)
+
+        data = {'enabled': enabled, 'initiator_id': initiator_id, 'reason_code': reason_code}
+        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'))
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['instance_id']
+        path_param_values = self.encode_path_vars(instance_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/bluemix_v1/service_instances/{instance_id}'.format(**path_param_dict)
+        request = self.prepare_request(method='PUT', url=url, headers=headers, data=data)
+
+        response = self.send(request)
+        return response
+
+    #########################
+    # Resource Instances
+    #########################
+
+    def replace_service_instance(
+        self,
+        instance_id: str,
+        *,
+        organization_guid: str = None,
+        plan_id: str = None,
+        service_id: str = None,
+        space_guid: str = None,
+        context: 'Context' = None,
+        parameters: dict = None,
+        accepts_incomplete: bool = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Create (provision) a service instance.
+
+        Create a service instance with GUID. When your service broker receives a provision
+        request from the IBM Cloud platform, it MUST take whatever action is necessary to
+        create a new resource.
+        When a user creates a service instance from the IBM Cloud console or the IBM Cloud
+        CLI, the IBM Cloud platform validates that the user has permission to create the
+        service instance using IBM Cloud IAM. After this validation occurs, your service
+        broker's provision endpoint (PUT /v2/resource_instances/:instance_id) will be
+        invoked. When provisioning occurs, the IBM Cloud platform provides the following
+        values:
+        - The IBM Cloud context is included in the context variable
+        - The X-Broker-API-Originating-Identity will have the IBM IAM ID of the user that
+        initiated the request
+        - The parameters section will include the requested location (and additional
+        parameters required by your service).
+
+        :param str instance_id: The `instance_id` of a service instance is provided
+               by the IBM Cloud platform. This ID will be used for future requests to bind
+               and deprovision, so the broker can use it to correlate the resource it
+               creates.
+        :param str organization_guid: (optional) Deprecated in favor of `context`.
+               The IBM Cloud platform GUID for the organization under which the service
+               instance is to be provisioned. Although most brokers will not use this
+               field, it might be helpful for executing operations on a user's behalf. It
+               MUST be a non-empty string.
+        :param str plan_id: (optional) The ID of the plan for which the service
+               instance has been requested, which is stored in the catalog.json of your
+               broker. This value should be a GUID and it MUST be unique to a service.
+        :param str service_id: (optional) The ID of the service stored in the
+               catalog.json of your broker. This value should be a GUID and it MUST be a
+               non-empty string.
+        :param str space_guid: (optional) Deprecated in favor of `context`. The
+               identifier for the project space within the IBM Cloud platform
+               organization. Although most brokers will not use this field, it might be
+               helpful for executing operations on a user's behalf. It MUST be a non-empty
+               string.
+        :param Context context: (optional) Platform specific contextual information
+               under which the service instance is to be provisioned.
+        :param dict parameters: (optional) Configuration options for the service
+               instance. An opaque object, controller treats this as a blob. Brokers
+               should ensure that the client has provided valid configuration parameters
+               and values for the operation. If this field is not present in the request
+               message, then the broker MUST NOT change the parameters of the instance as
+               a result of this request.
+        :param bool accepts_incomplete: (optional) A value of true indicates that
+               both the IBM Cloud platform and the requesting client support asynchronous
+               deprovisioning. If this parameter is not included in the request, and the
+               broker can only deprovision a service instance of the requested plan
+               asynchronously, the broker MUST reject the request with a `422`
+               Unprocessable Entity.
+        :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 `Resp2079872Root` object
+        """
+
+        if instance_id is None:
+            raise ValueError('instance_id must be provided')
+        if context is not None:
+            context = convert_model(context)
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='replace_service_instance'
+        )
+        headers.update(sdk_headers)
+
+        params = {'accepts_incomplete': accepts_incomplete}
+
+        data = {
+            'organization_guid': organization_guid,
+            'plan_id': plan_id,
+            'service_id': service_id,
+            'space_guid': space_guid,
+            'context': context,
+            'parameters': parameters,
+        }
+        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'))
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['instance_id']
+        path_param_values = self.encode_path_vars(instance_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v2/service_instances/{instance_id}'.format(**path_param_dict)
+        request = self.prepare_request(method='PUT', url=url, headers=headers, params=params, data=data)
+
+        response = self.send(request)
+        return response
+
+    def update_service_instance(
+        self,
+        instance_id: str,
+        *,
+        service_id: str = None,
+        context: 'Context' = None,
+        parameters: dict = None,
+        plan_id: str = None,
+        previous_values: dict = None,
+        accepts_incomplete: bool = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Update a service instance.
+
+        Patch an instance by GUID. Enabling this endpoint allows your user to change plans
+        and service parameters in a provisioned service instance. If your offering
+        supports multiple plans, and you want users to be able to change plans for a
+        provisioned instance, you will need to enable the ability for users to update
+        their service instance.
+        To enable support for the update of the plan, a broker MUST declare support per
+        service by specifying  `"plan_updateable": true` in your brokers' catalog.json.
+
+        :param str instance_id: The ID of a previously provisioned service
+               instance.
+        :param str service_id: (optional) The ID of the service stored in the
+               catalog.json of your broker. This value should be a GUID. It MUST be a
+               non-empty string.
+        :param Context context: (optional) Platform specific contextual information
+               under which the service instance is to be provisioned.
+        :param dict parameters: (optional) Configuration options for the service
+               instance. An opaque object, controller treats this as a blob. Brokers
+               should ensure that the client has provided valid configuration parameters
+               and values for the operation. If this field is not present in the request
+               message, then the broker MUST NOT change the parameters of the instance as
+               a result of this request.
+        :param str plan_id: (optional) The ID of the plan for which the service
+               instance has been requested, which is stored in the catalog.json of your
+               broker. This value should be a GUID. MUST be unique to a service. If
+               present, MUST be a non-empty string. If this field is not present in the
+               request message, then the broker MUST NOT change the plan of the instance
+               as a result of this request.
+        :param dict previous_values: (optional) Information about the service
+               instance prior to the update.
+        :param bool accepts_incomplete: (optional) A value of true indicates that
+               both the IBM Cloud platform and the requesting client support asynchronous
+               deprovisioning. If this parameter is not included in the request, and the
+               broker can only deprovision a service instance of the requested plan
+               asynchronously, the broker MUST reject the request with a `422`
+               Unprocessable Entity.
+        :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 `Resp2079874Root` object
+        """
+
+        if instance_id is None:
+            raise ValueError('instance_id must be provided')
+        if context is not None:
+            context = convert_model(context)
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='update_service_instance'
+        )
+        headers.update(sdk_headers)
+
+        params = {'accepts_incomplete': accepts_incomplete}
+
+        data = {
+            'service_id': service_id,
+            'context': context,
+            'parameters': parameters,
+            'plan_id': plan_id,
+            'previous_values': previous_values,
+        }
+        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'))
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['instance_id']
+        path_param_values = self.encode_path_vars(instance_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v2/service_instances/{instance_id}'.format(**path_param_dict)
+        request = self.prepare_request(method='PATCH', url=url, headers=headers, params=params, data=data)
+
+        response = self.send(request)
+        return response
+
+    def delete_service_instance(
+        self, service_id: str, plan_id: str, instance_id: str, *, accepts_incomplete: bool = None, **kwargs
+    ) -> DetailedResponse:
+        """
+        Delete (deprovision) a service instance.
+
+        Delete (deprovision) a service instance by GUID. When a service broker receives a
+        deprovision request from the IBM Cloud platform, it MUST delete any resources it
+        created during the provision. Usually this means that all resources are
+        immediately reclaimed for future provisions.
+
+        :param str service_id: The ID of the service stored in the catalog.json of
+               your broker. This value should be a GUID. MUST be a non-empty string.
+        :param str plan_id: The ID of the plan for which the service instance has
+               been requested, which is stored in the catalog.json of your broker. This
+               value should be a GUID. MUST be a non-empty string.
+        :param str instance_id: The ID of a previously provisioned service
+               instance.
+        :param bool accepts_incomplete: (optional) A value of true indicates that
+               both the IBM Cloud platform and the requesting client support asynchronous
+               deprovisioning. If this parameter is not included in the request, and the
+               broker can only deprovision a service instance of the requested plan
+               asynchronously, the broker MUST reject the request with a `422`
+               Unprocessable Entity.
+        :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 `Resp2079874Root` object
+        """
+
+        if service_id is None:
+            raise ValueError('service_id must be provided')
+        if plan_id is None:
+            raise ValueError('plan_id must be provided')
+        if instance_id is None:
+            raise ValueError('instance_id must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='delete_service_instance'
+        )
+        headers.update(sdk_headers)
+
+        params = {'service_id': service_id, 'plan_id': plan_id, 'accepts_incomplete': accepts_incomplete}
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['instance_id']
+        path_param_values = self.encode_path_vars(instance_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v2/service_instances/{instance_id}'.format(**path_param_dict)
+        request = self.prepare_request(method='DELETE', url=url, headers=headers, params=params)
+
+        response = self.send(request)
+        return response
+
+    #########################
+    # Catalog
+    #########################
+
+    def list_catalog(self, **kwargs) -> DetailedResponse:
+        """
+        Get the catalog metadata stored within the broker.
+
+        This endpoints defines the contract between the broker and the IBM Cloud platform
+        for the services and plans that the broker supports. This endpoint returns the
+        catalog metadata stored within your broker. These values define the minimal
+        provisioning contract between your service and the IBM Cloud platform. All
+        additional catalog metadata that is not required for provisioning is stored within
+        the IBM Cloud catalog, and any updates to catalog display values that are used to
+        render your dashboard like links, icons, and i18n translated metadata should be
+        updated in the Resource Management Console (RMC), and not housed in your broker.
+        None of metadata stored in your broker is displayed in the IBM Cloud console or
+        the IBM Cloud CLI; the console and CLI will return what was set withn RMC and
+        stored in the IBM Cloud catalog.
+
+        :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 `Resp1874650Root` object
+        """
+
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='list_catalog'
+        )
+        headers.update(sdk_headers)
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+        headers['Accept'] = 'application/json'
+
+        url = '/v2/catalog'
+        request = self.prepare_request(method='GET', url=url, headers=headers)
+
+        response = self.send(request)
+        return response
+
+    #########################
+    # Last Operation (Async)
+    #########################
+
+    def get_last_operation(
+        self, instance_id: str, *, operation: str = None, plan_id: str = None, service_id: str = None, **kwargs
+    ) -> DetailedResponse:
+        """
+        Get the current status of a provision in-progress for a service instance.
+
+        Get `last_operation` for instance by GUID (for asynchronous provision calls). When
+        a broker returns status code `202 Accepted` during a provision, update, or
+        deprovision call, the IBM Cloud platform will begin polling the `last_operation`
+        endpoint to obtain the state of the last requested operation. The broker response
+        MUST contain the field `state` and MAY contain the field `description`.
+        Valid values for `state` are `in progress`, `succeeded`, and `failed`. The
+        platform will poll the `last_operation `endpoint as long as the broker returns
+        "state": "in progress". Returning "state": "succeeded" or "state": "failed" will
+        cause the platform to cease polling. The value provided for description will be
+        passed through to the platform API client and can be used to provide additional
+        detail for users about the progress of the operation.
+
+        :param str instance_id: The unique instance ID generated during
+               provisioning by the IBM Cloud platform.
+        :param str operation: (optional) A broker-provided identifier for the
+               operation. When a value for operation is included with asynchronous
+               responses for provision and update, and deprovision requests, the IBM Cloud
+               platform will provide the same value using this query parameter as a
+               URL-encoded string. If present, MUST be a non-empty string.
+        :param str plan_id: (optional) ID of the plan from the catalog.json in your
+               broker. If present, MUST be a non-empty string.
+        :param str service_id: (optional) ID of the service from the catalog.json
+               in your service broker. If present, MUST be a non-empty string.
+        :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 `Resp2079894Root` object
+        """
+
+        if instance_id is None:
+            raise ValueError('instance_id must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='get_last_operation'
+        )
+        headers.update(sdk_headers)
+
+        params = {'operation': operation, 'plan_id': plan_id, 'service_id': service_id}
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['instance_id']
+        path_param_values = self.encode_path_vars(instance_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v2/service_instances/{instance_id}/last_operation'.format(**path_param_dict)
+        request = self.prepare_request(method='GET', url=url, headers=headers, params=params)
+
+        response = self.send(request)
+        return response
+
+    #########################
+    # Bindings and Credentials
+    #########################
+
+    def replace_service_binding(
+        self,
+        binding_id: str,
+        instance_id: str,
+        *,
+        plan_id: str = None,
+        service_id: str = None,
+        bind_resource: 'BindResource' = None,
+        parameters: dict = None,
+        **kwargs,
+    ) -> DetailedResponse:
+        """
+        Bind a service instance to another resource.
+
+        Create binding by GUID on service instance.
+        If your service can be bound to applications in IBM Cloud, `bindable:true` must be
+        specified in the catalog.json of your service broker. If bindable, it must be able
+        to return API endpoints and credentials to your service consumers.
+        **Note:** Brokers that do not offer any bindable services do not need to implement
+        the endpoint for bind requests.
+        See the OSB 2.12 spec for more details on
+        [binding](https://github.com/openservicebrokerapi/servicebroker/blob/v2.12/spec.md#binding).
+
+        :param str binding_id: The `binding_id` is provided by the IBM Cloud
+               platform. This ID will be used for future unbind requests, so the broker
+               can use it to correlate the resource it creates.
+        :param str instance_id: The :`instance_id` is the ID of a previously
+               provisioned service instance.
+        :param str plan_id: (optional) The ID of the plan from the catalog.json in
+               your broker. If present, it MUST be a non-empty string.
+        :param str service_id: (optional) The ID of the service from the
+               catalog.json in your broker. If present, it MUST be a non-empty string.
+        :param BindResource bind_resource: (optional) A JSON object that contains
+               data for platform resources associated with the binding to be created.
+        :param dict parameters: (optional) Configuration options for the service
+               instance. An opaque object, controller treats this as a blob. Brokers
+               should ensure that the client has provided valid configuration parameters
+               and values for the operation. If this field is not present in the request
+               message, then the broker MUST NOT change the parameters of the instance as
+               a result of this 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 `Resp2079876Root` object
+        """
+
+        if binding_id is None:
+            raise ValueError('binding_id must be provided')
+        if instance_id is None:
+            raise ValueError('instance_id must be provided')
+        if bind_resource is not None:
+            bind_resource = convert_model(bind_resource)
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='replace_service_binding'
+        )
+        headers.update(sdk_headers)
+
+        data = {'plan_id': plan_id, 'service_id': service_id, 'bind_resource': bind_resource, 'parameters': parameters}
+        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'))
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['binding_id', 'instance_id']
+        path_param_values = self.encode_path_vars(binding_id, instance_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v2/service_instances/{instance_id}/service_bindings/{binding_id}'.format(**path_param_dict)
+        request = self.prepare_request(method='PUT', url=url, headers=headers, data=data)
+
+        response = self.send(request)
+        return response
+
+    def delete_service_binding(
+        self, binding_id: str, instance_id: str, plan_id: str, service_id: str, **kwargs
+    ) -> DetailedResponse:
+        """
+        Delete (unbind) the credentials bound to a resource.
+
+        Delete instance binding by GUID.
+        When a broker receives an unbind request from the IBM Cloud platform, it MUST
+        delete any resources associated with the binding. In the case where credentials
+        were generated, this might result in requests to the service instance failing to
+        authenticate.
+        **Note**: Brokers that do not provide any bindable services or plans do not need
+        to implement this endpoint.
+
+        :param str binding_id: The `binding_id` is the ID of a previously
+               provisioned binding for that service instance.
+        :param str instance_id: The `instance_id` is the ID of a previously
+               provisioned service instance.
+        :param str plan_id: The ID of the plan from the catalog.json in the broker.
+               It MUST be a non-empty string and should be a GUID.
+        :param str service_id: The ID of the service from the catalog.json in the
+               broker. It MUST be a non-empty string and should be a GUID.
+        :param dict headers: A `dict` containing the request headers
+        :return: A `DetailedResponse` containing the result, headers and HTTP status code.
+        :rtype: DetailedResponse
+        """
+
+        if binding_id is None:
+            raise ValueError('binding_id must be provided')
+        if instance_id is None:
+            raise ValueError('instance_id must be provided')
+        if plan_id is None:
+            raise ValueError('plan_id must be provided')
+        if service_id is None:
+            raise ValueError('service_id must be provided')
+        headers = {}
+        sdk_headers = get_sdk_headers(
+            service_name=self.DEFAULT_SERVICE_NAME, service_version='V1', operation_id='delete_service_binding'
+        )
+        headers.update(sdk_headers)
+
+        params = {'plan_id': plan_id, 'service_id': service_id}
+
+        if 'headers' in kwargs:
+            headers.update(kwargs.get('headers'))
+        headers['Accept'] = 'application/json'
+
+        path_param_keys = ['binding_id', 'instance_id']
+        path_param_values = self.encode_path_vars(binding_id, instance_id)
+        path_param_dict = dict(zip(path_param_keys, path_param_values))
+        url = '/v2/service_instances/{instance_id}/service_bindings/{binding_id}'.format(**path_param_dict)
+        request = self.prepare_request(method='DELETE', url=url, headers=headers, params=params)
+
+        response = self.send(request)
+        return response
+
+
+##############################################################################
+# Models
+##############################################################################
+
+
+class Resp1874644Root:
+    """
+    Check the active status of an enabled service.
+
+    :attr bool active: (optional) Indicates (from the viewpoint of the provider)
+          whether the service instance is active and is meaningful if enabled is true. The
+          default value is true if not specified.
+    :attr bool enabled: (optional) Indicates the current state of the service
+          instance.
+    :attr float last_active: (optional) Indicates when the service instance was last
+          accessed/modified/etc., and is meaningful if enabled is true AND active is
+          false. Represented as milliseconds since the epoch, but does not need to be
+          accurate to the second/hour.
+    """
+
+    def __init__(self, *, active: bool = None, enabled: bool = None, last_active: float = None) -> None:
+        """
+        Initialize a Resp1874644Root object.
+
+        :param bool active: (optional) Indicates (from the viewpoint of the
+               provider) whether the service instance is active and is meaningful if
+               enabled is true. The default value is true if not specified.
+        :param bool enabled: (optional) Indicates the current state of the service
+               instance.
+        :param float last_active: (optional) Indicates when the service instance
+               was last accessed/modified/etc., and is meaningful if enabled is true AND
+               active is false. Represented as milliseconds since the epoch, but does not
+               need to be accurate to the second/hour.
+        """
+        self.active = active
+        self.enabled = enabled
+        self.last_active = last_active
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Resp1874644Root':
+        """Initialize a Resp1874644Root object from a json dictionary."""
+        args = {}
+        if 'active' in _dict:
+            args['active'] = _dict.get('active')
+        if 'enabled' in _dict:
+            args['enabled'] = _dict.get('enabled')
+        if 'last_active' in _dict:
+            args['last_active'] = _dict.get('last_active')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Resp1874644Root 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, 'active') and self.active is not None:
+            _dict['active'] = self.active
+        if hasattr(self, 'enabled') and self.enabled is not None:
+            _dict['enabled'] = self.enabled
+        if hasattr(self, 'last_active') and self.last_active is not None:
+            _dict['last_active'] = self.last_active
+        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 Resp1874644Root object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Resp1874644Root') -> 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: 'Resp1874644Root') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Resp1874650Root:
+    """
+    Resp1874650Root.
+
+    :attr List[Services] services: (optional) List of services.
+    """
+
+    def __init__(self, *, services: List['Services'] = None) -> None:
+        """
+        Initialize a Resp1874650Root object.
+
+        :param List[Services] services: (optional) List of services.
+        """
+        self.services = services
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Resp1874650Root':
+        """Initialize a Resp1874650Root object from a json dictionary."""
+        args = {}
+        if 'services' in _dict:
+            args['services'] = [Services.from_dict(x) for x in _dict.get('services')]
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Resp1874650Root 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, 'services') and self.services is not None:
+            _dict['services'] = [x.to_dict() for x in self.services]
+        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 Resp1874650Root object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Resp1874650Root') -> 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: 'Resp1874650Root') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Resp2079872Root:
+    """
+    OK - MUST be returned if the service instance already exists, is fully provisioned,
+    and the requested parameters are identical to the existing service instance.
+
+    :attr str dashboard_url: (optional) The URL of a web-based management user
+          interface for the service instance; we refer to this as a service dashboard. The
+          URL MUST contain enough information for the dashboard to identify the resource
+          being accessed. Note: a broker that wishes to return `dashboard_url` for a
+          service instance MUST return it with the initial response to the provision
+          request, even if the service is provisioned asynchronously. If present, it MUST
+          be a non-empty string.
+    :attr str operation: (optional) For asynchronous responses, service brokers MAY
+          return an identifier representing the operation. The value of this field MUST be
+          provided by the platform with requests to the `last_operation` endpoint in a URL
+          encoded query parameter. If present, MUST be a non-empty string.
+    """
+
+    def __init__(self, *, dashboard_url: str = None, operation: str = None) -> None:
+        """
+        Initialize a Resp2079872Root object.
+
+        :param str dashboard_url: (optional) The URL of a web-based management user
+               interface for the service instance; we refer to this as a service
+               dashboard. The URL MUST contain enough information for the dashboard to
+               identify the resource being accessed. Note: a broker that wishes to return
+               `dashboard_url` for a service instance MUST return it with the initial
+               response to the provision request, even if the service is provisioned
+               asynchronously. If present, it MUST be a non-empty string.
+        :param str operation: (optional) For asynchronous responses, service
+               brokers MAY return an identifier representing the operation. The value of
+               this field MUST be provided by the platform with requests to the
+               `last_operation` endpoint in a URL encoded query parameter. If present,
+               MUST be a non-empty string.
+        """
+        self.dashboard_url = dashboard_url
+        self.operation = operation
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Resp2079872Root':
+        """Initialize a Resp2079872Root object from a json dictionary."""
+        args = {}
+        if 'dashboard_url' in _dict:
+            args['dashboard_url'] = _dict.get('dashboard_url')
+        if 'operation' in _dict:
+            args['operation'] = _dict.get('operation')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Resp2079872Root 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, 'dashboard_url') and self.dashboard_url is not None:
+            _dict['dashboard_url'] = self.dashboard_url
+        if hasattr(self, 'operation') and self.operation is not None:
+            _dict['operation'] = self.operation
+        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 Resp2079872Root object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Resp2079872Root') -> 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: 'Resp2079872Root') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Resp2079874Root:
+    """
+    Accepted - MUST be returned if the service instance provisioning is in progress. This
+    triggers the IBM Cloud platform to poll the Service Instance `last_operation` Endpoint
+    for operation status. Note that a re-sent `PUT` request MUST return a `202 Accepted`,
+    not a `200 OK`, if the service instance is not yet fully provisioned.
+
+    :attr str operation: (optional) For asynchronous responses, service brokers MAY
+          return an identifier representing the operation. The value of this field MUST be
+          provided by the platform with requests to the Last Operation endpoint in a URL
+          encoded query parameter. If present, MUST be a non-empty string.
+    """
+
+    def __init__(self, *, operation: str = None) -> None:
+        """
+        Initialize a Resp2079874Root object.
+
+        :param str operation: (optional) For asynchronous responses, service
+               brokers MAY return an identifier representing the operation. The value of
+               this field MUST be provided by the platform with requests to the Last
+               Operation endpoint in a URL encoded query parameter. If present, MUST be a
+               non-empty string.
+        """
+        self.operation = operation
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Resp2079874Root':
+        """Initialize a Resp2079874Root object from a json dictionary."""
+        args = {}
+        if 'operation' in _dict:
+            args['operation'] = _dict.get('operation')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Resp2079874Root 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, 'operation') and self.operation is not None:
+            _dict['operation'] = self.operation
+        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 Resp2079874Root object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Resp2079874Root') -> 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: 'Resp2079874Root') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Resp2079876Root:
+    """
+    Resp2079876Root.
+
+    :attr object credentials: (optional) A free-form hash of credentials that can be
+          used by applications or users to access the service.
+    :attr str syslog_drain_url: (optional) A URL to which logs MUST be streamed.
+          'requires':['syslog_drain'] MUST be declared in the Catalog endpoint or the
+          platform MUST consider the response invalid.
+    :attr str route_service_url: (optional) A URL to which the platform MUST proxy
+          requests for the address sent with bind_resource.route in the request body.
+          'requires':['route_forwarding'] MUST be declared in the Catalog endpoint or the
+          platform can consider the response invalid.
+    :attr List[VolumeMount] volume_mounts: (optional) An array of configuration for
+          remote storage devices to be mounted into an application container filesystem.
+          'requires':['volume_mount'] MUST be declared in the Catalog endpoint or the
+          platform can consider the response invalid.
+    """
+
+    def __init__(
+        self,
+        *,
+        credentials: object = None,
+        syslog_drain_url: str = None,
+        route_service_url: str = None,
+        volume_mounts: List['VolumeMount'] = None,
+    ) -> None:
+        """
+        Initialize a Resp2079876Root object.
+
+        :param object credentials: (optional) A free-form hash of credentials that
+               can be used by applications or users to access the service.
+        :param str syslog_drain_url: (optional) A URL to which logs MUST be
+               streamed. 'requires':['syslog_drain'] MUST be declared in the Catalog
+               endpoint or the platform MUST consider the response invalid.
+        :param str route_service_url: (optional) A URL to which the platform MUST
+               proxy requests for the address sent with bind_resource.route in the request
+               body. 'requires':['route_forwarding'] MUST be declared in the Catalog
+               endpoint or the platform can consider the response invalid.
+        :param List[VolumeMount] volume_mounts: (optional) An array of
+               configuration for remote storage devices to be mounted into an application
+               container filesystem. 'requires':['volume_mount'] MUST be declared in the
+               Catalog endpoint or the platform can consider the response invalid.
+        """
+        self.credentials = credentials
+        self.syslog_drain_url = syslog_drain_url
+        self.route_service_url = route_service_url
+        self.volume_mounts = volume_mounts
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Resp2079876Root':
+        """Initialize a Resp2079876Root object from a json dictionary."""
+        args = {}
+        if 'credentials' in _dict:
+            args['credentials'] = _dict.get('credentials')
+        if 'syslog_drain_url' in _dict:
+            args['syslog_drain_url'] = _dict.get('syslog_drain_url')
+        if 'route_service_url' in _dict:
+            args['route_service_url'] = _dict.get('route_service_url')
+        if 'volume_mounts' in _dict:
+            args['volume_mounts'] = [VolumeMount.from_dict(x) for x in _dict.get('volume_mounts')]
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Resp2079876Root 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, 'credentials') and self.credentials is not None:
+            _dict['credentials'] = self.credentials
+        if hasattr(self, 'syslog_drain_url') and self.syslog_drain_url is not None:
+            _dict['syslog_drain_url'] = self.syslog_drain_url
+        if hasattr(self, 'route_service_url') and self.route_service_url is not None:
+            _dict['route_service_url'] = self.route_service_url
+        if hasattr(self, 'volume_mounts') and self.volume_mounts is not None:
+            _dict['volume_mounts'] = [x.to_dict() for x in self.volume_mounts]
+        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 Resp2079876Root object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Resp2079876Root') -> 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: 'Resp2079876Root') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Resp2079894Root:
+    """
+    OK - MUST be returned upon successful processing of this request.
+
+    :attr str description: (optional) A user-facing message displayed to the
+          platform API client. Can be used to tell the user details about the status of
+          the operation. If present, MUST be a non-empty string.
+    :attr str state: Valid values are `in progress`, `succeeded`, and `failed`.
+          While `†state": "in progress†`, the platform SHOULD continue polling. A
+          response with `†state": "succeeded†` or `†state": "failed†` MUST cause
+          the platform to cease polling.
+    """
+
+    def __init__(self, state: str, *, description: str = None) -> None:
+        """
+        Initialize a Resp2079894Root object.
+
+        :param str state: Valid values are `in progress`, `succeeded`, and
+               `failed`. While `†state": "in progress†`, the platform SHOULD continue
+               polling. A response with `†state": "succeeded†` or `†state":
+               "failed†` MUST cause the platform to cease polling.
+        :param str description: (optional) A user-facing message displayed to the
+               platform API client. Can be used to tell the user details about the status
+               of the operation. If present, MUST be a non-empty string.
+        """
+        self.description = description
+        self.state = state
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Resp2079894Root':
+        """Initialize a Resp2079894Root object from a json dictionary."""
+        args = {}
+        if 'description' in _dict:
+            args['description'] = _dict.get('description')
+        if 'state' in _dict:
+            args['state'] = _dict.get('state')
+        else:
+            raise ValueError('Required property \'state\' not present in Resp2079894Root JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Resp2079894Root 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, 'description') and self.description is not None:
+            _dict['description'] = self.description
+        if hasattr(self, 'state') and self.state is not None:
+            _dict['state'] = self.state
+        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 Resp2079894Root object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Resp2079894Root') -> 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: 'Resp2079894Root') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Resp2448145Root:
+    """
+    Check the enabled status of active service.
+
+    :attr bool active: (optional) Indicates (from the viewpoint of the provider)
+          whether the service instance is active and is meaningful if `enabled` is true.
+          The default value is true if not specified.
+    :attr bool enabled: Indicates the current state of the service instance.
+    :attr int last_active: (optional) Indicates when the service instance was last
+          accessed or modified, and is meaningful if `enabled` is true AND `active` is
+          false.  Represented as milliseconds since the epoch, but does not need to be
+          accurate to the second/hour.
+    """
+
+    def __init__(self, enabled: bool, *, active: bool = None, last_active: int = None) -> None:
+        """
+        Initialize a Resp2448145Root object.
+
+        :param bool enabled: Indicates the current state of the service instance.
+        :param bool active: (optional) Indicates (from the viewpoint of the
+               provider) whether the service instance is active and is meaningful if
+               `enabled` is true.  The default value is true if not specified.
+        :param int last_active: (optional) Indicates when the service instance was
+               last accessed or modified, and is meaningful if `enabled` is true AND
+               `active` is false.  Represented as milliseconds since the epoch, but does
+               not need to be accurate to the second/hour.
+        """
+        self.active = active
+        self.enabled = enabled
+        self.last_active = last_active
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Resp2448145Root':
+        """Initialize a Resp2448145Root object from a json dictionary."""
+        args = {}
+        if 'active' in _dict:
+            args['active'] = _dict.get('active')
+        if 'enabled' in _dict:
+            args['enabled'] = _dict.get('enabled')
+        else:
+            raise ValueError('Required property \'enabled\' not present in Resp2448145Root JSON')
+        if 'last_active' in _dict:
+            args['last_active'] = _dict.get('last_active')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Resp2448145Root 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, 'active') and self.active is not None:
+            _dict['active'] = self.active
+        if hasattr(self, 'enabled') and self.enabled is not None:
+            _dict['enabled'] = self.enabled
+        if hasattr(self, 'last_active') and self.last_active is not None:
+            _dict['last_active'] = self.last_active
+        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 Resp2448145Root object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Resp2448145Root') -> 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: 'Resp2448145Root') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class BindResource:
+    """
+    A JSON object that contains data for platform resources associated with the binding to
+    be created.
+
+    :attr str account_id: (optional) Account owner of resource to bind.
+    :attr str serviceid_crn: (optional) Service ID of resource to bind.
+    :attr str target_crn: (optional) Target ID of resource to bind.
+    :attr str app_guid: (optional) GUID of an application associated with the
+          binding. For credentials bindings.
+    :attr str route: (optional) URL of the application to be intermediated. For
+          route services bindings.
+    """
+
+    def __init__(
+        self,
+        *,
+        account_id: str = None,
+        serviceid_crn: str = None,
+        target_crn: str = None,
+        app_guid: str = None,
+        route: str = None,
+    ) -> None:
+        """
+        Initialize a BindResource object.
+
+        :param str account_id: (optional) Account owner of resource to bind.
+        :param str serviceid_crn: (optional) Service ID of resource to bind.
+        :param str target_crn: (optional) Target ID of resource to bind.
+        :param str app_guid: (optional) GUID of an application associated with the
+               binding. For credentials bindings.
+        :param str route: (optional) URL of the application to be intermediated.
+               For route services bindings.
+        """
+        self.account_id = account_id
+        self.serviceid_crn = serviceid_crn
+        self.target_crn = target_crn
+        self.app_guid = app_guid
+        self.route = route
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'BindResource':
+        """Initialize a BindResource object from a json dictionary."""
+        args = {}
+        if 'account_id' in _dict:
+            args['account_id'] = _dict.get('account_id')
+        if 'serviceid_crn' in _dict:
+            args['serviceid_crn'] = _dict.get('serviceid_crn')
+        if 'target_crn' in _dict:
+            args['target_crn'] = _dict.get('target_crn')
+        if 'app_guid' in _dict:
+            args['app_guid'] = _dict.get('app_guid')
+        if 'route' in _dict:
+            args['route'] = _dict.get('route')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a BindResource object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'account_id') and self.account_id is not None:
+            _dict['account_id'] = self.account_id
+        if hasattr(self, 'serviceid_crn') and self.serviceid_crn is not None:
+            _dict['serviceid_crn'] = self.serviceid_crn
+        if hasattr(self, 'target_crn') and self.target_crn is not None:
+            _dict['target_crn'] = self.target_crn
+        if hasattr(self, 'app_guid') and self.app_guid is not None:
+            _dict['app_guid'] = self.app_guid
+        if hasattr(self, 'route') and self.route is not None:
+            _dict['route'] = self.route
+        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 BindResource object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'BindResource') -> 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: 'BindResource') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Context:
+    """
+    Platform specific contextual information under which the service instance is to be
+    provisioned.
+
+    :attr str account_id: (optional) Returns the ID of the account in IBM Cloud that
+          is provisioning the service instance.
+    :attr str crn: (optional) When a customer provisions your service in IBM Cloud,
+          a service instance is created and this instance is identified by its IBM Cloud
+          Resource Name (CRN). The CRN is utilized in all aspects of the interaction with
+          IBM Cloud including provisioning, binding (creating credentials and endpoints),
+          metering, dashboard display, and access control. From a service provider
+          perspective, the CRN can largely be treated as an opaque string to be utilized
+          with the IBM Cloud APIs, but it can also be decomposed via the following
+          structure:
+          `crn:version:cname:ctype:service-name:location:scope:service-instance:resource-type:resource`.
+    :attr str platform: (optional) Identifies the platform as "ibmcloud".
+    """
+
+    def __init__(self, *, account_id: str = None, crn: str = None, platform: str = None) -> None:
+        """
+        Initialize a Context object.
+
+        :param str account_id: (optional) Returns the ID of the account in IBM
+               Cloud that is provisioning the service instance.
+        :param str crn: (optional) When a customer provisions your service in IBM
+               Cloud, a service instance is created and this instance is identified by its
+               IBM Cloud Resource Name (CRN). The CRN is utilized in all aspects of the
+               interaction with IBM Cloud including provisioning, binding (creating
+               credentials and endpoints), metering, dashboard display, and access
+               control. From a service provider perspective, the CRN can largely be
+               treated as an opaque string to be utilized with the IBM Cloud APIs, but it
+               can also be decomposed via the following structure:
+               `crn:version:cname:ctype:service-name:location:scope:service-instance:resource-type:resource`.
+        :param str platform: (optional) Identifies the platform as "ibmcloud".
+        """
+        self.account_id = account_id
+        self.crn = crn
+        self.platform = platform
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Context':
+        """Initialize a Context object from a json dictionary."""
+        args = {}
+        if 'account_id' in _dict:
+            args['account_id'] = _dict.get('account_id')
+        if 'crn' in _dict:
+            args['crn'] = _dict.get('crn')
+        if 'platform' in _dict:
+            args['platform'] = _dict.get('platform')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Context object from a json dictionary."""
+        return cls.from_dict(_dict)
+
+    def to_dict(self) -> Dict:
+        """Return a json dictionary representing this model."""
+        _dict = {}
+        if hasattr(self, 'account_id') and self.account_id is not None:
+            _dict['account_id'] = self.account_id
+        if hasattr(self, 'crn') and self.crn is not None:
+            _dict['crn'] = self.crn
+        if hasattr(self, 'platform') and self.platform is not None:
+            _dict['platform'] = self.platform
+        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 Context object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Context') -> 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: 'Context') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Plans:
+    """
+    Where is this in the source?.
+
+    :attr str description: A short description of the plan. It MUST be a non-empty
+          string. The description is NOT displayed in the IBM Cloud catalog or IBM Cloud
+          CLI.
+    :attr bool free: (optional) When false, service instances of this plan have a
+          cost. The default is true.
+    :attr str id: An identifier used to correlate this plan in future requests to
+          the broker.  This MUST be globally unique within a platform marketplace. It MUST
+          be a non-empty string and using a GUID is RECOMMENDED. If you define your
+          service in the RMC, it will create a unique GUID for you to use. It is
+          recommended to use the RMC to define and generate these values and then use them
+          in your catalog.json metadata in your broker. This value is NOT displayed in the
+          IBM Cloud catalog or IBM Cloud CLI.
+    :attr str name: The programmatic name of the plan. It MUST be unique within the
+          service. All lowercase, no spaces. It MUST be a non-empty string, and it's NOT
+          displayed in the IBM Cloud catalog or IBM Cloud CLI.
+    """
+
+    def __init__(self, description: str, id: str, name: str, *, free: bool = None) -> None:
+        """
+        Initialize a Plans object.
+
+        :param str description: A short description of the plan. It MUST be a
+               non-empty string. The description is NOT displayed in the IBM Cloud catalog
+               or IBM Cloud CLI.
+        :param str id: An identifier used to correlate this plan in future requests
+               to the broker.  This MUST be globally unique within a platform marketplace.
+               It MUST be a non-empty string and using a GUID is RECOMMENDED. If you
+               define your service in the RMC, it will create a unique GUID for you to
+               use. It is recommended to use the RMC to define and generate these values
+               and then use them in your catalog.json metadata in your broker. This value
+               is NOT displayed in the IBM Cloud catalog or IBM Cloud CLI.
+        :param str name: The programmatic name of the plan. It MUST be unique
+               within the service. All lowercase, no spaces. It MUST be a non-empty
+               string, and it's NOT displayed in the IBM Cloud catalog or IBM Cloud CLI.
+        :param bool free: (optional) When false, service instances of this plan
+               have a cost. The default is true.
+        """
+        self.description = description
+        self.free = free
+        self.id = id
+        self.name = name
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Plans':
+        """Initialize a Plans object from a json dictionary."""
+        args = {}
+        if 'description' in _dict:
+            args['description'] = _dict.get('description')
+        else:
+            raise ValueError('Required property \'description\' not present in Plans JSON')
+        if 'free' in _dict:
+            args['free'] = _dict.get('free')
+        if 'id' in _dict:
+            args['id'] = _dict.get('id')
+        else:
+            raise ValueError('Required property \'id\' not present in Plans JSON')
+        if 'name' in _dict:
+            args['name'] = _dict.get('name')
+        else:
+            raise ValueError('Required property \'name\' not present in Plans JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Plans 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, 'description') and self.description is not None:
+            _dict['description'] = self.description
+        if hasattr(self, 'free') and self.free is not None:
+            _dict['free'] = self.free
+        if hasattr(self, 'id') and self.id is not None:
+            _dict['id'] = self.id
+        if hasattr(self, 'name') and self.name is not None:
+            _dict['name'] = self.name
+        return _dict
+
+    def _to_dict(self):
+        """Return a json dictionary representing this model."""
+        return self.to_dict()
+
+    def __str__(self) -> str:
+        """Return a `str` version of this Plans object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Plans') -> 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: 'Plans') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class Services:
+    """
+    The service object that describes the properties of your service.
+
+    :attr bool bindable: Specifies whether or not your service can be bound to
+          applications in IBM Cloud. If bindable, it must be able to return API endpoints
+          and credentials to your service consumers.
+    :attr str description: A short description of the service. It MUST be a
+          non-empty string. Note that this description is not displayed by the the IBM
+          Cloud console or IBM Cloud CLI.
+    :attr str id: An identifier used to correlate this service in future requests to
+          the broker. This MUST be globally unique within the IBM Cloud platform. It MUST
+          be a non-empty string, and using a GUID is recommended. Recommended: If you
+          define your service in the RMC, the RMC will generate a globally unique GUID
+          service ID that you can use in your service broker.
+    :attr str name: The service name is not your display name. Your service name
+          must follow the follow these rules:
+           - It must be all lowercase.
+           - It can't include spaces but may include hyphens (`-`).
+           - It must be less than 32 characters.
+           Your service name should include your company name. If your company has more
+          then one offering your service name should include both company and offering as
+          part of the name. For example, the Compose company has offerings for Redis and
+          Elasticsearch. Sample service names on IBM Cloud for these offerings would be
+          `compose-redis` and `compose-elasticsearch`.  Each of these service names have
+          associated display names that are shown in the IBM Cloud catalog: *Compose
+          Redis* and *Compose Elasticsearch*. Another company (e.g. FastJetMail) may only
+          have the single JetMail offering, in which case the service name should be
+          `fastjetmail`. Recommended: If you define your service in RMC, you can export a
+          catalog.json that will include the service name you defined within the RMC.
+    :attr bool plan_updateable: (optional) The Default is false. This specifices
+          whether or not you support plan changes for provisioned instances. If your
+          offering supports multiple plans, and you want users to be able to change plans
+          for a provisioned instance, you will need to enable the ability for users to
+          update their service instance by using /v2/service_instances/{instance_id}
+          PATCH.
+    :attr List[Plans] plans: A list of plans for this service that must contain at
+          least one plan.
+    """
+
+    def __init__(
+        self,
+        bindable: bool,
+        description: str,
+        id: str,
+        name: str,
+        plans: List['Plans'],
+        *,
+        plan_updateable: bool = None,
+    ) -> None:
+        """
+        Initialize a Services object.
+
+        :param bool bindable: Specifies whether or not your service can be bound to
+               applications in IBM Cloud. If bindable, it must be able to return API
+               endpoints and credentials to your service consumers.
+        :param str description: A short description of the service. It MUST be a
+               non-empty string. Note that this description is not displayed by the the
+               IBM Cloud console or IBM Cloud CLI.
+        :param str id: An identifier used to correlate this service in future
+               requests to the broker. This MUST be globally unique within the IBM Cloud
+               platform. It MUST be a non-empty string, and using a GUID is recommended.
+               Recommended: If you define your service in the RMC, the RMC will generate a
+               globally unique GUID service ID that you can use in your service broker.
+        :param str name: The service name is not your display name. Your service
+               name must follow the follow these rules:
+                - It must be all lowercase.
+                - It can't include spaces but may include hyphens (`-`).
+                - It must be less than 32 characters.
+                Your service name should include your company name. If your company has
+               more then one offering your service name should include both company and
+               offering as part of the name. For example, the Compose company has
+               offerings for Redis and Elasticsearch. Sample service names on IBM Cloud
+               for these offerings would be `compose-redis` and `compose-elasticsearch`.
+               Each of these service names have associated display names that are shown in
+               the IBM Cloud catalog: *Compose Redis* and *Compose Elasticsearch*. Another
+               company (e.g. FastJetMail) may only have the single JetMail offering, in
+               which case the service name should be `fastjetmail`. Recommended: If you
+               define your service in RMC, you can export a catalog.json that will include
+               the service name you defined within the RMC.
+        :param List[Plans] plans: A list of plans for this service that must
+               contain at least one plan.
+        :param bool plan_updateable: (optional) The Default is false. This
+               specifices whether or not you support plan changes for provisioned
+               instances. If your offering supports multiple plans, and you want users to
+               be able to change plans for a provisioned instance, you will need to enable
+               the ability for users to update their service instance by using
+               /v2/service_instances/{instance_id} PATCH.
+        """
+        self.bindable = bindable
+        self.description = description
+        self.id = id
+        self.name = name
+        self.plan_updateable = plan_updateable
+        self.plans = plans
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'Services':
+        """Initialize a Services object from a json dictionary."""
+        args = {}
+        if 'bindable' in _dict:
+            args['bindable'] = _dict.get('bindable')
+        else:
+            raise ValueError('Required property \'bindable\' not present in Services JSON')
+        if 'description' in _dict:
+            args['description'] = _dict.get('description')
+        else:
+            raise ValueError('Required property \'description\' not present in Services JSON')
+        if 'id' in _dict:
+            args['id'] = _dict.get('id')
+        else:
+            raise ValueError('Required property \'id\' not present in Services JSON')
+        if 'name' in _dict:
+            args['name'] = _dict.get('name')
+        else:
+            raise ValueError('Required property \'name\' not present in Services JSON')
+        if 'plan_updateable' in _dict:
+            args['plan_updateable'] = _dict.get('plan_updateable')
+        if 'plans' in _dict:
+            args['plans'] = [Plans.from_dict(x) for x in _dict.get('plans')]
+        else:
+            raise ValueError('Required property \'plans\' not present in Services JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a Services 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, 'bindable') and self.bindable is not None:
+            _dict['bindable'] = self.bindable
+        if hasattr(self, 'description') and self.description is not None:
+            _dict['description'] = self.description
+        if hasattr(self, 'id') and self.id is not None:
+            _dict['id'] = self.id
+        if hasattr(self, 'name') and self.name is not None:
+            _dict['name'] = self.name
+        if hasattr(self, 'plan_updateable') and self.plan_updateable is not None:
+            _dict['plan_updateable'] = self.plan_updateable
+        if hasattr(self, 'plans') and self.plans is not None:
+            _dict['plans'] = [x.to_dict() for x in self.plans]
+        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 Services object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'Services') -> 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: 'Services') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other
+
+
+class VolumeMount:
+    """
+    VolumeMount.
+
+    :attr str driver: A free-form hash of credentials that can be used by
+          applications or users to access the service.
+    :attr str container_dir: The path in the application container onto which the
+          volume will be mounted. This specification does not mandate what action the
+          platform is to take if the path specified already exists in the container.
+    :attr str mode: 'r' to mount the volume read-only or 'rw' to mount it
+          read-write.
+    :attr str device_type: A string specifying the type of device to mount.
+          Currently the only supported value is 'shared'.
+    :attr str device: Device object containing device_type specific details.
+          Currently only shared devices are supported.
+    """
+
+    def __init__(self, driver: str, container_dir: str, mode: str, device_type: str, device: str) -> None:
+        """
+        Initialize a VolumeMount object.
+
+        :param str driver: A free-form hash of credentials that can be used by
+               applications or users to access the service.
+        :param str container_dir: The path in the application container onto which
+               the volume will be mounted. This specification does not mandate what action
+               the platform is to take if the path specified already exists in the
+               container.
+        :param str mode: 'r' to mount the volume read-only or 'rw' to mount it
+               read-write.
+        :param str device_type: A string specifying the type of device to mount.
+               Currently the only supported value is 'shared'.
+        :param str device: Device object containing device_type specific details.
+               Currently only shared devices are supported.
+        """
+        self.driver = driver
+        self.container_dir = container_dir
+        self.mode = mode
+        self.device_type = device_type
+        self.device = device
+
+    @classmethod
+    def from_dict(cls, _dict: Dict) -> 'VolumeMount':
+        """Initialize a VolumeMount object from a json dictionary."""
+        args = {}
+        if 'driver' in _dict:
+            args['driver'] = _dict.get('driver')
+        else:
+            raise ValueError('Required property \'driver\' not present in VolumeMount JSON')
+        if 'container_dir' in _dict:
+            args['container_dir'] = _dict.get('container_dir')
+        else:
+            raise ValueError('Required property \'container_dir\' not present in VolumeMount JSON')
+        if 'mode' in _dict:
+            args['mode'] = _dict.get('mode')
+        else:
+            raise ValueError('Required property \'mode\' not present in VolumeMount JSON')
+        if 'device_type' in _dict:
+            args['device_type'] = _dict.get('device_type')
+        else:
+            raise ValueError('Required property \'device_type\' not present in VolumeMount JSON')
+        if 'device' in _dict:
+            args['device'] = _dict.get('device')
+        else:
+            raise ValueError('Required property \'device\' not present in VolumeMount JSON')
+        return cls(**args)
+
+    @classmethod
+    def _from_dict(cls, _dict):
+        """Initialize a VolumeMount 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, 'driver') and self.driver is not None:
+            _dict['driver'] = self.driver
+        if hasattr(self, 'container_dir') and self.container_dir is not None:
+            _dict['container_dir'] = self.container_dir
+        if hasattr(self, 'mode') and self.mode is not None:
+            _dict['mode'] = self.mode
+        if hasattr(self, 'device_type') and self.device_type is not None:
+            _dict['device_type'] = self.device_type
+        if hasattr(self, 'device') and self.device is not None:
+            _dict['device'] = self.device
+        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 VolumeMount object."""
+        return json.dumps(self.to_dict(), indent=2)
+
+    def __eq__(self, other: 'VolumeMount') -> 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: 'VolumeMount') -> bool:
+        """Return `true` when self and other are not equal, false otherwise."""
+        return not self == other