# coding: utf-8

"""
    Onshape REST API

    The Onshape REST API consumed by all clients.  # noqa: E501

    The version of the OpenAPI document: 1.113
    Contact: api-support@onshape.zendesk.com
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401
import sys  # noqa: F401

# python 2 and python 3 compatibility library
import six

from onshape_client.oas.api_client import ApiClient
from onshape_client.oas.exceptions import (
    ApiTypeError,
    ApiValueError
)
from onshape_client.oas.model_utils import (  # noqa: F401
    check_allowed_values,
    check_validations,
    date,
    datetime,
    file_type,
    int,
    none_type,
    str,
    validate_and_convert_types
)
from onshape_client.oas.models import bt_copy_document_params
from onshape_client.oas.models import bt_copy_document_info
from onshape_client.oas.models import bt_document_params
from onshape_client.oas.models import bt_document_info
from onshape_client.oas.models import bt_version_or_workspace_params
from onshape_client.oas.models import bt_version_info
from onshape_client.oas.models import bt_workspace_info
from onshape_client.oas.models import bt_export_model_params
from onshape_client.oas.models import bt_microversion_info
from onshape_client.oas.models import bt_acl_info
from onshape_client.oas.models import bt_global_tree_node_list_response
from onshape_client.oas.models import bt_document_element_info
from onshape_client.oas.models import bt_insertables_list_response
from onshape_client.oas.models import bt_version_or_workspace_info
from onshape_client.oas.models import bt_document_merge_info
from onshape_client.oas.models import bt_move_element_info
from onshape_client.oas.models import bt_move_element_params
from onshape_client.oas.models import bt_document_search_params
from onshape_client.oas.models import bt_share_params
from onshape_client.oas.models import bt_link_to_latest_document_params
from onshape_client.oas.models import bt_link_to_latest_document_info


class DocumentsApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __copy_workspace(
            self,
            did,
            wid,
            **kwargs
        ):
            """Copy Workspace  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.copy_workspace(did, wid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wid (str):

            Keyword Args:
                bt_copy_document_params (bt_copy_document_params.BTCopyDocumentParams): [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_copy_document_info.BTCopyDocumentInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wid'] = \
                wid
            return self.call_with_http_info(**kwargs)

        self.copy_workspace = Endpoint(
            settings={
                'response_type': (bt_copy_document_info.BTCopyDocumentInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}/workspaces/{wid}/copy',
                'operation_id': 'copy_workspace',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wid',
                    'bt_copy_document_params',
                ],
                'required': [
                    'did',
                    'wid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wid':
                        (str,),
                    'bt_copy_document_params':
                        (bt_copy_document_params.BTCopyDocumentParams,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wid': 'wid',
                },
                'location_map': {
                    'did': 'path',
                    'wid': 'path',
                    'bt_copy_document_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__copy_workspace
        )

        def __create_document(
            self,
            bt_document_params,
            **kwargs
        ):
            """Create document.  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.create_document(bt_document_params, async_req=True)
            >>> result = thread.get()

            Args:
                bt_document_params (bt_document_params.BTDocumentParams):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_document_info.BTDocumentInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['bt_document_params'] = \
                bt_document_params
            return self.call_with_http_info(**kwargs)

        self.create_document = Endpoint(
            settings={
                'response_type': (bt_document_info.BTDocumentInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents',
                'operation_id': 'create_document',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'bt_document_params',
                ],
                'required': [
                    'bt_document_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'bt_document_params':
                        (bt_document_params.BTDocumentParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'bt_document_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__create_document
        )

        def __create_version(
            self,
            did,
            bt_version_or_workspace_params,
            **kwargs
        ):
            """Create Version.  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.create_version(did, bt_version_or_workspace_params, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                bt_version_or_workspace_params (bt_version_or_workspace_params.BTVersionOrWorkspaceParams):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_version_info.BTVersionInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['bt_version_or_workspace_params'] = \
                bt_version_or_workspace_params
            return self.call_with_http_info(**kwargs)

        self.create_version = Endpoint(
            settings={
                'response_type': (bt_version_info.BTVersionInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/versions',
                'operation_id': 'create_version',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'bt_version_or_workspace_params',
                ],
                'required': [
                    'did',
                    'bt_version_or_workspace_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'bt_version_or_workspace_params':
                        (bt_version_or_workspace_params.BTVersionOrWorkspaceParams,),
                },
                'attribute_map': {
                    'did': 'did',
                },
                'location_map': {
                    'did': 'path',
                    'bt_version_or_workspace_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__create_version
        )

        def __create_workspace(
            self,
            did,
            **kwargs
        ):
            """Create Workspace  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.create_workspace(did, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):

            Keyword Args:
                bt_version_or_workspace_params (bt_version_or_workspace_params.BTVersionOrWorkspaceParams): [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_workspace_info.BTWorkspaceInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            return self.call_with_http_info(**kwargs)

        self.create_workspace = Endpoint(
            settings={
                'response_type': (bt_workspace_info.BTWorkspaceInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/workspaces',
                'operation_id': 'create_workspace',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'bt_version_or_workspace_params',
                ],
                'required': [
                    'did',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'bt_version_or_workspace_params':
                        (bt_version_or_workspace_params.BTVersionOrWorkspaceParams,),
                },
                'attribute_map': {
                    'did': 'did',
                },
                'location_map': {
                    'did': 'path',
                    'bt_version_or_workspace_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__create_workspace
        )

        def __delete_document(
            self,
            did,
            **kwargs
        ):
            """Delete Document  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.delete_document(did, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):

            Keyword Args:
                forever (bool): [optional] if omitted the server will use the default value of False
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            return self.call_with_http_info(**kwargs)

        self.delete_document = Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}',
                'operation_id': 'delete_document',
                'http_method': 'DELETE',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'forever',
                ],
                'required': [
                    'did',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'forever':
                        (bool,),
                },
                'attribute_map': {
                    'did': 'did',
                    'forever': 'forever',
                },
                'location_map': {
                    'did': 'path',
                    'forever': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__delete_document
        )

        def __delete_workspace(
            self,
            did,
            wid,
            **kwargs
        ):
            """Delete Workspace  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.delete_workspace(did, wid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wid (str):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wid'] = \
                wid
            return self.call_with_http_info(**kwargs)

        self.delete_workspace = Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/workspaces/{wid}',
                'operation_id': 'delete_workspace',
                'http_method': 'DELETE',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wid',
                ],
                'required': [
                    'did',
                    'wid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wid':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wid': 'wid',
                },
                'location_map': {
                    'did': 'path',
                    'wid': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__delete_workspace
        )

        def __download_external_data(
            self,
            did,
            fid,
            **kwargs
        ):
            """Download External Data  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.download_external_data(did, fid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                fid (str):

            Keyword Args:
                if_none_match (str): [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                file_type
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['fid'] = \
                fid
            return self.call_with_http_info(**kwargs)

        self.download_external_data = Endpoint(
            settings={
                'response_type': (file_type,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/externaldata/{fid}',
                'operation_id': 'download_external_data',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'fid',
                    'if_none_match',
                ],
                'required': [
                    'did',
                    'fid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'fid':
                        (str,),
                    'if_none_match':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                    'fid': 'fid',
                    'if_none_match': 'If-None-Match',
                },
                'location_map': {
                    'did': 'path',
                    'fid': 'path',
                    'if_none_match': 'header',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+octet-stream;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__download_external_data
        )

        def __export2_json(
            self,
            did,
            wv,
            wvid,
            eid,
            **kwargs
        ):
            """export2_json  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.export2_json(did, wv, wvid, eid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wv (str):
                wvid (str):
                eid (str):

            Keyword Args:
                bt_export_model_params (bt_export_model_params.BTExportModelParams): [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wv'] = \
                wv
            kwargs['wvid'] = \
                wvid
            kwargs['eid'] = \
                eid
            return self.call_with_http_info(**kwargs)

        self.export2_json = Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/{wv}/{wvid}/e/{eid}/export',
                'operation_id': 'export2_json',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wv',
                    'wvid',
                    'eid',
                    'bt_export_model_params',
                ],
                'required': [
                    'did',
                    'wv',
                    'wvid',
                    'eid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wv':
                        (str,),
                    'wvid':
                        (str,),
                    'eid':
                        (str,),
                    'bt_export_model_params':
                        (bt_export_model_params.BTExportModelParams,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wv': 'wv',
                    'wvid': 'wvid',
                    'eid': 'eid',
                },
                'location_map': {
                    'did': 'path',
                    'wv': 'path',
                    'wvid': 'path',
                    'eid': 'path',
                    'bt_export_model_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+octet-stream;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__export2_json
        )

        def __get_current_microversion(
            self,
            did,
            wv,
            wvid,
            **kwargs
        ):
            """Get Current Document Microversion  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_current_microversion(did, wv, wvid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wv (str):
                wvid (str):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_microversion_info.BTMicroversionInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wv'] = \
                wv
            kwargs['wvid'] = \
                wvid
            return self.call_with_http_info(**kwargs)

        self.get_current_microversion = Endpoint(
            settings={
                'response_type': (bt_microversion_info.BTMicroversionInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/{wv}/{wvid}/currentmicroversion',
                'operation_id': 'get_current_microversion',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wv',
                    'wvid',
                ],
                'required': [
                    'did',
                    'wv',
                    'wvid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wv':
                        (str,),
                    'wvid':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wv': 'wv',
                    'wvid': 'wvid',
                },
                'location_map': {
                    'did': 'path',
                    'wv': 'path',
                    'wvid': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_current_microversion
        )

        def __get_document(
            self,
            did,
            **kwargs
        ):
            """Get Document  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_document(did, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_document_info.BTDocumentInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            return self.call_with_http_info(**kwargs)

        self.get_document = Endpoint(
            settings={
                'response_type': (bt_document_info.BTDocumentInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}',
                'operation_id': 'get_document',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                ],
                'required': [
                    'did',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                },
                'location_map': {
                    'did': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_document
        )

        def __get_document_acl(
            self,
            did,
            **kwargs
        ):
            """Get Access Control List  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_document_acl(did, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_acl_info.BTAclInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            return self.call_with_http_info(**kwargs)

        self.get_document_acl = Endpoint(
            settings={
                'response_type': (bt_acl_info.BTAclInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}/acl',
                'operation_id': 'get_document_acl',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                ],
                'required': [
                    'did',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                },
                'location_map': {
                    'did': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_document_acl
        )

        def __get_document_permission_set(
            self,
            did,
            **kwargs
        ):
            """Get Document Permissions  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_document_permission_set(did, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bool, date, datetime, dict, float, int, list, str
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            return self.call_with_http_info(**kwargs)

        self.get_document_permission_set = Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}/permissionset',
                'operation_id': 'get_document_permission_set',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                ],
                'required': [
                    'did',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                },
                'location_map': {
                    'did': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_document_permission_set
        )

        def __get_document_versions(
            self,
            did,
            **kwargs
        ):
            """Get Versions  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_document_versions(did, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):

            Keyword Args:
                offset (int): [optional] if omitted the server will use the default value of 0
                limit (int): [optional] if omitted the server will use the default value of 0
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                [bt_version_info.BTVersionInfo]
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            return self.call_with_http_info(**kwargs)

        self.get_document_versions = Endpoint(
            settings={
                'response_type': ([bt_version_info.BTVersionInfo],),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/versions',
                'operation_id': 'get_document_versions',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'offset',
                    'limit',
                ],
                'required': [
                    'did',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'offset':
                        (int,),
                    'limit':
                        (int,),
                },
                'attribute_map': {
                    'did': 'did',
                    'offset': 'offset',
                    'limit': 'limit',
                },
                'location_map': {
                    'did': 'path',
                    'offset': 'query',
                    'limit': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_document_versions
        )

        def __get_document_workspaces(
            self,
            did,
            **kwargs
        ):
            """Get Workspaces  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_document_workspaces(did, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                [bt_workspace_info.BTWorkspaceInfo]
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            return self.call_with_http_info(**kwargs)

        self.get_document_workspaces = Endpoint(
            settings={
                'response_type': ([bt_workspace_info.BTWorkspaceInfo],),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/workspaces',
                'operation_id': 'get_document_workspaces',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                ],
                'required': [
                    'did',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                },
                'location_map': {
                    'did': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_document_workspaces
        )

        def __get_documents(
            self,
            **kwargs
        ):
            """Get Documents  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_documents(async_req=True)
            >>> result = thread.get()


            Keyword Args:
                q (str): [optional] if omitted the server will use the default value of ''
                filter (int): [optional]
                owner (str): [optional] if omitted the server will use the default value of ''
                owner_type (int): [optional] if omitted the server will use the default value of 1
                sort_column (str): [optional] if omitted the server will use the default value of 'createdAt'
                sort_order (str): [optional] if omitted the server will use the default value of 'desc'
                offset (int): [optional] if omitted the server will use the default value of 0
                limit (int): [optional] if omitted the server will use the default value of 20
                label (str): [optional]
                project (str): [optional]
                parent_id (str): [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_global_tree_node_list_response.BTGlobalTreeNodeListResponse
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            return self.call_with_http_info(**kwargs)

        self.get_documents = Endpoint(
            settings={
                'response_type': (bt_global_tree_node_list_response.BTGlobalTreeNodeListResponse,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents',
                'operation_id': 'get_documents',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'q',
                    'filter',
                    'owner',
                    'owner_type',
                    'sort_column',
                    'sort_order',
                    'offset',
                    'limit',
                    'label',
                    'project',
                    'parent_id',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'q':
                        (str,),
                    'filter':
                        (int,),
                    'owner':
                        (str,),
                    'owner_type':
                        (int,),
                    'sort_column':
                        (str,),
                    'sort_order':
                        (str,),
                    'offset':
                        (int,),
                    'limit':
                        (int,),
                    'label':
                        (str,),
                    'project':
                        (str,),
                    'parent_id':
                        (str,),
                },
                'attribute_map': {
                    'q': 'q',
                    'filter': 'filter',
                    'owner': 'owner',
                    'owner_type': 'ownerType',
                    'sort_column': 'sortColumn',
                    'sort_order': 'sortOrder',
                    'offset': 'offset',
                    'limit': 'limit',
                    'label': 'label',
                    'project': 'project',
                    'parent_id': 'parentId',
                },
                'location_map': {
                    'q': 'query',
                    'filter': 'query',
                    'owner': 'query',
                    'owner_type': 'query',
                    'sort_column': 'query',
                    'sort_order': 'query',
                    'offset': 'query',
                    'limit': 'query',
                    'label': 'query',
                    'project': 'query',
                    'parent_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_documents
        )

        def __get_elements_in_document(
            self,
            did,
            wvm,
            wvmid,
            **kwargs
        ):
            """Get a list of elements in the workspace, version, or microversion of the document.  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_elements_in_document(did, wvm, wvmid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wvm (str):
                wvmid (str):

            Keyword Args:
                element_type (str): [optional] if omitted the server will use the default value of ''
                element_id (str): [optional] if omitted the server will use the default value of ''
                with_thumbnails (bool): [optional] if omitted the server will use the default value of False
                link_document_id (str): [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                [bt_document_element_info.BTDocumentElementInfo]
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wvm'] = \
                wvm
            kwargs['wvmid'] = \
                wvmid
            return self.call_with_http_info(**kwargs)

        self.get_elements_in_document = Endpoint(
            settings={
                'response_type': ([bt_document_element_info.BTDocumentElementInfo],),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/{wvm}/{wvmid}/elements',
                'operation_id': 'get_elements_in_document',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wvm',
                    'wvmid',
                    'element_type',
                    'element_id',
                    'with_thumbnails',
                    'link_document_id',
                ],
                'required': [
                    'did',
                    'wvm',
                    'wvmid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wvm':
                        (str,),
                    'wvmid':
                        (str,),
                    'element_type':
                        (str,),
                    'element_id':
                        (str,),
                    'with_thumbnails':
                        (bool,),
                    'link_document_id':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wvm': 'wvm',
                    'wvmid': 'wvmid',
                    'element_type': 'elementType',
                    'element_id': 'elementId',
                    'with_thumbnails': 'withThumbnails',
                    'link_document_id': 'linkDocumentId',
                },
                'location_map': {
                    'did': 'path',
                    'wvm': 'path',
                    'wvmid': 'path',
                    'element_type': 'query',
                    'element_id': 'query',
                    'with_thumbnails': 'query',
                    'link_document_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_elements_in_document
        )

        def __get_insertables(
            self,
            did,
            wvm,
            wvmid,
            **kwargs
        ):
            """Insertable List for Document Version.  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_insertables(did, wvm, wvmid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wvm (str):
                wvmid (str):

            Keyword Args:
                beta_capability_ids ([str]): [optional]
                include_parts (bool): [optional] if omitted the server will use the default value of False
                include_surfaces (bool): [optional] if omitted the server will use the default value of False
                include_wires (bool): [optional] if omitted the server will use the default value of False
                include_sketches (bool): [optional] if omitted the server will use the default value of False
                include_reference_features (bool): [optional] if omitted the server will use the default value of False
                include_assemblies (bool): [optional] if omitted the server will use the default value of False
                include_features (bool): [optional] if omitted the server will use the default value of False
                include_feature_studios (bool): [optional] if omitted the server will use the default value of False
                include_part_studios (bool): [optional] if omitted the server will use the default value of False
                include_blobs (bool): [optional] if omitted the server will use the default value of False
                include_meshes (bool): [optional] if omitted the server will use the default value of False
                include_flattened_bodies (bool): [optional] if omitted the server will use the default value of False
                allowed_blob_mime_types (str): [optional] if omitted the server will use the default value of ''
                max_feature_script_version (int): [optional] if omitted the server will use the default value of 0
                include_applications (bool): [optional] if omitted the server will use the default value of False
                allowed_application_mime_types (str): [optional] if omitted the server will use the default value of ''
                include_composite_parts (bool): [optional] if omitted the server will use the default value of False
                include_fs_tables (bool): [optional] if omitted the server will use the default value of False
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_insertables_list_response.BTInsertablesListResponse
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wvm'] = \
                wvm
            kwargs['wvmid'] = \
                wvmid
            return self.call_with_http_info(**kwargs)

        self.get_insertables = Endpoint(
            settings={
                'response_type': (bt_insertables_list_response.BTInsertablesListResponse,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/{wvm}/{wvmid}/insertables',
                'operation_id': 'get_insertables',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wvm',
                    'wvmid',
                    'beta_capability_ids',
                    'include_parts',
                    'include_surfaces',
                    'include_wires',
                    'include_sketches',
                    'include_reference_features',
                    'include_assemblies',
                    'include_features',
                    'include_feature_studios',
                    'include_part_studios',
                    'include_blobs',
                    'include_meshes',
                    'include_flattened_bodies',
                    'allowed_blob_mime_types',
                    'max_feature_script_version',
                    'include_applications',
                    'allowed_application_mime_types',
                    'include_composite_parts',
                    'include_fs_tables',
                ],
                'required': [
                    'did',
                    'wvm',
                    'wvmid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wvm':
                        (str,),
                    'wvmid':
                        (str,),
                    'beta_capability_ids':
                        ([str],),
                    'include_parts':
                        (bool,),
                    'include_surfaces':
                        (bool,),
                    'include_wires':
                        (bool,),
                    'include_sketches':
                        (bool,),
                    'include_reference_features':
                        (bool,),
                    'include_assemblies':
                        (bool,),
                    'include_features':
                        (bool,),
                    'include_feature_studios':
                        (bool,),
                    'include_part_studios':
                        (bool,),
                    'include_blobs':
                        (bool,),
                    'include_meshes':
                        (bool,),
                    'include_flattened_bodies':
                        (bool,),
                    'allowed_blob_mime_types':
                        (str,),
                    'max_feature_script_version':
                        (int,),
                    'include_applications':
                        (bool,),
                    'allowed_application_mime_types':
                        (str,),
                    'include_composite_parts':
                        (bool,),
                    'include_fs_tables':
                        (bool,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wvm': 'wvm',
                    'wvmid': 'wvmid',
                    'beta_capability_ids': 'betaCapabilityIds',
                    'include_parts': 'includeParts',
                    'include_surfaces': 'includeSurfaces',
                    'include_wires': 'includeWires',
                    'include_sketches': 'includeSketches',
                    'include_reference_features': 'includeReferenceFeatures',
                    'include_assemblies': 'includeAssemblies',
                    'include_features': 'includeFeatures',
                    'include_feature_studios': 'includeFeatureStudios',
                    'include_part_studios': 'includePartStudios',
                    'include_blobs': 'includeBlobs',
                    'include_meshes': 'includeMeshes',
                    'include_flattened_bodies': 'includeFlattenedBodies',
                    'allowed_blob_mime_types': 'allowedBlobMimeTypes',
                    'max_feature_script_version': 'maxFeatureScriptVersion',
                    'include_applications': 'includeApplications',
                    'allowed_application_mime_types': 'allowedApplicationMimeTypes',
                    'include_composite_parts': 'includeCompositeParts',
                    'include_fs_tables': 'includeFSTables',
                },
                'location_map': {
                    'did': 'path',
                    'wvm': 'path',
                    'wvmid': 'path',
                    'beta_capability_ids': 'query',
                    'include_parts': 'query',
                    'include_surfaces': 'query',
                    'include_wires': 'query',
                    'include_sketches': 'query',
                    'include_reference_features': 'query',
                    'include_assemblies': 'query',
                    'include_features': 'query',
                    'include_feature_studios': 'query',
                    'include_part_studios': 'query',
                    'include_blobs': 'query',
                    'include_meshes': 'query',
                    'include_flattened_bodies': 'query',
                    'allowed_blob_mime_types': 'query',
                    'max_feature_script_version': 'query',
                    'include_applications': 'query',
                    'allowed_application_mime_types': 'query',
                    'include_composite_parts': 'query',
                    'include_fs_tables': 'query',
                },
                'collection_format_map': {
                    'beta_capability_ids': 'multi',
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_insertables
        )

        def __get_version(
            self,
            did,
            vid,
            **kwargs
        ):
            """Get Version  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.get_version(did, vid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                vid (str):

            Keyword Args:
                parents (bool): [optional] if omitted the server will use the default value of False
                link_document_id (str): [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_version_info.BTVersionInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['vid'] = \
                vid
            return self.call_with_http_info(**kwargs)

        self.get_version = Endpoint(
            settings={
                'response_type': (bt_version_info.BTVersionInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/versions/{vid}',
                'operation_id': 'get_version',
                'http_method': 'GET',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'vid',
                    'parents',
                    'link_document_id',
                ],
                'required': [
                    'did',
                    'vid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'vid':
                        (str,),
                    'parents':
                        (bool,),
                    'link_document_id':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                    'vid': 'vid',
                    'parents': 'parents',
                    'link_document_id': 'linkDocumentId',
                },
                'location_map': {
                    'did': 'path',
                    'vid': 'path',
                    'parents': 'query',
                    'link_document_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_version
        )

        def __merge_into_workspace(
            self,
            did,
            wid,
            bt_version_or_workspace_info,
            **kwargs
        ):
            """Merge into workspace  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.merge_into_workspace(did, wid, bt_version_or_workspace_info, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wid (str):
                bt_version_or_workspace_info (bt_version_or_workspace_info.BTVersionOrWorkspaceInfo):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_document_merge_info.BTDocumentMergeInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wid'] = \
                wid
            kwargs['bt_version_or_workspace_info'] = \
                bt_version_or_workspace_info
            return self.call_with_http_info(**kwargs)

        self.merge_into_workspace = Endpoint(
            settings={
                'response_type': (bt_document_merge_info.BTDocumentMergeInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}/workspaces/{wid}/merge',
                'operation_id': 'merge_into_workspace',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wid',
                    'bt_version_or_workspace_info',
                ],
                'required': [
                    'did',
                    'wid',
                    'bt_version_or_workspace_info',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wid':
                        (str,),
                    'bt_version_or_workspace_info':
                        (bt_version_or_workspace_info.BTVersionOrWorkspaceInfo,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wid': 'wid',
                },
                'location_map': {
                    'did': 'path',
                    'wid': 'path',
                    'bt_version_or_workspace_info': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__merge_into_workspace
        )

        def __move_elements_to_document(
            self,
            did,
            wid,
            bt_move_element_params,
            **kwargs
        ):
            """Move Elements  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.move_elements_to_document(did, wid, bt_move_element_params, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wid (str):
                bt_move_element_params (bt_move_element_params.BTMoveElementParams):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_move_element_info.BTMoveElementInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wid'] = \
                wid
            kwargs['bt_move_element_params'] = \
                bt_move_element_params
            return self.call_with_http_info(**kwargs)

        self.move_elements_to_document = Endpoint(
            settings={
                'response_type': (bt_move_element_info.BTMoveElementInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/w/{wid}/moveelement',
                'operation_id': 'move_elements_to_document',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wid',
                    'bt_move_element_params',
                ],
                'required': [
                    'did',
                    'wid',
                    'bt_move_element_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wid':
                        (str,),
                    'bt_move_element_params':
                        (bt_move_element_params.BTMoveElementParams,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wid': 'wid',
                },
                'location_map': {
                    'did': 'path',
                    'wid': 'path',
                    'bt_move_element_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__move_elements_to_document
        )

        def __restore_from_history(
            self,
            did,
            wid,
            vm,
            vmid,
            **kwargs
        ):
            """Restore version or microversion to workspace.  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.restore_from_history(did, wid, vm, vmid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wid (str):
                vm (str):
                vmid (str):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wid'] = \
                wid
            kwargs['vm'] = \
                vm
            kwargs['vmid'] = \
                vmid
            return self.call_with_http_info(**kwargs)

        self.restore_from_history = Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}/w/{wid}/restore/{vm}/{vmid}',
                'operation_id': 'restore_from_history',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wid',
                    'vm',
                    'vmid',
                ],
                'required': [
                    'did',
                    'wid',
                    'vm',
                    'vmid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wid':
                        (str,),
                    'vm':
                        (str,),
                    'vmid':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wid': 'wid',
                    'vm': 'vm',
                    'vmid': 'vmid',
                },
                'location_map': {
                    'did': 'path',
                    'wid': 'path',
                    'vm': 'path',
                    'vmid': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__restore_from_history
        )

        def __search(
            self,
            bt_document_search_params,
            **kwargs
        ):
            """search  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.search(bt_document_search_params, async_req=True)
            >>> result = thread.get()

            Args:
                bt_document_search_params (bt_document_search_params.BTDocumentSearchParams):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['bt_document_search_params'] = \
                bt_document_search_params
            return self.call_with_http_info(**kwargs)

        self.search = Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/search',
                'operation_id': 'search',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'bt_document_search_params',
                ],
                'required': [
                    'bt_document_search_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'bt_document_search_params':
                        (bt_document_search_params.BTDocumentSearchParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'bt_document_search_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__search
        )

        def __share_document(
            self,
            did,
            bt_share_params,
            **kwargs
        ):
            """Share Document  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.share_document(did, bt_share_params, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                bt_share_params (bt_share_params.BTShareParams):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_acl_info.BTAclInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['bt_share_params'] = \
                bt_share_params
            return self.call_with_http_info(**kwargs)

        self.share_document = Endpoint(
            settings={
                'response_type': (bt_acl_info.BTAclInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}/share',
                'operation_id': 'share_document',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'bt_share_params',
                ],
                'required': [
                    'did',
                    'bt_share_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'bt_share_params':
                        (bt_share_params.BTShareParams,),
                },
                'attribute_map': {
                    'did': 'did',
                },
                'location_map': {
                    'did': 'path',
                    'bt_share_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__share_document
        )

        def __sync_application_elements(
            self,
            did,
            wid,
            application_element_ids,
            **kwargs
        ):
            """Sync Application Elements  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.sync_application_elements(did, wid, application_element_ids, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wid (str):
                application_element_ids ([str]):

            Keyword Args:
                description (str): [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wid'] = \
                wid
            kwargs['application_element_ids'] = \
                application_element_ids
            return self.call_with_http_info(**kwargs)

        self.sync_application_elements = Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/w/{wid}/syncApplicationElements',
                'operation_id': 'sync_application_elements',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wid',
                    'application_element_ids',
                    'description',
                ],
                'required': [
                    'did',
                    'wid',
                    'application_element_ids',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wid':
                        (str,),
                    'application_element_ids':
                        ([str],),
                    'description':
                        (str,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wid': 'wid',
                    'application_element_ids': 'applicationElementIds',
                    'description': 'description',
                },
                'location_map': {
                    'did': 'path',
                    'wid': 'path',
                    'application_element_ids': 'query',
                    'description': 'query',
                },
                'collection_format_map': {
                    'application_element_ids': 'multi',
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__sync_application_elements
        )

        def __un_share_document(
            self,
            did,
            eid,
            **kwargs
        ):
            """Unshare Document  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.un_share_document(did, eid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                eid (str):

            Keyword Args:
                entry_type (int): [optional] if omitted the server will use the default value of 0
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['eid'] = \
                eid
            return self.call_with_http_info(**kwargs)

        self.un_share_document = Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}/share/{eid}',
                'operation_id': 'un_share_document',
                'http_method': 'DELETE',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'eid',
                    'entry_type',
                ],
                'required': [
                    'did',
                    'eid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'eid':
                        (str,),
                    'entry_type':
                        (int,),
                },
                'attribute_map': {
                    'did': 'did',
                    'eid': 'eid',
                    'entry_type': 'entryType',
                },
                'location_map': {
                    'did': 'path',
                    'eid': 'path',
                    'entry_type': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__un_share_document
        )

        def __update_document_attributes(
            self,
            did,
            bt_document_params,
            **kwargs
        ):
            """Update Document Attributes.  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.update_document_attributes(did, bt_document_params, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                bt_document_params (bt_document_params.BTDocumentParams):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['bt_document_params'] = \
                bt_document_params
            return self.call_with_http_info(**kwargs)

        self.update_document_attributes = Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/{did}',
                'operation_id': 'update_document_attributes',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'bt_document_params',
                ],
                'required': [
                    'did',
                    'bt_document_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'bt_document_params':
                        (bt_document_params.BTDocumentParams,),
                },
                'attribute_map': {
                    'did': 'did',
                },
                'location_map': {
                    'did': 'path',
                    'bt_document_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__update_document_attributes
        )

        def __update_external_references_to_latest_documents(
            self,
            did,
            wid,
            eid,
            **kwargs
        ):
            """Update External References to Latest  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True
            >>> thread = api.update_external_references_to_latest_documents(did, wid, eid, async_req=True)
            >>> result = thread.get()

            Args:
                did (str):
                wid (str):
                eid (str):

            Keyword Args:
                bt_link_to_latest_document_params (bt_link_to_latest_document_params.BTLinkToLatestDocumentParams): [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int): specifies the index of the server
                    that we want to use.
                    Default is 0.
                async_req (bool): execute request asynchronously

            Returns:
                bt_link_to_latest_document_info.BTLinkToLatestDocumentInfo
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index', 0)
            kwargs['did'] = \
                did
            kwargs['wid'] = \
                wid
            kwargs['eid'] = \
                eid
            return self.call_with_http_info(**kwargs)

        self.update_external_references_to_latest_documents = Endpoint(
            settings={
                'response_type': (bt_link_to_latest_document_info.BTLinkToLatestDocumentInfo,),
                'auth': [
                    'OAuth2'
                ],
                'endpoint_path': '/api/documents/d/{did}/w/{wid}/e/{eid}/latestdocumentreferences',
                'operation_id': 'update_external_references_to_latest_documents',
                'http_method': 'POST',
                'servers': [],
            },
            params_map={
                'all': [
                    'did',
                    'wid',
                    'eid',
                    'bt_link_to_latest_document_params',
                ],
                'required': [
                    'did',
                    'wid',
                    'eid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'did':
                        (str,),
                    'wid':
                        (str,),
                    'eid':
                        (str,),
                    'bt_link_to_latest_document_params':
                        (bt_link_to_latest_document_params.BTLinkToLatestDocumentParams,),
                },
                'attribute_map': {
                    'did': 'did',
                    'wid': 'wid',
                    'eid': 'eid',
                },
                'location_map': {
                    'did': 'path',
                    'wid': 'path',
                    'eid': 'path',
                    'bt_link_to_latest_document_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/vnd.onshape.v1+json;charset=UTF-8;qs=0.1'
                ],
                'content_type': [
                    'application/json;charset=UTF-8; qs=0.09'
                ]
            },
            api_client=api_client,
            callable=__update_external_references_to_latest_documents
        )


class Endpoint(object):
    def __init__(self, settings=None, params_map=None, root_map=None,
                 headers_map=None, api_client=None, callable=None):
        """Creates an endpoint

        Args:
            settings (dict): see below key value pairs
                'response_type' (tuple/None): response type
                'auth' (list): a list of auth type keys
                'endpoint_path' (str): the endpoint path
                'operation_id' (str): endpoint string identifier
                'http_method' (str): POST/PUT/PATCH/GET etc
                'servers' (list): list of str servers that this endpoint is at
            params_map (dict): see below key value pairs
                'all' (list): list of str endpoint parameter names
                'required' (list): list of required parameter names
                'nullable' (list): list of nullable parameter names
                'enum' (list): list of parameters with enum values
                'validation' (list): list of parameters with validations
            root_map
                'validations' (dict): the dict mapping endpoint parameter tuple
                    paths to their validation dictionaries
                'allowed_values' (dict): the dict mapping endpoint parameter
                    tuple paths to their allowed_values (enum) dictionaries
                'openapi_types' (dict): param_name to openapi type
                'attribute_map' (dict): param_name to camelCase name
                'location_map' (dict): param_name to  'body', 'file', 'form',
                    'header', 'path', 'query'
                collection_format_map (dict): param_name to `csv` etc.
            headers_map (dict): see below key value pairs
                'accept' (list): list of Accept header strings
                'content_type' (list): list of Content-Type header strings
            api_client (ApiClient) api client instance
            callable (function): the function which is invoked when the
                Endpoint is called
        """
        self.settings = settings
        self.params_map = params_map
        self.params_map['all'].extend([
            'async_req',
            '_host_index',
            '_preload_content',
            '_request_timeout',
            '_return_http_data_only',
            '_check_input_type',
            '_check_return_type'
        ])
        self.params_map['nullable'].extend(['_request_timeout'])
        self.validations = root_map['validations']
        self.allowed_values = root_map['allowed_values']
        self.openapi_types = root_map['openapi_types']
        extra_types = {
            'async_req': (bool,),
            '_host_index': (int,),
            '_preload_content': (bool,),
            '_request_timeout': (none_type, int, (int,), [int]),
            '_return_http_data_only': (bool,),
            '_check_input_type': (bool,),
            '_check_return_type': (bool,)
        }
        self.openapi_types.update(extra_types)
        self.attribute_map = root_map['attribute_map']
        self.location_map = root_map['location_map']
        self.collection_format_map = root_map['collection_format_map']
        self.headers_map = headers_map
        self.api_client = api_client
        self.callable = callable

    def __validate_inputs(self, kwargs):
        for param in self.params_map['enum']:
            if param in kwargs:
                check_allowed_values(
                    self.allowed_values,
                    (param,),
                    kwargs[param]
                )

        for param in self.params_map['validation']:
            if param in kwargs:
                check_validations(
                    self.validations,
                    (param,),
                    kwargs[param]
                )

        if kwargs['_check_input_type'] is False:
            return

        for key, value in six.iteritems(kwargs):
            fixed_val = validate_and_convert_types(
                value,
                self.openapi_types[key],
                [key],
                False,
                kwargs['_check_input_type'],
                configuration=self.api_client.configuration
            )
            kwargs[key] = fixed_val

    def __gather_params(self, kwargs):
        params = {
            'body': None,
            'collection_format': {},
            'file': {},
            'form': [],
            'header': {},
            'path': {},
            'query': []
        }

        for param_name, param_value in six.iteritems(kwargs):
            param_location = self.location_map.get(param_name)
            if param_location is None:
                continue
            if param_location:
                if param_location == 'body':
                    params['body'] = param_value
                    continue
                base_name = self.attribute_map[param_name]
                if (param_location == 'form' and
                        self.openapi_types[param_name] == (file_type,)):
                    params['file'][param_name] = [param_value]
                elif (param_location == 'form' and
                        self.openapi_types[param_name] == ([file_type],)):
                    # param_value is already a list
                    params['file'][param_name] = param_value
                elif param_location in {'form', 'query'}:
                    param_value_full = (base_name, param_value)
                    params[param_location].append(param_value_full)
                if param_location not in {'form', 'query'}:
                    params[param_location][base_name] = param_value
                collection_format = self.collection_format_map.get(param_name)
                if collection_format:
                    params['collection_format'][base_name] = collection_format

        return params

    def __call__(self, *args, **kwargs):
        """ This method is invoked when endpoints are called
        Example:
        pet_api = PetApi()
        pet_api.add_pet  # this is an instance of the class Endpoint
        pet_api.add_pet()  # this invokes pet_api.add_pet.__call__()
        which then invokes the callable functions stored in that endpoint at
        pet_api.add_pet.callable or self.callable in this class
        """
        return self.callable(self, *args, **kwargs)

    def call_with_http_info(self, **kwargs):

        try:
            _host = self.settings['servers'][kwargs['_host_index']]
        except IndexError:
            if self.settings['servers']:
                raise ApiValueError(
                    "Invalid host index. Must be 0 <= index < %s" %
                    len(self.settings['servers'])
                )
            _host = None

        for key, value in six.iteritems(kwargs):
            if key not in self.params_map['all']:
                raise ApiTypeError(
                    "Got an unexpected parameter '%s'"
                    " to method `%s`" %
                    (key, self.settings['operation_id'])
                )
            # only throw this nullable ApiValueError if _check_input_type
            # is False, if _check_input_type==True we catch this case
            # in self.__validate_inputs
            if (key not in self.params_map['nullable'] and value is None
                    and kwargs['_check_input_type'] is False):
                raise ApiValueError(
                    "Value may not be None for non-nullable parameter `%s`"
                    " when calling `%s`" %
                    (key, self.settings['operation_id'])
                )

        for key in self.params_map['required']:
            if key not in kwargs.keys():
                raise ApiValueError(
                    "Missing the required parameter `%s` when calling "
                    "`%s`" % (key, self.settings['operation_id'])
                )

        self.__validate_inputs(kwargs)

        params = self.__gather_params(kwargs)

        accept_headers_list = self.headers_map['accept']
        if accept_headers_list:
            params['header']['Accept'] = self.api_client.select_header_accept(
                accept_headers_list)

        content_type_headers_list = self.headers_map['content_type']
        if content_type_headers_list:
            header_list = self.api_client.select_header_content_type(
                content_type_headers_list)
            params['header']['Content-Type'] = header_list

        return self.api_client.call_api(
            self.settings['endpoint_path'], self.settings['http_method'],
            params['path'],
            params['query'],
            params['header'],
            body=params['body'],
            post_params=params['form'],
            files=params['file'],
            response_type=self.settings['response_type'],
            auth_settings=self.settings['auth'],
            async_req=kwargs['async_req'],
            _check_type=kwargs['_check_return_type'],
            _return_http_data_only=kwargs['_return_http_data_only'],
            _preload_content=kwargs['_preload_content'],
            _request_timeout=kwargs['_request_timeout'],
            _host=_host,
            collection_formats=params['collection_format'])
