"""
    server

    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)  # noqa: E501

    The version of the OpenAPI document: 0.0.73
    Generated by: https://openapi-generator.tech
"""


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

from openapi_client.api_client import ApiClient, Endpoint as _Endpoint
from openapi_client.model_utils import (  # noqa: F401
    check_allowed_values,
    check_validations,
    date,
    datetime,
    file_type,
    none_type,
    validate_and_convert_types
)
from openapi_client.model.activation_params import ActivationParams
from openapi_client.model.add_custom_loss_params import AddCustomLossParams
from openapi_client.model.add_custom_loss_response import AddCustomLossResponse
from openapi_client.model.add_dashboard_params import AddDashboardParams
from openapi_client.model.add_dataset_response import AddDatasetResponse
from openapi_client.model.add_export_model_job_params import AddExportModelJobParams
from openapi_client.model.add_job_params import AddJobParams
from openapi_client.model.add_secret_manager_params import AddSecretManagerParams
from openapi_client.model.add_secret_manager_response import AddSecretManagerResponse
from openapi_client.model.custom_loss_list_response import CustomLossListResponse
from openapi_client.model.dataset_parse_request_params import DatasetParseRequestParams
from openapi_client.model.delete_visualizations_params import DeleteVisualizationsParams
from openapi_client.model.external_import_model_storage import ExternalImportModelStorage
from openapi_client.model.external_import_model_storage_response import ExternalImportModelStorageResponse
from openapi_client.model.get_branch_versions_params import GetBranchVersionsParams
from openapi_client.model.get_branch_versions_response import GetBranchVersionsResponse
from openapi_client.model.get_bucket_list_params import GetBucketListParams
from openapi_client.model.get_bucket_list_response import GetBucketListResponse
from openapi_client.model.get_current_project_version_params import GetCurrentProjectVersionParams
from openapi_client.model.get_current_project_version_response import GetCurrentProjectVersionResponse
from openapi_client.model.get_custom_loss_version_params import GetCustomLossVersionParams
from openapi_client.model.get_custom_loss_version_response import GetCustomLossVersionResponse
from openapi_client.model.get_dashboards_response import GetDashboardsResponse
from openapi_client.model.get_dataset_version_params import GetDatasetVersionParams
from openapi_client.model.get_dataset_version_response import GetDatasetVersionResponse
from openapi_client.model.get_datasets_response import GetDatasetsResponse
from openapi_client.model.get_deleted_visualizations_params import GetDeletedVisualizationsParams
from openapi_client.model.get_deleted_visualizations_response import GetDeletedVisualizationsResponse
from openapi_client.model.get_demos_response import GetDemosResponse
from openapi_client.model.get_exported_model_jobs_params import GetExportedModelJobsParams
from openapi_client.model.get_exported_model_jobs_response import GetExportedModelJobsResponse
from openapi_client.model.get_jobs_params import GetJobsParams
from openapi_client.model.get_jobs_response import GetJobsResponse
from openapi_client.model.get_kibana_dashboards_response import GetKibanaDashboardsResponse
from openapi_client.model.get_latest_custom_loss_version_params import GetLatestCustomLossVersionParams
from openapi_client.model.get_latest_custom_loss_version_response import GetLatestCustomLossVersionResponse
from openapi_client.model.get_latest_dataset_version_params import GetLatestDatasetVersionParams
from openapi_client.model.get_latest_dataset_version_response import GetLatestDatasetVersionResponse
from openapi_client.model.get_model_jobs_params import GetModelJobsParams
from openapi_client.model.get_model_jobs_response import GetModelJobsResponse
from openapi_client.model.get_model_visualizations_params import GetModelVisualizationsParams
from openapi_client.model.get_model_visualizations_response import GetModelVisualizationsResponse
from openapi_client.model.get_notifications_response import GetNotificationsResponse
from openapi_client.model.get_organization_jobs_params import GetOrganizationJobsParams
from openapi_client.model.get_project_slim_versions_response import GetProjectSlimVersionsResponse
from openapi_client.model.get_project_versions_params import GetProjectVersionsParams
from openapi_client.model.get_project_versions_response import GetProjectVersionsResponse
from openapi_client.model.get_projects_response import GetProjectsResponse
from openapi_client.model.get_secret_manager_list_response import GetSecretManagerListResponse
from openapi_client.model.get_stored_exported_model_resource_url_params import GetStoredExportedModelResourceUrlParams
from openapi_client.model.get_stored_exported_model_resource_url_response import GetStoredExportedModelResourceUrlResponse
from openapi_client.model.get_training_job_params import GetTrainingJobParams
from openapi_client.model.get_upload_signed_url_params import GetUploadSignedUrlParams
from openapi_client.model.get_visualization_params import GetVisualizationParams
from openapi_client.model.import_demo_project_params import ImportDemoProjectParams
from openapi_client.model.import_demo_project_response import ImportDemoProjectResponse
from openapi_client.model.import_new_model_params import ImportNewModelParams
from openapi_client.model.inline_response200 import InlineResponse200
from openapi_client.model.is_training_job_running_params import IsTrainingJobRunningParams
from openapi_client.model.is_training_job_running_response import IsTrainingJobRunningResponse
from openapi_client.model.job import Job
from openapi_client.model.key_login_params import KeyLoginParams
from openapi_client.model.list_objects_params import ListObjectsParams
from openapi_client.model.list_objects_response import ListObjectsResponse
from openapi_client.model.load_model_params import LoadModelParams
from openapi_client.model.load_model_response import LoadModelResponse
from openapi_client.model.load_version_params import LoadVersionParams
from openapi_client.model.load_version_response import LoadVersionResponse
from openapi_client.model.login_params import LoginParams
from openapi_client.model.model_hash_request_params import ModelHashRequestParams
from openapi_client.model.model_version_id_request_params import ModelVersionIdRequestParams
from openapi_client.model.models_response import ModelsResponse
from openapi_client.model.new_dataset_params import NewDatasetParams
from openapi_client.model.parse_dataset_response import ParseDatasetResponse
from openapi_client.model.recent_models_response import RecentModelsResponse
from openapi_client.model.recent_organization_models_request_params import RecentOrganizationModelsRequestParams
from openapi_client.model.recover_visualizations_params import RecoverVisualizationsParams
from openapi_client.model.recover_visualizations_response import RecoverVisualizationsResponse
from openapi_client.model.remove_dashboard_params import RemoveDashboardParams
from openapi_client.model.remove_project_from_dashboard_params import RemoveProjectFromDashboardParams
from openapi_client.model.request_trial_params import RequestTrialParams
from openapi_client.model.request_trial_response import RequestTrialResponse
from openapi_client.model.resend_activation_mail_params import ResendActivationMailParams
from openapi_client.model.resend_activation_mail_response import ResendActivationMailResponse
from openapi_client.model.reset_password_params import ResetPasswordParams
from openapi_client.model.reset_password_response import ResetPasswordResponse
from openapi_client.model.save_analyzer_layout_params import SaveAnalyzerLayoutParams
from openapi_client.model.save_custom_loss_version_params import SaveCustomLossVersionParams
from openapi_client.model.save_custom_loss_version_response import SaveCustomLossVersionResponse
from openapi_client.model.save_dataset_setup_response import SaveDatasetSetupResponse
from openapi_client.model.save_dataset_version_params import SaveDatasetVersionParams
from openapi_client.model.save_project_params import SaveProjectParams
from openapi_client.model.save_project_response import SaveProjectResponse
from openapi_client.model.send_reset_password_mail_params import SendResetPasswordMailParams
from openapi_client.model.send_reset_password_mail_response import SendResetPasswordMailResponse
from openapi_client.model.set_project_to_dashboard_params import SetProjectToDashboardParams
from openapi_client.model.set_user_metadata_params import SetUserMetadataParams
from openapi_client.model.set_user_metadata_response import SetUserMetadataResponse
from openapi_client.model.signup_params import SignupParams
from openapi_client.model.signup_response import SignupResponse
from openapi_client.model.terminate_job_params import TerminateJobParams
from openapi_client.model.terminate_job_response import TerminateJobResponse
from openapi_client.model.test_custom_loss_params import TestCustomLossParams
from openapi_client.model.test_custom_loss_response import TestCustomLossResponse
from openapi_client.model.test_stub_params import TestStubParams
from openapi_client.model.test_stub_response import TestStubResponse
from openapi_client.model.trash_custom_loss_params import TrashCustomLossParams
from openapi_client.model.trash_dataset_params import TrashDatasetParams
from openapi_client.model.trash_project_params import TrashProjectParams
from openapi_client.model.trash_secret_manager_params import TrashSecretManagerParams
from openapi_client.model.trash_secret_manager_response import TrashSecretManagerResponse
from openapi_client.model.update_secret_manager_params import UpdateSecretManagerParams
from openapi_client.model.update_secret_manager_response import UpdateSecretManagerResponse
from openapi_client.model.user_data import UserData
from openapi_client.model.visualization import Visualization


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

    Do not edit the class manually.
    """

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

        def __activate(
            self,
            activation_params,
            **kwargs
        ):
            """activate  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.activate(activation_params, async_req=True)
            >>> result = thread.get()

            Args:
                activation_params (ActivationParams):

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

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

        self.activate = _Endpoint(
            settings={
                'response_type': (UserData,),
                'auth': [],
                'endpoint_path': '/auth/activate',
                'operation_id': 'activate',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'activation_params',
                ],
                'required': [
                    'activation_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'activation_params':
                        (ActivationParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'activation_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__activate
        )

        def __add_custom_loss(
            self,
            add_custom_loss_params,
            **kwargs
        ):
            """add_custom_loss  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.add_custom_loss(add_custom_loss_params, async_req=True)
            >>> result = thread.get()

            Args:
                add_custom_loss_params (AddCustomLossParams):

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

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

        self.add_custom_loss = _Endpoint(
            settings={
                'response_type': (AddCustomLossResponse,),
                'auth': [],
                'endpoint_path': '/custom-loss/addCustomLoss',
                'operation_id': 'add_custom_loss',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'add_custom_loss_params',
                ],
                'required': [
                    'add_custom_loss_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'add_custom_loss_params':
                        (AddCustomLossParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'add_custom_loss_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__add_custom_loss
        )

        def __add_dashboard(
            self,
            add_dashboard_params,
            **kwargs
        ):
            """add_dashboard  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.add_dashboard(add_dashboard_params, async_req=True)
            >>> result = thread.get()

            Args:
                add_dashboard_params (AddDashboardParams):

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

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

        self.add_dashboard = _Endpoint(
            settings={
                'response_type': (GetDashboardsResponse,),
                'auth': [],
                'endpoint_path': '/dashboards/add',
                'operation_id': 'add_dashboard',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'add_dashboard_params',
                ],
                'required': [
                    'add_dashboard_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'add_dashboard_params':
                        (AddDashboardParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'add_dashboard_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__add_dashboard
        )

        def __add_dataset(
            self,
            new_dataset_params,
            **kwargs
        ):
            """add_dataset  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.add_dataset(new_dataset_params, async_req=True)
            >>> result = thread.get()

            Args:
                new_dataset_params (NewDatasetParams):

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

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

        self.add_dataset = _Endpoint(
            settings={
                'response_type': (AddDatasetResponse,),
                'auth': [],
                'endpoint_path': '/datasets/addDataset',
                'operation_id': 'add_dataset',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'new_dataset_params',
                ],
                'required': [
                    'new_dataset_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'new_dataset_params':
                        (NewDatasetParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'new_dataset_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__add_dataset
        )

        def __add_export_model_job(
            self,
            add_export_model_job_params,
            **kwargs
        ):
            """add_export_model_job  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.add_export_model_job(add_export_model_job_params, async_req=True)
            >>> result = thread.get()

            Args:
                add_export_model_job_params (AddExportModelJobParams):

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

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

        self.add_export_model_job = _Endpoint(
            settings={
                'response_type': (Job,),
                'auth': [],
                'endpoint_path': '/jobs/addExportModelJob',
                'operation_id': 'add_export_model_job',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'add_export_model_job_params',
                ],
                'required': [
                    'add_export_model_job_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'add_export_model_job_params':
                        (AddExportModelJobParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'add_export_model_job_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__add_export_model_job
        )

        def __add_job(
            self,
            add_job_params,
            **kwargs
        ):
            """add_job  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.add_job(add_job_params, async_req=True)
            >>> result = thread.get()

            Args:
                add_job_params (AddJobParams):

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

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

        self.add_job = _Endpoint(
            settings={
                'response_type': (Job,),
                'auth': [],
                'endpoint_path': '/jobs/addJob',
                'operation_id': 'add_job',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'add_job_params',
                ],
                'required': [
                    'add_job_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'add_job_params':
                        (AddJobParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'add_job_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__add_job
        )

        def __add_secret_manager(
            self,
            add_secret_manager_params,
            **kwargs
        ):
            """add_secret_manager  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.add_secret_manager(add_secret_manager_params, async_req=True)
            >>> result = thread.get()

            Args:
                add_secret_manager_params (AddSecretManagerParams):

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

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

        self.add_secret_manager = _Endpoint(
            settings={
                'response_type': (AddSecretManagerResponse,),
                'auth': [],
                'endpoint_path': '/secret-manager/addSecretManager',
                'operation_id': 'add_secret_manager',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'add_secret_manager_params',
                ],
                'required': [
                    'add_secret_manager_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'add_secret_manager_params':
                        (AddSecretManagerParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'add_secret_manager_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__add_secret_manager
        )

        def __delete_visualizations(
            self,
            delete_visualizations_params,
            **kwargs
        ):
            """delete_visualizations  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.delete_visualizations(delete_visualizations_params, async_req=True)
            >>> result = thread.get()

            Args:
                delete_visualizations_params (DeleteVisualizationsParams):

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

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

        self.delete_visualizations = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/visualizations/deleteVisualizations',
                'operation_id': 'delete_visualizations',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'delete_visualizations_params',
                ],
                'required': [
                    'delete_visualizations_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'delete_visualizations_params':
                        (DeleteVisualizationsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'delete_visualizations_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__delete_visualizations
        )

        def __get_branch_versions(
            self,
            get_branch_versions_params,
            **kwargs
        ):
            """get_branch_versions  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_branch_versions(get_branch_versions_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_branch_versions_params (GetBranchVersionsParams):

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

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

        self.get_branch_versions = _Endpoint(
            settings={
                'response_type': (GetBranchVersionsResponse,),
                'auth': [],
                'endpoint_path': '/versions/getBranchVersions',
                'operation_id': 'get_branch_versions',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_branch_versions_params',
                ],
                'required': [
                    'get_branch_versions_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_branch_versions_params':
                        (GetBranchVersionsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_branch_versions_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_branch_versions
        )

        def __get_bucket_list(
            self,
            get_bucket_list_params,
            **kwargs
        ):
            """get_bucket_list  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_bucket_list(get_bucket_list_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_bucket_list_params (GetBucketListParams):

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

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

        self.get_bucket_list = _Endpoint(
            settings={
                'response_type': (GetBucketListResponse,),
                'auth': [],
                'endpoint_path': '/datasets/getBucketList',
                'operation_id': 'get_bucket_list',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_bucket_list_params',
                ],
                'required': [
                    'get_bucket_list_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_bucket_list_params':
                        (GetBucketListParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_bucket_list_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_bucket_list
        )

        def __get_current_project_version(
            self,
            get_current_project_version_params,
            **kwargs
        ):
            """get_current_project_version  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_current_project_version(get_current_project_version_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_current_project_version_params (GetCurrentProjectVersionParams):

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

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

        self.get_current_project_version = _Endpoint(
            settings={
                'response_type': (GetCurrentProjectVersionResponse,),
                'auth': [],
                'endpoint_path': '/projects/getCurrentProjectVersion',
                'operation_id': 'get_current_project_version',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_current_project_version_params',
                ],
                'required': [
                    'get_current_project_version_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_current_project_version_params':
                        (GetCurrentProjectVersionParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_current_project_version_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_current_project_version
        )

        def __get_custom_loss_version(
            self,
            get_custom_loss_version_params,
            **kwargs
        ):
            """get_custom_loss_version  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_custom_loss_version(get_custom_loss_version_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_custom_loss_version_params (GetCustomLossVersionParams):

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

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

        self.get_custom_loss_version = _Endpoint(
            settings={
                'response_type': (GetCustomLossVersionResponse,),
                'auth': [],
                'endpoint_path': '/custom-loss/getCustomLossVersion',
                'operation_id': 'get_custom_loss_version',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_custom_loss_version_params',
                ],
                'required': [
                    'get_custom_loss_version_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_custom_loss_version_params':
                        (GetCustomLossVersionParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_custom_loss_version_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_custom_loss_version
        )

        def __get_custom_losses(
            self,
            **kwargs
        ):
            """get_custom_losses  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_custom_losses(async_req=True)
            >>> result = thread.get()


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

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

        self.get_custom_losses = _Endpoint(
            settings={
                'response_type': (CustomLossListResponse,),
                'auth': [],
                'endpoint_path': '/custom-loss/getCustomLosses',
                'operation_id': 'get_custom_losses',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_custom_losses
        )

        def __get_dashboards(
            self,
            **kwargs
        ):
            """get_dashboards  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_dashboards(async_req=True)
            >>> result = thread.get()


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

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

        self.get_dashboards = _Endpoint(
            settings={
                'response_type': (GetDashboardsResponse,),
                'auth': [],
                'endpoint_path': '/dashboards/list',
                'operation_id': 'get_dashboards',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_dashboards
        )

        def __get_dataset_version(
            self,
            get_dataset_version_params,
            **kwargs
        ):
            """get_dataset_version  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_dataset_version(get_dataset_version_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_dataset_version_params (GetDatasetVersionParams):

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

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

        self.get_dataset_version = _Endpoint(
            settings={
                'response_type': (GetDatasetVersionResponse,),
                'auth': [],
                'endpoint_path': '/datasets/getDatasetVersion',
                'operation_id': 'get_dataset_version',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_dataset_version_params',
                ],
                'required': [
                    'get_dataset_version_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_dataset_version_params':
                        (GetDatasetVersionParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_dataset_version_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_dataset_version
        )

        def __get_datasets(
            self,
            **kwargs
        ):
            """get_datasets  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_datasets(async_req=True)
            >>> result = thread.get()


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

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

        self.get_datasets = _Endpoint(
            settings={
                'response_type': (GetDatasetsResponse,),
                'auth': [],
                'endpoint_path': '/datasets/getDatasets',
                'operation_id': 'get_datasets',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_datasets
        )

        def __get_deleted_visualizations(
            self,
            get_deleted_visualizations_params,
            **kwargs
        ):
            """get_deleted_visualizations  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_deleted_visualizations(get_deleted_visualizations_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_deleted_visualizations_params (GetDeletedVisualizationsParams):

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

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

        self.get_deleted_visualizations = _Endpoint(
            settings={
                'response_type': (GetDeletedVisualizationsResponse,),
                'auth': [],
                'endpoint_path': '/visualizations/getDeletedVisualizations',
                'operation_id': 'get_deleted_visualizations',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_deleted_visualizations_params',
                ],
                'required': [
                    'get_deleted_visualizations_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_deleted_visualizations_params':
                        (GetDeletedVisualizationsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_deleted_visualizations_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_deleted_visualizations
        )

        def __get_demos(
            self,
            **kwargs
        ):
            """get_demos  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_demos(async_req=True)
            >>> result = thread.get()


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

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

        self.get_demos = _Endpoint(
            settings={
                'response_type': (GetDemosResponse,),
                'auth': [],
                'endpoint_path': '/demos/getDemos',
                'operation_id': 'get_demos',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_demos
        )

        def __get_exported_model_jobs(
            self,
            get_exported_model_jobs_params,
            **kwargs
        ):
            """get_exported_model_jobs  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_exported_model_jobs(get_exported_model_jobs_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_exported_model_jobs_params (GetExportedModelJobsParams):

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

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

        self.get_exported_model_jobs = _Endpoint(
            settings={
                'response_type': (GetExportedModelJobsResponse,),
                'auth': [],
                'endpoint_path': '/exportedmodels/getExportedModelJobs',
                'operation_id': 'get_exported_model_jobs',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_exported_model_jobs_params',
                ],
                'required': [
                    'get_exported_model_jobs_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_exported_model_jobs_params':
                        (GetExportedModelJobsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_exported_model_jobs_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_exported_model_jobs
        )

        def __get_jobs(
            self,
            get_jobs_params,
            **kwargs
        ):
            """get_jobs  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_jobs(get_jobs_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_jobs_params (GetJobsParams):

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

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

        self.get_jobs = _Endpoint(
            settings={
                'response_type': (GetJobsResponse,),
                'auth': [],
                'endpoint_path': '/jobs/getJobs',
                'operation_id': 'get_jobs',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_jobs_params',
                ],
                'required': [
                    'get_jobs_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_jobs_params':
                        (GetJobsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_jobs_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_jobs
        )

        def __get_kibana_dashboards(
            self,
            **kwargs
        ):
            """get_kibana_dashboards  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_kibana_dashboards(async_req=True)
            >>> result = thread.get()


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

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

        self.get_kibana_dashboards = _Endpoint(
            settings={
                'response_type': (GetKibanaDashboardsResponse,),
                'auth': [],
                'endpoint_path': '/dashboards/getKibanaDashboards',
                'operation_id': 'get_kibana_dashboards',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_kibana_dashboards
        )

        def __get_latest_custom_loss_version(
            self,
            get_latest_custom_loss_version_params,
            **kwargs
        ):
            """get_latest_custom_loss_version  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_latest_custom_loss_version(get_latest_custom_loss_version_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_latest_custom_loss_version_params (GetLatestCustomLossVersionParams):

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

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

        self.get_latest_custom_loss_version = _Endpoint(
            settings={
                'response_type': (GetLatestCustomLossVersionResponse,),
                'auth': [],
                'endpoint_path': '/custom-loss/getLatestCustomLossVersion',
                'operation_id': 'get_latest_custom_loss_version',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_latest_custom_loss_version_params',
                ],
                'required': [
                    'get_latest_custom_loss_version_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_latest_custom_loss_version_params':
                        (GetLatestCustomLossVersionParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_latest_custom_loss_version_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_latest_custom_loss_version
        )

        def __get_latest_dataset_version(
            self,
            get_latest_dataset_version_params,
            **kwargs
        ):
            """get_latest_dataset_version  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_latest_dataset_version(get_latest_dataset_version_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_latest_dataset_version_params (GetLatestDatasetVersionParams):

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

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

        self.get_latest_dataset_version = _Endpoint(
            settings={
                'response_type': (GetLatestDatasetVersionResponse,),
                'auth': [],
                'endpoint_path': '/datasets/getLatestDatasetVersion',
                'operation_id': 'get_latest_dataset_version',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_latest_dataset_version_params',
                ],
                'required': [
                    'get_latest_dataset_version_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_latest_dataset_version_params':
                        (GetLatestDatasetVersionParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_latest_dataset_version_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_latest_dataset_version
        )

        def __get_model_jobs(
            self,
            get_model_jobs_params,
            **kwargs
        ):
            """get_model_jobs  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_model_jobs(get_model_jobs_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_model_jobs_params (GetModelJobsParams):

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

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

        self.get_model_jobs = _Endpoint(
            settings={
                'response_type': (GetModelJobsResponse,),
                'auth': [],
                'endpoint_path': '/jobs/getModelJobs',
                'operation_id': 'get_model_jobs',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_model_jobs_params',
                ],
                'required': [
                    'get_model_jobs_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_model_jobs_params':
                        (GetModelJobsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_model_jobs_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_model_jobs
        )

        def __get_model_visualizations(
            self,
            get_model_visualizations_params,
            **kwargs
        ):
            """get_model_visualizations  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_model_visualizations(get_model_visualizations_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_model_visualizations_params (GetModelVisualizationsParams):

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

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

        self.get_model_visualizations = _Endpoint(
            settings={
                'response_type': (GetModelVisualizationsResponse,),
                'auth': [],
                'endpoint_path': '/visualizations/getModelVisualizations',
                'operation_id': 'get_model_visualizations',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_model_visualizations_params',
                ],
                'required': [
                    'get_model_visualizations_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_model_visualizations_params':
                        (GetModelVisualizationsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_model_visualizations_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_model_visualizations
        )

        def __get_models_by_hash(
            self,
            model_hash_request_params,
            **kwargs
        ):
            """get_models_by_hash  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_models_by_hash(model_hash_request_params, async_req=True)
            >>> result = thread.get()

            Args:
                model_hash_request_params (ModelHashRequestParams):

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

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

        self.get_models_by_hash = _Endpoint(
            settings={
                'response_type': (ModelsResponse,),
                'auth': [],
                'endpoint_path': '/models/getModelsByHash',
                'operation_id': 'get_models_by_hash',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'model_hash_request_params',
                ],
                'required': [
                    'model_hash_request_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'model_hash_request_params':
                        (ModelHashRequestParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'model_hash_request_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_models_by_hash
        )

        def __get_models_by_version_id(
            self,
            model_version_id_request_params,
            **kwargs
        ):
            """get_models_by_version_id  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_models_by_version_id(model_version_id_request_params, async_req=True)
            >>> result = thread.get()

            Args:
                model_version_id_request_params (ModelVersionIdRequestParams):

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

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

        self.get_models_by_version_id = _Endpoint(
            settings={
                'response_type': (ModelsResponse,),
                'auth': [],
                'endpoint_path': '/models/getModelsByVersionId',
                'operation_id': 'get_models_by_version_id',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'model_version_id_request_params',
                ],
                'required': [
                    'model_version_id_request_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'model_version_id_request_params':
                        (ModelVersionIdRequestParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'model_version_id_request_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_models_by_version_id
        )

        def __get_notifications(
            self,
            **kwargs
        ):
            """get_notifications  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_notifications(async_req=True)
            >>> result = thread.get()


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

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

        self.get_notifications = _Endpoint(
            settings={
                'response_type': (GetNotificationsResponse,),
                'auth': [],
                'endpoint_path': '/notifications/getDemos',
                'operation_id': 'get_notifications',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_notifications
        )

        def __get_organization_jobs(
            self,
            get_organization_jobs_params,
            **kwargs
        ):
            """get_organization_jobs  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_organization_jobs(get_organization_jobs_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_organization_jobs_params (GetOrganizationJobsParams):

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

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

        self.get_organization_jobs = _Endpoint(
            settings={
                'response_type': (GetJobsResponse,),
                'auth': [],
                'endpoint_path': '/jobs/getOrganizationJobs',
                'operation_id': 'get_organization_jobs',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_organization_jobs_params',
                ],
                'required': [
                    'get_organization_jobs_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_organization_jobs_params':
                        (GetOrganizationJobsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_organization_jobs_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_organization_jobs
        )

        def __get_project_slim_versions(
            self,
            get_project_versions_params,
            **kwargs
        ):
            """get_project_slim_versions  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_project_slim_versions(get_project_versions_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_project_versions_params (GetProjectVersionsParams):

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

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

        self.get_project_slim_versions = _Endpoint(
            settings={
                'response_type': (GetProjectSlimVersionsResponse,),
                'auth': [],
                'endpoint_path': '/versions/getProjectSlimVersions',
                'operation_id': 'get_project_slim_versions',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_project_versions_params',
                ],
                'required': [
                    'get_project_versions_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_project_versions_params':
                        (GetProjectVersionsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_project_versions_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_project_slim_versions
        )

        def __get_project_versions(
            self,
            get_project_versions_params,
            **kwargs
        ):
            """get_project_versions  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_project_versions(get_project_versions_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_project_versions_params (GetProjectVersionsParams):

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

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

        self.get_project_versions = _Endpoint(
            settings={
                'response_type': (GetProjectVersionsResponse,),
                'auth': [],
                'endpoint_path': '/versions/getProjectVersions',
                'operation_id': 'get_project_versions',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_project_versions_params',
                ],
                'required': [
                    'get_project_versions_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_project_versions_params':
                        (GetProjectVersionsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_project_versions_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_project_versions
        )

        def __get_projects(
            self,
            **kwargs
        ):
            """get_projects  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_projects(async_req=True)
            >>> result = thread.get()


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

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

        self.get_projects = _Endpoint(
            settings={
                'response_type': (GetProjectsResponse,),
                'auth': [],
                'endpoint_path': '/projects/getProjects',
                'operation_id': 'get_projects',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_projects
        )

        def __get_recent_organization_models(
            self,
            recent_organization_models_request_params,
            **kwargs
        ):
            """get_recent_organization_models  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_recent_organization_models(recent_organization_models_request_params, async_req=True)
            >>> result = thread.get()

            Args:
                recent_organization_models_request_params (RecentOrganizationModelsRequestParams):

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

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

        self.get_recent_organization_models = _Endpoint(
            settings={
                'response_type': (RecentModelsResponse,),
                'auth': [],
                'endpoint_path': '/models/getRecentOrganizationModels',
                'operation_id': 'get_recent_organization_models',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'recent_organization_models_request_params',
                ],
                'required': [
                    'recent_organization_models_request_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'recent_organization_models_request_params':
                        (RecentOrganizationModelsRequestParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'recent_organization_models_request_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_recent_organization_models
        )

        def __get_secret_manager_list(
            self,
            **kwargs
        ):
            """get_secret_manager_list  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_secret_manager_list(async_req=True)
            >>> result = thread.get()


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

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

        self.get_secret_manager_list = _Endpoint(
            settings={
                'response_type': (GetSecretManagerListResponse,),
                'auth': [],
                'endpoint_path': '/secret-manager/getSecretManagerList',
                'operation_id': 'get_secret_manager_list',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_secret_manager_list
        )

        def __get_stored_exported_model_resource_url(
            self,
            get_stored_exported_model_resource_url_params,
            **kwargs
        ):
            """get_stored_exported_model_resource_url  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_stored_exported_model_resource_url(get_stored_exported_model_resource_url_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_stored_exported_model_resource_url_params (GetStoredExportedModelResourceUrlParams):

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

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

        self.get_stored_exported_model_resource_url = _Endpoint(
            settings={
                'response_type': (GetStoredExportedModelResourceUrlResponse,),
                'auth': [],
                'endpoint_path': '/exportedmodels/getStoredExportedModelResourceUrl',
                'operation_id': 'get_stored_exported_model_resource_url',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_stored_exported_model_resource_url_params',
                ],
                'required': [
                    'get_stored_exported_model_resource_url_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_stored_exported_model_resource_url_params':
                        (GetStoredExportedModelResourceUrlParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_stored_exported_model_resource_url_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_stored_exported_model_resource_url
        )

        def __get_stored_resource(
            self,
            blob,
            **kwargs
        ):
            """get_stored_resource  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_stored_resource(blob, async_req=True)
            >>> result = thread.get()

            Args:
                blob (str):

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

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

        self.get_stored_resource = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/jobs/getStoredResource',
                'operation_id': 'get_stored_resource',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'blob',
                ],
                'required': [
                    'blob',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'blob':
                        (str,),
                },
                'attribute_map': {
                    'blob': 'blob',
                },
                'location_map': {
                    'blob': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_stored_resource
        )

        def __get_stored_resource_string(
            self,
            blob,
            **kwargs
        ):
            """get_stored_resource_string  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_stored_resource_string(blob, async_req=True)
            >>> result = thread.get()

            Args:
                blob (str):

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

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

        self.get_stored_resource_string = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/jobs/getStoredResourceUrl',
                'operation_id': 'get_stored_resource_string',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'blob',
                ],
                'required': [
                    'blob',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'blob':
                        (str,),
                },
                'attribute_map': {
                    'blob': 'blob',
                },
                'location_map': {
                    'blob': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__get_stored_resource_string
        )

        def __get_training_jobs(
            self,
            get_training_job_params,
            **kwargs
        ):
            """get_training_jobs  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_training_jobs(get_training_job_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_training_job_params (GetTrainingJobParams):

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

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

        self.get_training_jobs = _Endpoint(
            settings={
                'response_type': ([Job],),
                'auth': [],
                'endpoint_path': '/jobs/getTrainingJobs',
                'operation_id': 'get_training_jobs',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_training_job_params',
                ],
                'required': [
                    'get_training_job_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_training_job_params':
                        (GetTrainingJobParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_training_job_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_training_jobs
        )

        def __get_upload_signed_url(
            self,
            get_upload_signed_url_params,
            **kwargs
        ):
            """get_upload_signed_url  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_upload_signed_url(get_upload_signed_url_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_upload_signed_url_params (GetUploadSignedUrlParams):

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

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

        self.get_upload_signed_url = _Endpoint(
            settings={
                'response_type': (ExternalImportModelStorage,),
                'auth': [],
                'endpoint_path': '/versions/getUploadSignedUrl',
                'operation_id': 'get_upload_signed_url',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_upload_signed_url_params',
                ],
                'required': [
                    'get_upload_signed_url_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_upload_signed_url_params':
                        (GetUploadSignedUrlParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_upload_signed_url_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_upload_signed_url
        )

        def __get_visualization(
            self,
            get_visualization_params,
            **kwargs
        ):
            """get_visualization  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.get_visualization(get_visualization_params, async_req=True)
            >>> result = thread.get()

            Args:
                get_visualization_params (GetVisualizationParams):

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

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

        self.get_visualization = _Endpoint(
            settings={
                'response_type': (Visualization,),
                'auth': [],
                'endpoint_path': '/visualizations/getVisualization',
                'operation_id': 'get_visualization',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'get_visualization_params',
                ],
                'required': [
                    'get_visualization_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'get_visualization_params':
                        (GetVisualizationParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'get_visualization_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__get_visualization
        )

        def __import_demo_project(
            self,
            import_demo_project_params,
            **kwargs
        ):
            """import_demo_project  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.import_demo_project(import_demo_project_params, async_req=True)
            >>> result = thread.get()

            Args:
                import_demo_project_params (ImportDemoProjectParams):

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

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

        self.import_demo_project = _Endpoint(
            settings={
                'response_type': (ImportDemoProjectResponse,),
                'auth': [],
                'endpoint_path': '/demos/importDemoProject',
                'operation_id': 'import_demo_project',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'import_demo_project_params',
                ],
                'required': [
                    'import_demo_project_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'import_demo_project_params':
                        (ImportDemoProjectParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'import_demo_project_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__import_demo_project
        )

        def __import_model(
            self,
            import_new_model_params,
            **kwargs
        ):
            """import_model  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.import_model(import_new_model_params, async_req=True)
            >>> result = thread.get()

            Args:
                import_new_model_params (ImportNewModelParams):

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

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

        self.import_model = _Endpoint(
            settings={
                'response_type': (ExternalImportModelStorageResponse,),
                'auth': [],
                'endpoint_path': '/versions/importModel',
                'operation_id': 'import_model',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'import_new_model_params',
                ],
                'required': [
                    'import_new_model_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'import_new_model_params':
                        (ImportNewModelParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'import_new_model_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__import_model
        )

        def __is_training_job_running(
            self,
            is_training_job_running_params,
            **kwargs
        ):
            """is_training_job_running  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.is_training_job_running(is_training_job_running_params, async_req=True)
            >>> result = thread.get()

            Args:
                is_training_job_running_params (IsTrainingJobRunningParams):

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

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

        self.is_training_job_running = _Endpoint(
            settings={
                'response_type': (IsTrainingJobRunningResponse,),
                'auth': [],
                'endpoint_path': '/jobs/isTrainingJobRunning',
                'operation_id': 'is_training_job_running',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'is_training_job_running_params',
                ],
                'required': [
                    'is_training_job_running_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'is_training_job_running_params':
                        (IsTrainingJobRunningParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'is_training_job_running_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__is_training_job_running
        )

        def __key_gen(
            self,
            **kwargs
        ):
            """key_gen  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.key_gen(async_req=True)
            >>> result = thread.get()


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

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

        self.key_gen = _Endpoint(
            settings={
                'response_type': (str,),
                'auth': [],
                'endpoint_path': '/auth/keygen',
                'operation_id': 'key_gen',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__key_gen
        )

        def __key_login(
            self,
            key_login_params,
            **kwargs
        ):
            """key_login  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.key_login(key_login_params, async_req=True)
            >>> result = thread.get()

            Args:
                key_login_params (KeyLoginParams):

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

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

        self.key_login = _Endpoint(
            settings={
                'response_type': (UserData,),
                'auth': [],
                'endpoint_path': '/auth/keylogin',
                'operation_id': 'key_login',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'key_login_params',
                ],
                'required': [
                    'key_login_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'key_login_params':
                        (KeyLoginParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'key_login_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__key_login
        )

        def __load_model(
            self,
            load_model_params,
            **kwargs
        ):
            """load_model  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.load_model(load_model_params, async_req=True)
            >>> result = thread.get()

            Args:
                load_model_params (LoadModelParams):

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

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

        self.load_model = _Endpoint(
            settings={
                'response_type': (LoadModelResponse,),
                'auth': [],
                'endpoint_path': '/projects/loadModel',
                'operation_id': 'load_model',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'load_model_params',
                ],
                'required': [
                    'load_model_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'load_model_params':
                        (LoadModelParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'load_model_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__load_model
        )

        def __load_version(
            self,
            load_version_params,
            **kwargs
        ):
            """load_version  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.load_version(load_version_params, async_req=True)
            >>> result = thread.get()

            Args:
                load_version_params (LoadVersionParams):

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

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

        self.load_version = _Endpoint(
            settings={
                'response_type': (LoadVersionResponse,),
                'auth': [],
                'endpoint_path': '/versions/loadVersion',
                'operation_id': 'load_version',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'load_version_params',
                ],
                'required': [
                    'load_version_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'load_version_params':
                        (LoadVersionParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'load_version_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__load_version
        )

        def __login(
            self,
            login_params,
            **kwargs
        ):
            """login  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.login(login_params, async_req=True)
            >>> result = thread.get()

            Args:
                login_params (LoginParams):

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

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

        self.login = _Endpoint(
            settings={
                'response_type': (UserData,),
                'auth': [],
                'endpoint_path': '/auth/login',
                'operation_id': 'login',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'login_params',
                ],
                'required': [
                    'login_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'login_params':
                        (LoginParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'login_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__login
        )

        def __logout(
            self,
            **kwargs
        ):
            """logout  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.logout(async_req=True)
            >>> result = thread.get()


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

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

        self.logout = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/auth/logout',
                'operation_id': 'logout',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client,
            callable=__logout
        )

        def __parse_dataset(
            self,
            dataset_parse_request_params,
            **kwargs
        ):
            """parse_dataset  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.parse_dataset(dataset_parse_request_params, async_req=True)
            >>> result = thread.get()

            Args:
                dataset_parse_request_params (DatasetParseRequestParams):

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

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

        self.parse_dataset = _Endpoint(
            settings={
                'response_type': (ParseDatasetResponse,),
                'auth': [],
                'endpoint_path': '/datasets/parseDataset',
                'operation_id': 'parse_dataset',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'dataset_parse_request_params',
                ],
                'required': [
                    'dataset_parse_request_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'dataset_parse_request_params':
                        (DatasetParseRequestParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'dataset_parse_request_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__parse_dataset
        )

        def __recover_deleted_visualizations(
            self,
            recover_visualizations_params,
            **kwargs
        ):
            """recover_deleted_visualizations  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.recover_deleted_visualizations(recover_visualizations_params, async_req=True)
            >>> result = thread.get()

            Args:
                recover_visualizations_params (RecoverVisualizationsParams):

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

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

        self.recover_deleted_visualizations = _Endpoint(
            settings={
                'response_type': (RecoverVisualizationsResponse,),
                'auth': [],
                'endpoint_path': '/visualizations/recoverDeletedVisualizations',
                'operation_id': 'recover_deleted_visualizations',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'recover_visualizations_params',
                ],
                'required': [
                    'recover_visualizations_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'recover_visualizations_params':
                        (RecoverVisualizationsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'recover_visualizations_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__recover_deleted_visualizations
        )

        def __remove_dashboard(
            self,
            remove_dashboard_params,
            **kwargs
        ):
            """remove_dashboard  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.remove_dashboard(remove_dashboard_params, async_req=True)
            >>> result = thread.get()

            Args:
                remove_dashboard_params (RemoveDashboardParams):

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

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

        self.remove_dashboard = _Endpoint(
            settings={
                'response_type': (GetDashboardsResponse,),
                'auth': [],
                'endpoint_path': '/dashboards/remove',
                'operation_id': 'remove_dashboard',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'remove_dashboard_params',
                ],
                'required': [
                    'remove_dashboard_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'remove_dashboard_params':
                        (RemoveDashboardParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'remove_dashboard_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__remove_dashboard
        )

        def __remove_project_from_dashboard(
            self,
            remove_project_from_dashboard_params,
            **kwargs
        ):
            """remove_project_from_dashboard  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.remove_project_from_dashboard(remove_project_from_dashboard_params, async_req=True)
            >>> result = thread.get()

            Args:
                remove_project_from_dashboard_params (RemoveProjectFromDashboardParams):

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

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

        self.remove_project_from_dashboard = _Endpoint(
            settings={
                'response_type': (GetDashboardsResponse,),
                'auth': [],
                'endpoint_path': '/dashboards/removeProjectFromDashboard',
                'operation_id': 'remove_project_from_dashboard',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'remove_project_from_dashboard_params',
                ],
                'required': [
                    'remove_project_from_dashboard_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'remove_project_from_dashboard_params':
                        (RemoveProjectFromDashboardParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'remove_project_from_dashboard_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__remove_project_from_dashboard
        )

        def __request_trial(
            self,
            request_trial_params,
            **kwargs
        ):
            """request_trial  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.request_trial(request_trial_params, async_req=True)
            >>> result = thread.get()

            Args:
                request_trial_params (RequestTrialParams):

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

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

        self.request_trial = _Endpoint(
            settings={
                'response_type': (RequestTrialResponse,),
                'auth': [],
                'endpoint_path': '/auth/requestTrial',
                'operation_id': 'request_trial',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'request_trial_params',
                ],
                'required': [
                    'request_trial_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'request_trial_params':
                        (RequestTrialParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'request_trial_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__request_trial
        )

        def __resend_activation_mail(
            self,
            resend_activation_mail_params,
            **kwargs
        ):
            """resend_activation_mail  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.resend_activation_mail(resend_activation_mail_params, async_req=True)
            >>> result = thread.get()

            Args:
                resend_activation_mail_params (ResendActivationMailParams):

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

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

        self.resend_activation_mail = _Endpoint(
            settings={
                'response_type': (ResendActivationMailResponse,),
                'auth': [],
                'endpoint_path': '/auth/resendActivationMail',
                'operation_id': 'resend_activation_mail',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'resend_activation_mail_params',
                ],
                'required': [
                    'resend_activation_mail_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'resend_activation_mail_params':
                        (ResendActivationMailParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'resend_activation_mail_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__resend_activation_mail
        )

        def __reset_password(
            self,
            reset_password_params,
            **kwargs
        ):
            """reset_password  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.reset_password(reset_password_params, async_req=True)
            >>> result = thread.get()

            Args:
                reset_password_params (ResetPasswordParams):

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

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

        self.reset_password = _Endpoint(
            settings={
                'response_type': (ResetPasswordResponse,),
                'auth': [],
                'endpoint_path': '/auth/resetPassword',
                'operation_id': 'reset_password',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'reset_password_params',
                ],
                'required': [
                    'reset_password_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'reset_password_params':
                        (ResetPasswordParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'reset_password_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__reset_password
        )

        def __save_analyzer_layout(
            self,
            save_analyzer_layout_params,
            **kwargs
        ):
            """save_analyzer_layout  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.save_analyzer_layout(save_analyzer_layout_params, async_req=True)
            >>> result = thread.get()

            Args:
                save_analyzer_layout_params (SaveAnalyzerLayoutParams):

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

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

        self.save_analyzer_layout = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/visualizations/saveAnalyzerLayout',
                'operation_id': 'save_analyzer_layout',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'save_analyzer_layout_params',
                ],
                'required': [
                    'save_analyzer_layout_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'save_analyzer_layout_params':
                        (SaveAnalyzerLayoutParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'save_analyzer_layout_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__save_analyzer_layout
        )

        def __save_custom_loss_version(
            self,
            save_custom_loss_version_params,
            **kwargs
        ):
            """save_custom_loss_version  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.save_custom_loss_version(save_custom_loss_version_params, async_req=True)
            >>> result = thread.get()

            Args:
                save_custom_loss_version_params (SaveCustomLossVersionParams):

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

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

        self.save_custom_loss_version = _Endpoint(
            settings={
                'response_type': (SaveCustomLossVersionResponse,),
                'auth': [],
                'endpoint_path': '/custom-loss/saveCustomLossVersion',
                'operation_id': 'save_custom_loss_version',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'save_custom_loss_version_params',
                ],
                'required': [
                    'save_custom_loss_version_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'save_custom_loss_version_params':
                        (SaveCustomLossVersionParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'save_custom_loss_version_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__save_custom_loss_version
        )

        def __save_dataset_version(
            self,
            save_dataset_version_params,
            **kwargs
        ):
            """save_dataset_version  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.save_dataset_version(save_dataset_version_params, async_req=True)
            >>> result = thread.get()

            Args:
                save_dataset_version_params (SaveDatasetVersionParams):

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

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

        self.save_dataset_version = _Endpoint(
            settings={
                'response_type': (SaveDatasetSetupResponse,),
                'auth': [],
                'endpoint_path': '/datasets/saveDatasetVersion',
                'operation_id': 'save_dataset_version',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'save_dataset_version_params',
                ],
                'required': [
                    'save_dataset_version_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'save_dataset_version_params':
                        (SaveDatasetVersionParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'save_dataset_version_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__save_dataset_version
        )

        def __save_project(
            self,
            save_project_params,
            **kwargs
        ):
            """save_project  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.save_project(save_project_params, async_req=True)
            >>> result = thread.get()

            Args:
                save_project_params (SaveProjectParams):

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

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

        self.save_project = _Endpoint(
            settings={
                'response_type': (SaveProjectResponse,),
                'auth': [],
                'endpoint_path': '/projects/saveProject',
                'operation_id': 'save_project',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'save_project_params',
                ],
                'required': [
                    'save_project_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'save_project_params':
                        (SaveProjectParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'save_project_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__save_project
        )

        def __send_reset_password_mail(
            self,
            send_reset_password_mail_params,
            **kwargs
        ):
            """send_reset_password_mail  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.send_reset_password_mail(send_reset_password_mail_params, async_req=True)
            >>> result = thread.get()

            Args:
                send_reset_password_mail_params (SendResetPasswordMailParams):

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

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

        self.send_reset_password_mail = _Endpoint(
            settings={
                'response_type': (SendResetPasswordMailResponse,),
                'auth': [],
                'endpoint_path': '/auth/sendResetPasswordMail',
                'operation_id': 'send_reset_password_mail',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'send_reset_password_mail_params',
                ],
                'required': [
                    'send_reset_password_mail_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'send_reset_password_mail_params':
                        (SendResetPasswordMailParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'send_reset_password_mail_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__send_reset_password_mail
        )

        def __set_project_to_dashboard(
            self,
            set_project_to_dashboard_params,
            **kwargs
        ):
            """set_project_to_dashboard  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.set_project_to_dashboard(set_project_to_dashboard_params, async_req=True)
            >>> result = thread.get()

            Args:
                set_project_to_dashboard_params (SetProjectToDashboardParams):

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

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

        self.set_project_to_dashboard = _Endpoint(
            settings={
                'response_type': (GetDashboardsResponse,),
                'auth': [],
                'endpoint_path': '/dashboards/setProjectToDashboard',
                'operation_id': 'set_project_to_dashboard',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'set_project_to_dashboard_params',
                ],
                'required': [
                    'set_project_to_dashboard_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'set_project_to_dashboard_params':
                        (SetProjectToDashboardParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'set_project_to_dashboard_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__set_project_to_dashboard
        )

        def __set_user_metadata(
            self,
            set_user_metadata_params,
            **kwargs
        ):
            """set_user_metadata  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.set_user_metadata(set_user_metadata_params, async_req=True)
            >>> result = thread.get()

            Args:
                set_user_metadata_params (SetUserMetadataParams):

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

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

        self.set_user_metadata = _Endpoint(
            settings={
                'response_type': (SetUserMetadataResponse,),
                'auth': [],
                'endpoint_path': '/auth/setUserMetadata',
                'operation_id': 'set_user_metadata',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'set_user_metadata_params',
                ],
                'required': [
                    'set_user_metadata_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'set_user_metadata_params':
                        (SetUserMetadataParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'set_user_metadata_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__set_user_metadata
        )

        def __set_user_notifications_as_read(
            self,
            **kwargs
        ):
            """set_user_notifications_as_read  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.set_user_notifications_as_read(async_req=True)
            >>> result = thread.get()


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

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

        self.set_user_notifications_as_read = _Endpoint(
            settings={
                'response_type': (InlineResponse200,),
                'auth': [],
                'endpoint_path': '/notifications/setUserNotificationsAsRead',
                'operation_id': 'set_user_notifications_as_read',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__set_user_notifications_as_read
        )

        def __signup(
            self,
            signup_params,
            **kwargs
        ):
            """signup  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.signup(signup_params, async_req=True)
            >>> result = thread.get()

            Args:
                signup_params (SignupParams):

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

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

        self.signup = _Endpoint(
            settings={
                'response_type': (SignupResponse,),
                'auth': [],
                'endpoint_path': '/auth/signup',
                'operation_id': 'signup',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'signup_params',
                ],
                'required': [
                    'signup_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'signup_params':
                        (SignupParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'signup_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__signup
        )

        def __terminate_job(
            self,
            terminate_job_params,
            **kwargs
        ):
            """terminate_job  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.terminate_job(terminate_job_params, async_req=True)
            >>> result = thread.get()

            Args:
                terminate_job_params (TerminateJobParams):

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

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

        self.terminate_job = _Endpoint(
            settings={
                'response_type': (TerminateJobResponse,),
                'auth': [],
                'endpoint_path': '/jobs/terminateJob',
                'operation_id': 'terminate_job',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'terminate_job_params',
                ],
                'required': [
                    'terminate_job_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'terminate_job_params':
                        (TerminateJobParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'terminate_job_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__terminate_job
        )

        def __test_custom_loss(
            self,
            test_custom_loss_params,
            **kwargs
        ):
            """test_custom_loss  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.test_custom_loss(test_custom_loss_params, async_req=True)
            >>> result = thread.get()

            Args:
                test_custom_loss_params (TestCustomLossParams):

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

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

        self.test_custom_loss = _Endpoint(
            settings={
                'response_type': (TestCustomLossResponse,),
                'auth': [],
                'endpoint_path': '/custom-loss/testCustomLoss',
                'operation_id': 'test_custom_loss',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'test_custom_loss_params',
                ],
                'required': [
                    'test_custom_loss_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'test_custom_loss_params':
                        (TestCustomLossParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'test_custom_loss_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__test_custom_loss
        )

        def __test_stub(
            self,
            test_stub_params,
            **kwargs
        ):
            """test_stub  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.test_stub(test_stub_params, async_req=True)
            >>> result = thread.get()

            Args:
                test_stub_params (TestStubParams):

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

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

        self.test_stub = _Endpoint(
            settings={
                'response_type': (TestStubResponse,),
                'auth': [],
                'endpoint_path': '/custom-loss/testStub',
                'operation_id': 'test_stub',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'test_stub_params',
                ],
                'required': [
                    'test_stub_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'test_stub_params':
                        (TestStubParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'test_stub_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__test_stub
        )

        def __trash_custom_loss(
            self,
            trash_custom_loss_params,
            **kwargs
        ):
            """trash_custom_loss  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.trash_custom_loss(trash_custom_loss_params, async_req=True)
            >>> result = thread.get()

            Args:
                trash_custom_loss_params (TrashCustomLossParams):

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

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

        self.trash_custom_loss = _Endpoint(
            settings={
                'response_type': (CustomLossListResponse,),
                'auth': [],
                'endpoint_path': '/custom-loss/trashCustomLoss',
                'operation_id': 'trash_custom_loss',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'trash_custom_loss_params',
                ],
                'required': [
                    'trash_custom_loss_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'trash_custom_loss_params':
                        (TrashCustomLossParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'trash_custom_loss_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__trash_custom_loss
        )

        def __trash_dataset(
            self,
            trash_dataset_params,
            **kwargs
        ):
            """trash_dataset  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.trash_dataset(trash_dataset_params, async_req=True)
            >>> result = thread.get()

            Args:
                trash_dataset_params (TrashDatasetParams):

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

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

        self.trash_dataset = _Endpoint(
            settings={
                'response_type': (GetDatasetsResponse,),
                'auth': [],
                'endpoint_path': '/datasets/trashDataset',
                'operation_id': 'trash_dataset',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'trash_dataset_params',
                ],
                'required': [
                    'trash_dataset_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'trash_dataset_params':
                        (TrashDatasetParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'trash_dataset_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__trash_dataset
        )

        def __trash_project(
            self,
            trash_project_params,
            **kwargs
        ):
            """trash_project  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.trash_project(trash_project_params, async_req=True)
            >>> result = thread.get()

            Args:
                trash_project_params (TrashProjectParams):

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

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

        self.trash_project = _Endpoint(
            settings={
                'response_type': (GetProjectsResponse,),
                'auth': [],
                'endpoint_path': '/projects/trashProject',
                'operation_id': 'trash_project',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'trash_project_params',
                ],
                'required': [
                    'trash_project_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'trash_project_params':
                        (TrashProjectParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'trash_project_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__trash_project
        )

        def __trash_secret_manager(
            self,
            trash_secret_manager_params,
            **kwargs
        ):
            """trash_secret_manager  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.trash_secret_manager(trash_secret_manager_params, async_req=True)
            >>> result = thread.get()

            Args:
                trash_secret_manager_params (TrashSecretManagerParams):

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

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

        self.trash_secret_manager = _Endpoint(
            settings={
                'response_type': (TrashSecretManagerResponse,),
                'auth': [],
                'endpoint_path': '/secret-manager/trashSecretManager',
                'operation_id': 'trash_secret_manager',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'trash_secret_manager_params',
                ],
                'required': [
                    'trash_secret_manager_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'trash_secret_manager_params':
                        (TrashSecretManagerParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'trash_secret_manager_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__trash_secret_manager
        )

        def __update_secret_manager(
            self,
            update_secret_manager_params,
            **kwargs
        ):
            """update_secret_manager  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.update_secret_manager(update_secret_manager_params, async_req=True)
            >>> result = thread.get()

            Args:
                update_secret_manager_params (UpdateSecretManagerParams):

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

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

        self.update_secret_manager = _Endpoint(
            settings={
                'response_type': (UpdateSecretManagerResponse,),
                'auth': [],
                'endpoint_path': '/secret-manager/updateSecretManager',
                'operation_id': 'update_secret_manager',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'update_secret_manager_params',
                ],
                'required': [
                    'update_secret_manager_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'update_secret_manager_params':
                        (UpdateSecretManagerParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'update_secret_manager_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__update_secret_manager
        )

        def __view_bucket(
            self,
            list_objects_params,
            **kwargs
        ):
            """view_bucket  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.view_bucket(list_objects_params, async_req=True)
            >>> result = thread.get()

            Args:
                list_objects_params (ListObjectsParams):

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

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

        self.view_bucket = _Endpoint(
            settings={
                'response_type': (ListObjectsResponse,),
                'auth': [],
                'endpoint_path': '/buckets/viewBucket',
                'operation_id': 'view_bucket',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'list_objects_params',
                ],
                'required': [
                    'list_objects_params',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'list_objects_params':
                        (ListObjectsParams,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'list_objects_params': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__view_bucket
        )

        def __warmup(
            self,
            **kwargs
        ):
            """warmup  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.warmup(async_req=True)
            >>> result = thread.get()


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

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

        self.warmup = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/jobs/warmup',
                'operation_id': 'warmup',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client,
            callable=__warmup
        )

        def __who_am_i(
            self,
            **kwargs
        ):
            """who_am_i  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.who_am_i(async_req=True)
            >>> result = thread.get()


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

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

        self.who_am_i = _Endpoint(
            settings={
                'response_type': (UserData,),
                'auth': [],
                'endpoint_path': '/auth/whoAmI',
                'operation_id': 'who_am_i',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__who_am_i
        )
