# coding: utf-8

"""
    Seeq REST API

    No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)  # noqa: E501

    OpenAPI spec version: 66.106.1-v202602230103-CD
    
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""

from __future__ import absolute_import

import sys
import os
import re

from deprecated import deprecated
# python 2 and python 3 compatibility library
from six import iteritems

from ..configuration import Configuration
from ..api_client import ApiClient
from ..models import *

class ModelsApi(object):
    """
    NOTE: This class is auto generated by the swagger code generator program.
    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    """

    def __init__(self, api_client=None):
        config = Configuration()
        if api_client:
            self.api_client = api_client
        else:
            if not config.api_client:
                config.api_client = ApiClient()
            self.api_client = config.api_client

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def apply_model(self, **kwargs):
        """
        Apply a model once by providing inputs to the model's features. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.apply_model(body=body_value, model_id=model_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelInitialApplicationInputV1 body: (required)
        :param str model_id: (required)
        :return: InstanceOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.apply_model_with_http_info(**kwargs)
        else:
            (data) = self.apply_model_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def apply_model_with_http_info(self, **kwargs):
        """
        Apply a model once by providing inputs to the model's features. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.apply_model_with_http_info(body=body_value, model_id=model_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelInitialApplicationInputV1 body: (required)
        :param str model_id: (required)
        :return: InstanceOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputV1
        """

        all_params = ['body', 'model_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method apply_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `apply_model`")
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `apply_model`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['modelId'] = params['model_id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/{modelId}/instances', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'InstanceOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def apply_model_to_table(self, **kwargs):
        """
        Apply a model to a table definition and recompute the newly-added columns. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.apply_model_to_table(body=body_value, model_id=model_id_value, table_definition_id=table_definition_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param TableModelApplicationInputV1 body: (required)
        :param str model_id: (required)
        :param str table_definition_id: (required)
        :return: ModelTableApplicationOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelTableApplicationOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.apply_model_to_table_with_http_info(**kwargs)
        else:
            (data) = self.apply_model_to_table_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def apply_model_to_table_with_http_info(self, **kwargs):
        """
        Apply a model to a table definition and recompute the newly-added columns. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.apply_model_to_table_with_http_info(body=body_value, model_id=model_id_value, table_definition_id=table_definition_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param TableModelApplicationInputV1 body: (required)
        :param str model_id: (required)
        :param str table_definition_id: (required)
        :return: ModelTableApplicationOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelTableApplicationOutputV1
        """

        all_params = ['body', 'model_id', 'table_definition_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method apply_model_to_table" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `apply_model_to_table`")
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `apply_model_to_table`")
        # verify the required parameter 'table_definition_id' is set
        if ('table_definition_id' not in params) or (params['table_definition_id'] is None):
            raise ValueError("Missing the required parameter `table_definition_id` when calling `apply_model_to_table`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['modelId'] = params['model_id']
        if 'table_definition_id' in params:
            path_params['tableDefinitionId'] = params['table_definition_id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/{modelId}/table-application/{tableDefinitionId}', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ModelTableApplicationOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def archive_model(self, **kwargs):
        """
        Archive a model by its ID. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.archive_model(id=id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str id: ID of the model to archive (required)
        :return: ArchiveOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ArchiveOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.archive_model_with_http_info(**kwargs)
        else:
            (data) = self.archive_model_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def archive_model_with_http_info(self, **kwargs):
        """
        Archive a model by its ID. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.archive_model_with_http_info(id=id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str id: ID of the model to archive (required)
        :return: ArchiveOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ArchiveOutputV1
        """

        all_params = ['id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method archive_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'id' is set
        if ('id' not in params) or (params['id'] is None):
            raise ValueError("Missing the required parameter `id` when calling `archive_model`")


        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/{id}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ArchiveOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def create_model(self, **kwargs):
        """
        Create a new model. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_model(body=body_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelV1 body: (required)
        :return: ModelV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.create_model_with_http_info(**kwargs)
        else:
            (data) = self.create_model_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def create_model_with_http_info(self, **kwargs):
        """
        Create a new model. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_model_with_http_info(body=body_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelV1 body: (required)
        :return: ModelV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelV1
        """

        all_params = ['body']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `create_model`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ModelV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def create_model_from_items(self, **kwargs):
        """
        Create a new model from reference items. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_model_from_items(body=body_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelFromIdsInputV1 body: (required)
        :return: ModelV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.create_model_from_items_with_http_info(**kwargs)
        else:
            (data) = self.create_model_from_items_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def create_model_from_items_with_http_info(self, **kwargs):
        """
        Create a new model from reference items. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_model_from_items_with_http_info(body=body_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelFromIdsInputV1 body: (required)
        :return: ModelV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelV1
        """

        all_params = ['body']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_model_from_items" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `create_model_from_items`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/from-items', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ModelV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def create_model_from_table_column_definitions(self, **kwargs):
        """
        Create a new model from reference column definitions. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_model_from_table_column_definitions(body=body_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelFromIdsInputV1 body: (required)
        :return: ModelV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.create_model_from_table_column_definitions_with_http_info(**kwargs)
        else:
            (data) = self.create_model_from_table_column_definitions_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def create_model_from_table_column_definitions_with_http_info(self, **kwargs):
        """
        Create a new model from reference column definitions. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_model_from_table_column_definitions_with_http_info(body=body_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelFromIdsInputV1 body: (required)
        :return: ModelV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelV1
        """

        all_params = ['body']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_model_from_table_column_definitions" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `create_model_from_table_column_definitions`")


        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/from-table-column-definitions', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ModelV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def edit_model(self, **kwargs):
        """
        Edit a model by ID. The full model must be provided. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.edit_model(body=body_value, model_id=model_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelV1 body: (required)
        :param str model_id: (required)
        :return: ModelOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.edit_model_with_http_info(**kwargs)
        else:
            (data) = self.edit_model_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def edit_model_with_http_info(self, **kwargs):
        """
        Edit a model by ID. The full model must be provided. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.edit_model_with_http_info(body=body_value, model_id=model_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelV1 body: (required)
        :param str model_id: (required)
        :return: ModelOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelOutputV1
        """

        all_params = ['body', 'model_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method edit_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `edit_model`")
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `edit_model`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['modelId'] = params['model_id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/{modelId}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ModelOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def generate_column_model(self, **kwargs):
        """
        Generates a list of independent and dependent column definitions from a list of items. The independent column definitions do not rely on other columns, while the dependent column definitions do. This can be used to create a model table from calculations. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.generate_column_model(body=body_value, scoped_to=scoped_to_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ColumnModelInputV1 body: (required)
        :param str scoped_to: The ID of the Workbook that the formula creator column rules will be scoped to (required)
        :return: ColumnModelOutput
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ColumnModelOutput
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.generate_column_model_with_http_info(**kwargs)
        else:
            (data) = self.generate_column_model_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def generate_column_model_with_http_info(self, **kwargs):
        """
        Generates a list of independent and dependent column definitions from a list of items. The independent column definitions do not rely on other columns, while the dependent column definitions do. This can be used to create a model table from calculations. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.generate_column_model_with_http_info(body=body_value, scoped_to=scoped_to_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ColumnModelInputV1 body: (required)
        :param str scoped_to: The ID of the Workbook that the formula creator column rules will be scoped to (required)
        :return: ColumnModelOutput
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ColumnModelOutput
        """

        all_params = ['body', 'scoped_to']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method generate_column_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `generate_column_model`")
        # verify the required parameter 'scoped_to' is set
        if ('scoped_to' not in params) or (params['scoped_to'] is None):
            raise ValueError("Missing the required parameter `scoped_to` when calling `generate_column_model`")


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'scoped_to' in params:
            query_params.append(('scopedTo', params['scoped_to']))

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/modelData', 'POST',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ColumnModelOutput'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_instance(self, **kwargs):
        """
        Fetch model instance by ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_instance(instance_id=instance_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str instance_id: (required)
        :return: InstanceOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.get_instance_with_http_info(**kwargs)
        else:
            (data) = self.get_instance_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_instance_with_http_info(self, **kwargs):
        """
        Fetch model instance by ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_instance_with_http_info(instance_id=instance_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str instance_id: (required)
        :return: InstanceOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputV1
        """

        all_params = ['instance_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_instance" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'instance_id' is set
        if ('instance_id' not in params) or (params['instance_id'] is None):
            raise ValueError("Missing the required parameter `instance_id` when calling `get_instance`")


        collection_formats = {}

        path_params = {}
        if 'instance_id' in params:
            path_params['instanceId'] = params['instance_id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/instances/{instanceId}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'InstanceOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_instances_for_model(self, **kwargs):
        """
        Fetch model instances for model ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_instances_for_model(model_id=model_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str model_id: (required)
        :param int offset: The pagination offset, the index of the first model instance that will be returned in this page of results
        :param int limit: The pagination limit, the total number of model instances that will be returned in this page of results
        :return: InstanceOutputPaginatedListV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputPaginatedListV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.get_instances_for_model_with_http_info(**kwargs)
        else:
            (data) = self.get_instances_for_model_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_instances_for_model_with_http_info(self, **kwargs):
        """
        Fetch model instances for model ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_instances_for_model_with_http_info(model_id=model_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str model_id: (required)
        :param int offset: The pagination offset, the index of the first model instance that will be returned in this page of results
        :param int limit: The pagination limit, the total number of model instances that will be returned in this page of results
        :return: InstanceOutputPaginatedListV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputPaginatedListV1
        """

        all_params = ['model_id', 'offset', 'limit']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_instances_for_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `get_instances_for_model`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['modelId'] = params['model_id']

        query_params = []
        if 'offset' in params:
            query_params.append(('offset', params['offset']))
        if 'limit' in params:
            query_params.append(('limit', params['limit']))

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/{modelId}/instances', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'InstanceOutputPaginatedListV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_instances_for_table(self, **kwargs):
        """
        Fetch model instances for table definition ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_instances_for_table(table_definition_id=table_definition_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str table_definition_id: (required)
        :param int offset: The pagination offset, the index of the first model instance that will be returned in this page of results
        :param int limit: The pagination limit, the total number of model instances that will be returned in this page of results
        :return: InstanceOutputPaginatedListV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputPaginatedListV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.get_instances_for_table_with_http_info(**kwargs)
        else:
            (data) = self.get_instances_for_table_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_instances_for_table_with_http_info(self, **kwargs):
        """
        Fetch model instances for table definition ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_instances_for_table_with_http_info(table_definition_id=table_definition_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str table_definition_id: (required)
        :param int offset: The pagination offset, the index of the first model instance that will be returned in this page of results
        :param int limit: The pagination limit, the total number of model instances that will be returned in this page of results
        :return: InstanceOutputPaginatedListV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputPaginatedListV1
        """

        all_params = ['table_definition_id', 'offset', 'limit']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_instances_for_table" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'table_definition_id' is set
        if ('table_definition_id' not in params) or (params['table_definition_id'] is None):
            raise ValueError("Missing the required parameter `table_definition_id` when calling `get_instances_for_table`")


        collection_formats = {}

        path_params = {}
        if 'table_definition_id' in params:
            path_params['tableDefinitionId'] = params['table_definition_id']

        query_params = []
        if 'offset' in params:
            query_params.append(('offset', params['offset']))
        if 'limit' in params:
            query_params.append(('limit', params['limit']))

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/instances/table/{tableDefinitionId}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'InstanceOutputPaginatedListV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_model(self, **kwargs):
        """
        Fetch a model by ID. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_model(model_id=model_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str model_id: (required)
        :return: ModelOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.get_model_with_http_info(**kwargs)
        else:
            (data) = self.get_model_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_model_with_http_info(self, **kwargs):
        """
        Fetch a model by ID. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_model_with_http_info(model_id=model_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str model_id: (required)
        :return: ModelOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelOutputV1
        """

        all_params = ['model_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `get_model`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['modelId'] = params['model_id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/{modelId}', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ModelOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_models(self, **kwargs):
        """
        Get a list of models. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_models(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int offset: The pagination offset, the index of the first item that will be returned in this page of results
        :param int limit: The pagination limit, the total number of models that will be returned in this page of results
        :return: ModelOutputListV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelOutputListV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.get_models_with_http_info(**kwargs)
        else:
            (data) = self.get_models_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_models_with_http_info(self, **kwargs):
        """
        Get a list of models. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_models_with_http_info(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int offset: The pagination offset, the index of the first item that will be returned in this page of results
        :param int limit: The pagination limit, the total number of models that will be returned in this page of results
        :return: ModelOutputListV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelOutputListV1
        """

        all_params = ['offset', 'limit']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_models" % key
                )
            params[key] = val
        del params['kwargs']


        collection_formats = {}

        path_params = {}

        query_params = []
        if 'offset' in params:
            query_params.append(('offset', params['offset']))
        if 'limit' in params:
            query_params.append(('limit', params['limit']))

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ModelOutputListV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_table_definition_model_applications(self, **kwargs):
        """
        Get the models applied to a given table definition. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_table_definition_model_applications(id=id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str id: The ID of the table definition (required)
        :return: ModelTableApplicationsOutputListV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelTableApplicationsOutputListV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.get_table_definition_model_applications_with_http_info(**kwargs)
        else:
            (data) = self.get_table_definition_model_applications_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def get_table_definition_model_applications_with_http_info(self, **kwargs):
        """
        Get the models applied to a given table definition. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_table_definition_model_applications_with_http_info(id=id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str id: The ID of the table definition (required)
        :return: ModelTableApplicationsOutputListV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelTableApplicationsOutputListV1
        """

        all_params = ['id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_table_definition_model_applications" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'id' is set
        if ('id' not in params) or (params['id'] is None):
            raise ValueError("Missing the required parameter `id` when calling `get_table_definition_model_applications`")


        collection_formats = {}

        path_params = {}
        if 'id' in params:
            path_params['id'] = params['id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/{id}/model-applications', 'GET',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ModelTableApplicationsOutputListV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def reapply_model(self, **kwargs):
        """
        Reapply a model once by providing inputs to the model's features. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.reapply_model(body=body_value, model_id=model_id_value, instance_id=instance_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelReapplicationInputV1 body: (required)
        :param str model_id: (required)
        :param str instance_id: (required)
        :return: InstanceOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.reapply_model_with_http_info(**kwargs)
        else:
            (data) = self.reapply_model_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def reapply_model_with_http_info(self, **kwargs):
        """
        Reapply a model once by providing inputs to the model's features. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.reapply_model_with_http_info(body=body_value, model_id=model_id_value, instance_id=instance_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ModelReapplicationInputV1 body: (required)
        :param str model_id: (required)
        :param str instance_id: (required)
        :return: InstanceOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceOutputV1
        """

        all_params = ['body', 'model_id', 'instance_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reapply_model" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `reapply_model`")
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `reapply_model`")
        # verify the required parameter 'instance_id' is set
        if ('instance_id' not in params) or (params['instance_id'] is None):
            raise ValueError("Missing the required parameter `instance_id` when calling `reapply_model`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['modelId'] = params['model_id']
        if 'instance_id' in params:
            path_params['instanceId'] = params['instance_id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/{modelId}/instances/{instanceId}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'InstanceOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def reapply_model_to_table(self, **kwargs):
        """
        Reapply a model to a table definition and recompute the results using the updated inputs. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.reapply_model_to_table(body=body_value, model_id=model_id_value, table_definition_id=table_definition_id_value, application_id=application_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param TableModelApplicationInputV1 body: (required)
        :param str model_id: (required)
        :param str table_definition_id: (required)
        :param str application_id: (required)
        :return: ModelTableApplicationOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelTableApplicationOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.reapply_model_to_table_with_http_info(**kwargs)
        else:
            (data) = self.reapply_model_to_table_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def reapply_model_to_table_with_http_info(self, **kwargs):
        """
        Reapply a model to a table definition and recompute the results using the updated inputs. This endpoint is experimental and may change in future releases.
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.reapply_model_to_table_with_http_info(body=body_value, model_id=model_id_value, table_definition_id=table_definition_id_value, application_id=application_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param TableModelApplicationInputV1 body: (required)
        :param str model_id: (required)
        :param str table_definition_id: (required)
        :param str application_id: (required)
        :return: ModelTableApplicationOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ModelTableApplicationOutputV1
        """

        all_params = ['body', 'model_id', 'table_definition_id', 'application_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method reapply_model_to_table" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'body' is set
        if ('body' not in params) or (params['body'] is None):
            raise ValueError("Missing the required parameter `body` when calling `reapply_model_to_table`")
        # verify the required parameter 'model_id' is set
        if ('model_id' not in params) or (params['model_id'] is None):
            raise ValueError("Missing the required parameter `model_id` when calling `reapply_model_to_table`")
        # verify the required parameter 'table_definition_id' is set
        if ('table_definition_id' not in params) or (params['table_definition_id'] is None):
            raise ValueError("Missing the required parameter `table_definition_id` when calling `reapply_model_to_table`")
        # verify the required parameter 'application_id' is set
        if ('application_id' not in params) or (params['application_id'] is None):
            raise ValueError("Missing the required parameter `application_id` when calling `reapply_model_to_table`")


        collection_formats = {}

        path_params = {}
        if 'model_id' in params:
            path_params['modelId'] = params['model_id']
        if 'table_definition_id' in params:
            path_params['tableDefinitionId'] = params['table_definition_id']
        if 'application_id' in params:
            path_params['applicationId'] = params['application_id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/{modelId}/table-application/{tableDefinitionId}/{applicationId}', 'PUT',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'ModelTableApplicationOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def retire_application(self, **kwargs):
        """
        Retire a model table application by ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.retire_application(application_id=application_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str application_id: (required)
        :return: TableApplicationRetiredOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: TableApplicationRetiredOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.retire_application_with_http_info(**kwargs)
        else:
            (data) = self.retire_application_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def retire_application_with_http_info(self, **kwargs):
        """
        Retire a model table application by ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.retire_application_with_http_info(application_id=application_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str application_id: (required)
        :return: TableApplicationRetiredOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: TableApplicationRetiredOutputV1
        """

        all_params = ['application_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method retire_application" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'application_id' is set
        if ('application_id' not in params) or (params['application_id'] is None):
            raise ValueError("Missing the required parameter `application_id` when calling `retire_application`")


        collection_formats = {}

        path_params = {}
        if 'application_id' in params:
            path_params['applicationId'] = params['application_id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/applications/{applicationId}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'TableApplicationRetiredOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def retire_instance(self, **kwargs):
        """
        Retire a model instance by ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.retire_instance(instance_id=instance_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str instance_id: (required)
        :return: InstanceRetiredOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceRetiredOutputV1
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('callback'):
            return self.retire_instance_with_http_info(**kwargs)
        else:
            (data) = self.retire_instance_with_http_info(**kwargs)
            return data

    @deprecated(reason="This API is experimental and may change or be removed in future releases without prior notice.")
    def retire_instance_with_http_info(self, **kwargs):
        """
        Retire a model instance by ID
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.retire_instance_with_http_info(instance_id=instance_id_value, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str instance_id: (required)
        :return: InstanceRetiredOutputV1
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InstanceRetiredOutputV1
        """

        all_params = ['instance_id']
        all_params.append('callback')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')
        all_params.append('_response_type')
        all_params.append('_custom_headers')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method retire_instance" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'instance_id' is set
        if ('instance_id' not in params) or (params['instance_id'] is None):
            raise ValueError("Missing the required parameter `instance_id` when calling `retire_instance`")


        collection_formats = {}

        path_params = {}
        if 'instance_id' in params:
            path_params['instanceId'] = params['instance_id']

        query_params = []

        header_params = {}

        for key, value in params.get('_custom_headers', {}).items():
            header_params[key] = value


        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/vnd.seeq.v1+json'])

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/vnd.seeq.v1+json', ])

        # Authentication setting
        auth_settings = ['api_key']

        return self.api_client.call_api('/models/instances/{instanceId}', 'DELETE',
                                        path_params,
                                        query_params,
                                        header_params,
                                        body=body_params,
                                        post_params=form_params,
                                        files=local_var_files,
                                        response_type=params.get('_response_type', 'InstanceRetiredOutputV1'),
                                        auth_settings=auth_settings,
                                        callback=params.get('callback'),
                                        _return_http_data_only=params.get('_return_http_data_only'),
                                        _preload_content=params.get('_preload_content', True),
                                        _request_timeout=params.get('_request_timeout'),
                                        collection_formats=collection_formats)
