Пример #1
0
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __passthrough_create(
            self,
            x_account_token,
            data_passthrough_request,
            **kwargs
        ):
            """passthrough_create  # noqa: E501

            Pull data from an endpoint not currently supported by Merge.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.passthrough_create(x_account_token, data_passthrough_request, async_req=True)
            >>> result = thread.get()

            Args:
                x_account_token (str): Token identifying the end user.
                data_passthrough_request (DataPassthroughRequest):

            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/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                RemoteResponse
                    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')
            kwargs['x_account_token'] = \
                x_account_token
            kwargs['data_passthrough_request'] = \
                data_passthrough_request
            return self.call_with_http_info(**kwargs)

        self.passthrough_create = Endpoint(
            settings={
                'response_type': (RemoteResponse,),
                'auth': [
                    'tokenAuth'
                ],
                'endpoint_path': '/passthrough',
                'operation_id': 'passthrough_create',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'x_account_token',
                    'data_passthrough_request',
                ],
                'required': [
                    'x_account_token',
                    'data_passthrough_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'x_account_token':
                        (str,),
                    'data_passthrough_request':
                        (DataPassthroughRequest, DataPassthrough),
                },
                'attribute_map': {
                    'x_account_token': 'X-Account-Token',
                },
                'location_map': {
                    'x_account_token': 'header',
                    'data_passthrough_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json',
                    'application/x-www-form-urlencoded',
                    'multipart/form-data'
                ]
            },
            api_client=api_client,
            callable=__passthrough_create
        )
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __account_token_retrieve(
            self,
            public_token,
            **kwargs
        ):
            """account_token_retrieve  # noqa: E501

            Returns the account token for the end user with the provided public token.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.account_token_retrieve(public_token, async_req=True)
            >>> result = thread.get()

            Args:
                public_token (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/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                AccountToken
                    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')
            kwargs['public_token'] = \
                public_token
            return self.call_with_http_info(**kwargs)

        self.account_token_retrieve = Endpoint(
            settings={
                'response_type': (AccountToken,),
                'auth': [
                    'tokenAuth'
                ],
                'endpoint_path': '/account-token/{public_token}',
                'operation_id': 'account_token_retrieve',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'public_token',
                ],
                'required': [
                    'public_token',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'public_token':
                        (str,),
                },
                'attribute_map': {
                    'public_token': 'public_token',
                },
                'location_map': {
                    'public_token': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__account_token_retrieve
        )
Пример #3
0
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __link_token_create(self, end_user_details_request, **kwargs):
            """link_token_create  # noqa: E501

            Creates a link token to be used when linking a new end user.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.link_token_create(end_user_details_request, async_req=True)
            >>> result = thread.get()

            Args:
                end_user_details_request (EndUserDetailsRequest):

            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/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                LinkToken
                    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')
            kwargs['end_user_details_request'] = \
                end_user_details_request
            return self.call_with_http_info(**kwargs)

        self.link_token_create = Endpoint(
            settings={
                'response_type': (LinkToken, ),
                'auth': ['tokenAuth'],
                'endpoint_path': '/link-token',
                'operation_id': 'link_token_create',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'end_user_details_request',
                ],
                'required': [
                    'end_user_details_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'end_user_details_request':
                    (EndUserDetailsRequest, EndUserDetails),
                },
                'attribute_map': {},
                'location_map': {
                    'end_user_details_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [
                    'application/json', 'application/x-www-form-urlencoded',
                    'multipart/form-data'
                ]
            },
            api_client=api_client,
            callable=__link_token_create)
Пример #4
0
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __departments_list(
            self,
            x_account_token,
            **kwargs
        ):
            """departments_list  # noqa: E501

            Returns a list of `Department` objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.departments_list(x_account_token, async_req=True)
            >>> result = thread.get()

            Args:
                x_account_token (str): Token identifying the end user.

            Keyword Args:
                created_after (datetime): If provided, will only return objects created after this datetime.. [optional]
                created_before (datetime): If provided, will only return objects created before this datetime.. [optional]
                cursor (str): The pagination cursor value.. [optional]
                include_remote_data (bool): Whether to include the original data Merge fetched from the third-party to produce these models.. [optional]
                modified_after (datetime): If provided, will only return objects modified after this datetime.. [optional]
                modified_before (datetime): If provided, will only return objects modified before this datetime.. [optional]
                page_size (int): Number of results to return per page.. [optional]
                remote_id (str, none_type): The API provider's ID for the given object.. [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/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                PaginatedDepartmentList
                    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')
            kwargs['x_account_token'] = \
                x_account_token
            return self.call_with_http_info(**kwargs)

        self.departments_list = Endpoint(
            settings={
                'response_type': (PaginatedDepartmentList,),
                'auth': [
                    'tokenAuth'
                ],
                'endpoint_path': '/departments',
                'operation_id': 'departments_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'x_account_token',
                    'created_after',
                    'created_before',
                    'cursor',
                    'include_remote_data',
                    'modified_after',
                    'modified_before',
                    'page_size',
                    'remote_id',
                ],
                'required': [
                    'x_account_token',
                ],
                'nullable': [
                    'remote_id',
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'x_account_token':
                        (str,),
                    'created_after':
                        (datetime,),
                    'created_before':
                        (datetime,),
                    'cursor':
                        (str,),
                    'include_remote_data':
                        (bool,),
                    'modified_after':
                        (datetime,),
                    'modified_before':
                        (datetime,),
                    'page_size':
                        (int,),
                    'remote_id':
                        (str, none_type,),
                },
                'attribute_map': {
                    'x_account_token': 'X-Account-Token',
                    'created_after': 'created_after',
                    'created_before': 'created_before',
                    'cursor': 'cursor',
                    'include_remote_data': 'include_remote_data',
                    'modified_after': 'modified_after',
                    'modified_before': 'modified_before',
                    'page_size': 'page_size',
                    'remote_id': 'remote_id',
                },
                'location_map': {
                    'x_account_token': 'header',
                    'created_after': 'query',
                    'created_before': 'query',
                    'cursor': 'query',
                    'include_remote_data': 'query',
                    'modified_after': 'query',
                    'modified_before': 'query',
                    'page_size': 'query',
                    'remote_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__departments_list
        )

        def __departments_retrieve(
            self,
            x_account_token,
            id,
            **kwargs
        ):
            """departments_retrieve  # noqa: E501

            Returns a `Department` object with the given `id`.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.departments_retrieve(x_account_token, id, async_req=True)
            >>> result = thread.get()

            Args:
                x_account_token (str): Token identifying the end user.
                id (str):

            Keyword Args:
                include_remote_data (bool): Whether to include the original data Merge fetched from the third-party to produce these models.. [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/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                Department
                    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')
            kwargs['x_account_token'] = \
                x_account_token
            kwargs['id'] = \
                id
            return self.call_with_http_info(**kwargs)

        self.departments_retrieve = Endpoint(
            settings={
                'response_type': (Department,),
                'auth': [
                    'tokenAuth'
                ],
                'endpoint_path': '/departments/{id}',
                'operation_id': 'departments_retrieve',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'x_account_token',
                    'id',
                    'include_remote_data',
                ],
                'required': [
                    'x_account_token',
                    'id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'x_account_token':
                        (str,),
                    'id':
                        (str,),
                    'include_remote_data':
                        (bool,),
                },
                'attribute_map': {
                    'x_account_token': 'X-Account-Token',
                    'id': 'id',
                    'include_remote_data': 'include_remote_data',
                },
                'location_map': {
                    'x_account_token': 'header',
                    'id': 'path',
                    'include_remote_data': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__departments_retrieve
        )
Пример #5
0
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __applications_create(
            self,
            x_account_token,
            remote_user_id,
            **kwargs
        ):
            """applications_create  # noqa: E501

            Creates an `Application` object with the given values.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.applications_create(x_account_token, remote_user_id, async_req=True)
            >>> result = thread.get()

            Args:
                x_account_token (str): Token identifying the end user.
                remote_user_id (str): The ID of the RemoteUser deleting the resource. This can be found in the ID field (not remote_id) in the RemoteUser table.

            Keyword Args:
                run_async (bool): Whether or not third-party updates should be run asynchronously.. [optional]
                application_request (ApplicationRequest): [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/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                Application
                    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')
            kwargs['x_account_token'] = \
                x_account_token
            kwargs['remote_user_id'] = \
                remote_user_id
            return self.call_with_http_info(**kwargs)

        self.applications_create = Endpoint(
            settings={
                'response_type': (Application,),
                'auth': [
                    'tokenAuth'
                ],
                'endpoint_path': '/applications',
                'operation_id': 'applications_create',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'x_account_token',
                    'remote_user_id',
                    'run_async',
                    'application_request',
                ],
                'required': [
                    'x_account_token',
                    'remote_user_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'x_account_token':
                        (str,),
                    'remote_user_id':
                        (str,),
                    'run_async':
                        (bool,),
                    'application_request':
                        (ApplicationRequest,),
                },
                'attribute_map': {
                    'x_account_token': 'X-Account-Token',
                    'remote_user_id': 'remote_user_id',
                    'run_async': 'run_async',
                },
                'location_map': {
                    'x_account_token': 'header',
                    'remote_user_id': 'query',
                    'run_async': 'query',
                    'application_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json',
                    'application/x-www-form-urlencoded',
                    'multipart/form-data'
                ]
            },
            api_client=api_client,
            callable=__applications_create
        )

        def __applications_list(
            self,
            x_account_token,
            **kwargs
        ):
            """applications_list  # noqa: E501

            Returns a list of `Application` objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.applications_list(x_account_token, async_req=True)
            >>> result = thread.get()

            Args:
                x_account_token (str): Token identifying the end user.

            Keyword Args:
                candidate_id (str): If provided, will only return applications for this candidate.. [optional]
                created_after (datetime): If provided, will only return objects created after this datetime.. [optional]
                created_before (datetime): If provided, will only return objects created before this datetime.. [optional]
                credited_to_id (str): If provided, will only return applications credited to this user.. [optional]
                current_stage_id (str): If provided, will only return applications at this interview stage.. [optional]
                cursor (str): The pagination cursor value.. [optional]
                expand (str): Which relations should be returned in expanded form. Multiple relation names should be comma separated without spaces.. [optional]
                include_remote_data (bool): Whether to include the original data Merge fetched from the third-party to produce these models.. [optional]
                job_id (str): If provided, will only return applications for this job.. [optional]
                modified_after (datetime): If provided, will only return objects modified after this datetime.. [optional]
                modified_before (datetime): If provided, will only return objects modified before this datetime.. [optional]
                page_size (int): Number of results to return per page.. [optional]
                reject_reason_id (str): If provided, will only return applications with this reject reason.. [optional]
                remote_id (str, none_type): The API provider's ID for the given object.. [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/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                PaginatedApplicationList
                    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')
            kwargs['x_account_token'] = \
                x_account_token
            return self.call_with_http_info(**kwargs)

        self.applications_list = Endpoint(
            settings={
                'response_type': (PaginatedApplicationList,),
                'auth': [
                    'tokenAuth'
                ],
                'endpoint_path': '/applications',
                'operation_id': 'applications_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'x_account_token',
                    'candidate_id',
                    'created_after',
                    'created_before',
                    'credited_to_id',
                    'current_stage_id',
                    'cursor',
                    'expand',
                    'include_remote_data',
                    'job_id',
                    'modified_after',
                    'modified_before',
                    'page_size',
                    'reject_reason_id',
                    'remote_id',
                ],
                'required': [
                    'x_account_token',
                ],
                'nullable': [
                    'remote_id',
                ],
                'enum': [
                    'expand',
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                    ('expand',): {

                        "CANDIDATE": "candidate",
                        "CANDIDATE,CREDITED_TO": "candidate,credited_to",
                        "CANDIDATE,CREDITED_TO,CURRENT_STAGE": "candidate,credited_to,current_stage",
                        "CANDIDATE,CREDITED_TO,CURRENT_STAGE,REJECT_REASON": "candidate,credited_to,current_stage,reject_reason",
                        "CANDIDATE,CREDITED_TO,REJECT_REASON": "candidate,credited_to,reject_reason",
                        "CANDIDATE,CURRENT_STAGE": "candidate,current_stage",
                        "CANDIDATE,CURRENT_STAGE,REJECT_REASON": "candidate,current_stage,reject_reason",
                        "CANDIDATE,JOB": "candidate,job",
                        "CANDIDATE,JOB,CREDITED_TO": "candidate,job,credited_to",
                        "CANDIDATE,JOB,CREDITED_TO,CURRENT_STAGE": "candidate,job,credited_to,current_stage",
                        "CANDIDATE,JOB,CREDITED_TO,CURRENT_STAGE,REJECT_REASON": "candidate,job,credited_to,current_stage,reject_reason",
                        "CANDIDATE,JOB,CREDITED_TO,REJECT_REASON": "candidate,job,credited_to,reject_reason",
                        "CANDIDATE,JOB,CURRENT_STAGE": "candidate,job,current_stage",
                        "CANDIDATE,JOB,CURRENT_STAGE,REJECT_REASON": "candidate,job,current_stage,reject_reason",
                        "CANDIDATE,JOB,REJECT_REASON": "candidate,job,reject_reason",
                        "CANDIDATE,REJECT_REASON": "candidate,reject_reason",
                        "CREDITED_TO": "credited_to",
                        "CREDITED_TO,CURRENT_STAGE": "credited_to,current_stage",
                        "CREDITED_TO,CURRENT_STAGE,REJECT_REASON": "credited_to,current_stage,reject_reason",
                        "CREDITED_TO,REJECT_REASON": "credited_to,reject_reason",
                        "CURRENT_STAGE": "current_stage",
                        "CURRENT_STAGE,REJECT_REASON": "current_stage,reject_reason",
                        "JOB": "job",
                        "JOB,CREDITED_TO": "job,credited_to",
                        "JOB,CREDITED_TO,CURRENT_STAGE": "job,credited_to,current_stage",
                        "JOB,CREDITED_TO,CURRENT_STAGE,REJECT_REASON": "job,credited_to,current_stage,reject_reason",
                        "JOB,CREDITED_TO,REJECT_REASON": "job,credited_to,reject_reason",
                        "JOB,CURRENT_STAGE": "job,current_stage",
                        "JOB,CURRENT_STAGE,REJECT_REASON": "job,current_stage,reject_reason",
                        "JOB,REJECT_REASON": "job,reject_reason",
                        "REJECT_REASON": "reject_reason"
                    },
                },
                'openapi_types': {
                    'x_account_token':
                        (str,),
                    'candidate_id':
                        (str,),
                    'created_after':
                        (datetime,),
                    'created_before':
                        (datetime,),
                    'credited_to_id':
                        (str,),
                    'current_stage_id':
                        (str,),
                    'cursor':
                        (str,),
                    'expand':
                        (str,),
                    'include_remote_data':
                        (bool,),
                    'job_id':
                        (str,),
                    'modified_after':
                        (datetime,),
                    'modified_before':
                        (datetime,),
                    'page_size':
                        (int,),
                    'reject_reason_id':
                        (str,),
                    'remote_id':
                        (str, none_type,),
                },
                'attribute_map': {
                    'x_account_token': 'X-Account-Token',
                    'candidate_id': 'candidate_id',
                    'created_after': 'created_after',
                    'created_before': 'created_before',
                    'credited_to_id': 'credited_to_id',
                    'current_stage_id': 'current_stage_id',
                    'cursor': 'cursor',
                    'expand': 'expand',
                    'include_remote_data': 'include_remote_data',
                    'job_id': 'job_id',
                    'modified_after': 'modified_after',
                    'modified_before': 'modified_before',
                    'page_size': 'page_size',
                    'reject_reason_id': 'reject_reason_id',
                    'remote_id': 'remote_id',
                },
                'location_map': {
                    'x_account_token': 'header',
                    'candidate_id': 'query',
                    'created_after': 'query',
                    'created_before': 'query',
                    'credited_to_id': 'query',
                    'current_stage_id': 'query',
                    'cursor': 'query',
                    'expand': 'query',
                    'include_remote_data': 'query',
                    'job_id': 'query',
                    'modified_after': 'query',
                    'modified_before': 'query',
                    'page_size': 'query',
                    'reject_reason_id': 'query',
                    'remote_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__applications_list
        )

        def __applications_partial_update(
            self,
            x_account_token,
            id,
            remote_user_id,
            **kwargs
        ):
            """applications_partial_update  # noqa: E501

            Updates an `Application` object with the given `id`.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.applications_partial_update(x_account_token, id, remote_user_id, async_req=True)
            >>> result = thread.get()

            Args:
                x_account_token (str): Token identifying the end user.
                id (str):
                remote_user_id (str): The ID of the RemoteUser deleting the resource. This can be found in the ID field (not remote_id) in the RemoteUser table.

            Keyword Args:
                run_async (bool): Whether or not third-party updates should be run asynchronously.. [optional]
                patched_application_request (PatchedApplicationRequest): [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/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                Application
                    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')
            kwargs['x_account_token'] = \
                x_account_token
            kwargs['id'] = \
                id
            kwargs['remote_user_id'] = \
                remote_user_id
            return self.call_with_http_info(**kwargs)

        self.applications_partial_update = Endpoint(
            settings={
                'response_type': (Application,),
                'auth': [
                    'tokenAuth'
                ],
                'endpoint_path': '/applications/{id}',
                'operation_id': 'applications_partial_update',
                'http_method': 'PATCH',
                'servers': None,
            },
            params_map={
                'all': [
                    'x_account_token',
                    'id',
                    'remote_user_id',
                    'run_async',
                    'patched_application_request',
                ],
                'required': [
                    'x_account_token',
                    'id',
                    'remote_user_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'x_account_token':
                        (str,),
                    'id':
                        (str,),
                    'remote_user_id':
                        (str,),
                    'run_async':
                        (bool,),
                    'patched_application_request':
                        (PatchedApplicationRequest,),
                },
                'attribute_map': {
                    'x_account_token': 'X-Account-Token',
                    'id': 'id',
                    'remote_user_id': 'remote_user_id',
                    'run_async': 'run_async',
                },
                'location_map': {
                    'x_account_token': 'header',
                    'id': 'path',
                    'remote_user_id': 'query',
                    'run_async': 'query',
                    'patched_application_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json',
                    'application/x-www-form-urlencoded',
                    'multipart/form-data'
                ]
            },
            api_client=api_client,
            callable=__applications_partial_update
        )

        def __applications_retrieve(
            self,
            x_account_token,
            id,
            **kwargs
        ):
            """applications_retrieve  # noqa: E501

            Returns an `Application` object with the given `id`.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.applications_retrieve(x_account_token, id, async_req=True)
            >>> result = thread.get()

            Args:
                x_account_token (str): Token identifying the end user.
                id (str):

            Keyword Args:
                expand (str): Which relations should be returned in expanded form. Multiple relation names should be comma separated without spaces.. [optional]
                include_remote_data (bool): Whether to include the original data Merge fetched from the third-party to produce these models.. [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/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                Application
                    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')
            kwargs['x_account_token'] = \
                x_account_token
            kwargs['id'] = \
                id
            return self.call_with_http_info(**kwargs)

        self.applications_retrieve = Endpoint(
            settings={
                'response_type': (Application,),
                'auth': [
                    'tokenAuth'
                ],
                'endpoint_path': '/applications/{id}',
                'operation_id': 'applications_retrieve',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'x_account_token',
                    'id',
                    'expand',
                    'include_remote_data',
                ],
                'required': [
                    'x_account_token',
                    'id',
                ],
                'nullable': [
                ],
                'enum': [
                    'expand',
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                    ('expand',): {

                        "CANDIDATE": "candidate",
                        "CANDIDATE,CREDITED_TO": "candidate,credited_to",
                        "CANDIDATE,CREDITED_TO,CURRENT_STAGE": "candidate,credited_to,current_stage",
                        "CANDIDATE,CREDITED_TO,CURRENT_STAGE,REJECT_REASON": "candidate,credited_to,current_stage,reject_reason",
                        "CANDIDATE,CREDITED_TO,REJECT_REASON": "candidate,credited_to,reject_reason",
                        "CANDIDATE,CURRENT_STAGE": "candidate,current_stage",
                        "CANDIDATE,CURRENT_STAGE,REJECT_REASON": "candidate,current_stage,reject_reason",
                        "CANDIDATE,JOB": "candidate,job",
                        "CANDIDATE,JOB,CREDITED_TO": "candidate,job,credited_to",
                        "CANDIDATE,JOB,CREDITED_TO,CURRENT_STAGE": "candidate,job,credited_to,current_stage",
                        "CANDIDATE,JOB,CREDITED_TO,CURRENT_STAGE,REJECT_REASON": "candidate,job,credited_to,current_stage,reject_reason",
                        "CANDIDATE,JOB,CREDITED_TO,REJECT_REASON": "candidate,job,credited_to,reject_reason",
                        "CANDIDATE,JOB,CURRENT_STAGE": "candidate,job,current_stage",
                        "CANDIDATE,JOB,CURRENT_STAGE,REJECT_REASON": "candidate,job,current_stage,reject_reason",
                        "CANDIDATE,JOB,REJECT_REASON": "candidate,job,reject_reason",
                        "CANDIDATE,REJECT_REASON": "candidate,reject_reason",
                        "CREDITED_TO": "credited_to",
                        "CREDITED_TO,CURRENT_STAGE": "credited_to,current_stage",
                        "CREDITED_TO,CURRENT_STAGE,REJECT_REASON": "credited_to,current_stage,reject_reason",
                        "CREDITED_TO,REJECT_REASON": "credited_to,reject_reason",
                        "CURRENT_STAGE": "current_stage",
                        "CURRENT_STAGE,REJECT_REASON": "current_stage,reject_reason",
                        "JOB": "job",
                        "JOB,CREDITED_TO": "job,credited_to",
                        "JOB,CREDITED_TO,CURRENT_STAGE": "job,credited_to,current_stage",
                        "JOB,CREDITED_TO,CURRENT_STAGE,REJECT_REASON": "job,credited_to,current_stage,reject_reason",
                        "JOB,CREDITED_TO,REJECT_REASON": "job,credited_to,reject_reason",
                        "JOB,CURRENT_STAGE": "job,current_stage",
                        "JOB,CURRENT_STAGE,REJECT_REASON": "job,current_stage,reject_reason",
                        "JOB,REJECT_REASON": "job,reject_reason",
                        "REJECT_REASON": "reject_reason"
                    },
                },
                'openapi_types': {
                    'x_account_token':
                        (str,),
                    'id':
                        (str,),
                    'expand':
                        (str,),
                    'include_remote_data':
                        (bool,),
                },
                'attribute_map': {
                    'x_account_token': 'X-Account-Token',
                    'id': 'id',
                    'expand': 'expand',
                    'include_remote_data': 'include_remote_data',
                },
                'location_map': {
                    'x_account_token': 'header',
                    'id': 'path',
                    'expand': 'query',
                    'include_remote_data': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__applications_retrieve
        )