"""
    Alvin

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

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


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

from alvin_api_client.api_client import ApiClient, Endpoint as _Endpoint
from alvin_api_client.model_utils import (  # noqa: F401
    check_allowed_values,
    check_validations,
    date,
    datetime,
    file_type,
    none_type,
    validate_and_convert_types
)
from alvin_api_client.model.accept_invite_request import AcceptInviteRequest
from alvin_api_client.model.admin_config import AdminConfig
from alvin_api_client.model.alvin_description_request import AlvinDescriptionRequest
from alvin_api_client.model.auth_provider import AuthProvider
from alvin_api_client.model.client_config import ClientConfig
from alvin_api_client.model.client_config_post_auth import ClientConfigPostAuth
from alvin_api_client.model.connection_direction import ConnectionDirection
from alvin_api_client.model.connection_type import ConnectionType
from alvin_api_client.model.connection_usage_classification import ConnectionUsageClassification
from alvin_api_client.model.data_entity_delete_tag_connection_request import DataEntityDeleteTagConnectionRequest
from alvin_api_client.model.data_entity_dependency_get import DataEntityDependencyGet
from alvin_api_client.model.data_entity_get import DataEntityGet
from alvin_api_client.model.data_entity_id import DataEntityID
from alvin_api_client.model.data_entity_lineage_children_request import DataEntityLineageChildrenRequest
from alvin_api_client.model.data_entity_lineage_children_response import DataEntityLineageChildrenResponse
from alvin_api_client.model.data_entity_lineage_list_request import DataEntityLineageListRequest
from alvin_api_client.model.data_entity_lineage_list_response import DataEntityLineageListResponse
from alvin_api_client.model.data_entity_lineage_v2_request import DataEntityLineageV2Request
from alvin_api_client.model.data_entity_lineage_v2_response import DataEntityLineageV2Response
from alvin_api_client.model.data_entity_numerical_stat_response import DataEntityNumericalStatResponse
from alvin_api_client.model.data_entity_run_get import DataEntityRunGet
from alvin_api_client.model.data_entity_run_job_step_mapping_get import DataEntityRunJobStepMappingGet
from alvin_api_client.model.data_entity_save_tag_connection_request import DataEntitySaveTagConnectionRequest
from alvin_api_client.model.data_entity_type import DataEntityType
from alvin_api_client.model.data_entity_usage_stats_report import DataEntityUsageStatsReport
from alvin_api_client.model.data_entity_usage_stats_request import DataEntityUsageStatsRequest
from alvin_api_client.model.data_platform_airflow_create import DataPlatformAirflowCreate
from alvin_api_client.model.data_platform_big_query_create import DataPlatformBigQueryCreate
from alvin_api_client.model.data_platform_dbt_create import DataPlatformDBTCreate
from alvin_api_client.model.data_platform_databricks_create import DataPlatformDatabricksCreate
from alvin_api_client.model.data_platform_delete import DataPlatformDelete
from alvin_api_client.model.data_platform_full import DataPlatformFull
from alvin_api_client.model.data_platform_get import DataPlatformGet
from alvin_api_client.model.data_platform_hive_create import DataPlatformHiveCreate
from alvin_api_client.model.data_platform_hive_glue_create import DataPlatformHiveGlueCreate
from alvin_api_client.model.data_platform_job_step import DataPlatformJobStep
from alvin_api_client.model.data_platform_job_step_aggregated_report import DataPlatformJobStepAggregatedReport
from alvin_api_client.model.data_platform_job_step_report_type import DataPlatformJobStepReportType
from alvin_api_client.model.data_platform_job_step_request import DataPlatformJobStepRequest
from alvin_api_client.model.data_platform_job_step_user import DataPlatformJobStepUser
from alvin_api_client.model.data_platform_looker_create import DataPlatformLookerCreate
from alvin_api_client.model.data_platform_mssql_create import DataPlatformMSSQLCreate
from alvin_api_client.model.data_platform_mode_create import DataPlatformModeCreate
from alvin_api_client.model.data_platform_my_sql_create import DataPlatformMySQLCreate
from alvin_api_client.model.data_platform_postgres_create import DataPlatformPostgresCreate
from alvin_api_client.model.data_platform_power_bi_create import DataPlatformPowerBICreate
from alvin_api_client.model.data_platform_redshift_create import DataPlatformRedshiftCreate
from alvin_api_client.model.data_platform_snowflake_create import DataPlatformSnowflakeCreate
from alvin_api_client.model.data_platform_tableau_create import DataPlatformTableauCreate
from alvin_api_client.model.data_platform_treasure_data_create import DataPlatformTreasureDataCreate
from alvin_api_client.model.data_tag_bulk_apply import DataTagBulkApply
from alvin_api_client.model.data_tag_bulk_delete import DataTagBulkDelete
from alvin_api_client.model.data_tag_request import DataTagRequest
from alvin_api_client.model.data_tag_request_delete import DataTagRequestDelete
from alvin_api_client.model.data_tag_request_v2 import DataTagRequestV2
from alvin_api_client.model.data_tag_rules_request_delete import DataTagRulesRequestDelete
from alvin_api_client.model.data_tag_type import DataTagType
from alvin_api_client.model.data_taxonomy_classification import DataTaxonomyClassification
from alvin_api_client.model.email_login_request import EmailLoginRequest
from alvin_api_client.model.exchange_token_request import ExchangeTokenRequest
from alvin_api_client.model.experience import Experience
from alvin_api_client.model.experience_data import ExperienceData
from alvin_api_client.model.filter_options import FilterOptions
from alvin_api_client.model.filters_response import FiltersResponse
from alvin_api_client.model.http_validation_error import HTTPValidationError
from alvin_api_client.model.healthcheck_response import HealthcheckResponse
from alvin_api_client.model.impact_analysis_node_list_response import ImpactAnalysisNodeListResponse
from alvin_api_client.model.impact_analysis_query_validation import ImpactAnalysisQueryValidation
from alvin_api_client.model.impact_analysis_request import ImpactAnalysisRequest
from alvin_api_client.model.impact_analysis_response import ImpactAnalysisResponse
from alvin_api_client.model.impact_analysis_validation_payload import ImpactAnalysisValidationPayload
from alvin_api_client.model.job_entity_usage_stats_report import JobEntityUsageStatsReport
from alvin_api_client.model.job_query_request import JobQueryRequest
from alvin_api_client.model.job_query_v1_response import JobQueryV1Response
from alvin_api_client.model.limit_offset_page_api_keys_response import LimitOffsetPageAPIKeysResponse
from alvin_api_client.model.limit_offset_page_data_entity_get import LimitOffsetPageDataEntityGet
from alvin_api_client.model.limit_offset_page_data_entity_numerical_stat import LimitOffsetPageDataEntityNumericalStat
from alvin_api_client.model.limit_offset_page_data_entity_run_facet_get import LimitOffsetPageDataEntityRunFacetGet
from alvin_api_client.model.limit_offset_page_data_entity_run_get import LimitOffsetPageDataEntityRunGet
from alvin_api_client.model.limit_offset_page_data_entity_run_job_mapping_get import LimitOffsetPageDataEntityRunJobMappingGet
from alvin_api_client.model.limit_offset_page_data_entity_usage_stat_raw import LimitOffsetPageDataEntityUsageStatRaw
from alvin_api_client.model.limit_offset_page_data_entity_usage_stats_report import LimitOffsetPageDataEntityUsageStatsReport
from alvin_api_client.model.limit_offset_page_data_platform_job import LimitOffsetPageDataPlatformJob
from alvin_api_client.model.limit_offset_page_data_platform_job_entity_aggregated_report import LimitOffsetPageDataPlatformJobEntityAggregatedReport
from alvin_api_client.model.limit_offset_page_data_tag_connection_get import LimitOffsetPageDataTagConnectionGet
from alvin_api_client.model.limit_offset_page_data_tag_get import LimitOffsetPageDataTagGet
from alvin_api_client.model.limit_offset_page_data_tag_rule_get import LimitOffsetPageDataTagRuleGet
from alvin_api_client.model.limit_offset_page_manual_lineage_data import LimitOffsetPageManualLineageData
from alvin_api_client.model.links_request import LinksRequest
from alvin_api_client.model.manual_lineage_data_request import ManualLineageDataRequest
from alvin_api_client.model.manual_lineage_entity_type_validation import ManualLineageEntityTypeValidation
from alvin_api_client.model.notification import Notification
from alvin_api_client.model.organization_get import OrganizationGet
from alvin_api_client.model.platform_classification import PlatformClassification
from alvin_api_client.model.processed_lineage_graph_data import ProcessedLineageGraphData
from alvin_api_client.model.save_search_filter import SaveSearchFilter
from alvin_api_client.model.save_search_string_filter import SaveSearchStringFilter
from alvin_api_client.model.search_node import SearchNode
from alvin_api_client.model.search_v2_response import SearchV2Response
from alvin_api_client.model.tiny_url_response import TinyURLResponse
from alvin_api_client.model.token import Token
from alvin_api_client.model.user_activity_request import UserActivityRequest
from alvin_api_client.model.user_activity_response import UserActivityResponse
from alvin_api_client.model.user_create_request import UserCreateRequest
from alvin_api_client.model.user_get import UserGet
from alvin_api_client.model.user_invite_create import UserInviteCreate
from alvin_api_client.model.user_organization_api_key_request import UserOrganizationAPIKeyRequest
from alvin_api_client.model.user_organization_api_key_response import UserOrganizationAPIKeyResponse


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
        self.accept_invite_to_organization_api_v2_users_accept_invite_put_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v2/users/accept-invite',
                'operation_id': 'accept_invite_to_organization_api_v2_users_accept_invite_put',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'accept_invite_request',
                ],
                'required': [
                    'accept_invite_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'accept_invite_request':
                        (AcceptInviteRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'accept_invite_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.add_manual_lineage_api_v1_lineage_manual_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/lineage/manual',
                'operation_id': 'add_manual_lineage_api_v1_lineage_manual_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'manual_lineage_data_request',
                ],
                'required': [
                    'manual_lineage_data_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'manual_lineage_data_request':
                        (ManualLineageDataRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'manual_lineage_data_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.add_user_stat_api_v2_user_analytics_add_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/user/analytics/add',
                'operation_id': 'add_user_stat_api_v2_user_analytics_add_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'user_activity_request',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'user_activity_request':
                        (UserActivityRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'user_activity_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.add_users_to_org_api_v2_users_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/users',
                'operation_id': 'add_users_to_org_api_v2_users_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'user_create_request',
                ],
                'required': [
                    'user_create_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'user_create_request':
                        (UserCreateRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'user_create_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.bulk_apply_api_v1_tags_bulk_apply_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/tags/bulk-apply',
                'operation_id': 'bulk_apply_api_v1_tags_bulk_apply_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_tag_bulk_apply',
                ],
                'required': [
                    'data_tag_bulk_apply',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_tag_bulk_apply':
                        (DataTagBulkApply,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_tag_bulk_apply': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.bulk_delete_api_v1_tags_bulk_delete_delete_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/tags/bulk-delete',
                'operation_id': 'bulk_delete_api_v1_tags_bulk_delete_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_tag_bulk_delete',
                ],
                'required': [
                    'data_tag_bulk_delete',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_tag_bulk_delete':
                        (DataTagBulkDelete,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_tag_bulk_delete': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.clear_platform_api_v1_platforms_platform_id_clear_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformDelete,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/{platform_id}/clear',
                'operation_id': 'clear_platform_api_v1_platforms_platform_id_clear_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.create_airflow_platform_api_v1_platforms_airflow_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/airflow',
                'operation_id': 'create_airflow_platform_api_v1_platforms_airflow_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_airflow_create',
                ],
                'required': [
                    'data_platform_airflow_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_airflow_create':
                        (DataPlatformAirflowCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_airflow_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_api_key_api_v1_api_key_post_endpoint = _Endpoint(
            settings={
                'response_type': (UserOrganizationAPIKeyResponse,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/api-key',
                'operation_id': 'create_api_key_api_v1_api_key_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'user_organization_api_key_request',
                ],
                'required': [
                    'user_organization_api_key_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'user_organization_api_key_request':
                        (UserOrganizationAPIKeyRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'user_organization_api_key_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_bigquery_platform_api_v1_platforms_bigquery_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/bigquery',
                'operation_id': 'create_bigquery_platform_api_v1_platforms_bigquery_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_big_query_create',
                ],
                'required': [
                    'data_platform_big_query_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_big_query_create':
                        (DataPlatformBigQueryCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_big_query_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_databricks_platform_api_v1_platforms_databricks_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/databricks',
                'operation_id': 'create_databricks_platform_api_v1_platforms_databricks_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_databricks_create',
                ],
                'required': [
                    'data_platform_databricks_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_databricks_create':
                        (DataPlatformDatabricksCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_databricks_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_dbt_platform_api_v1_platforms_dbt_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/dbt',
                'operation_id': 'create_dbt_platform_api_v1_platforms_dbt_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_dbt_create',
                ],
                'required': [
                    'data_platform_dbt_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_dbt_create':
                        (DataPlatformDBTCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_dbt_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_hive_platform_api_v1_platforms_hive_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/hive',
                'operation_id': 'create_hive_platform_api_v1_platforms_hive_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_hive_create',
                ],
                'required': [
                    'data_platform_hive_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_hive_create':
                        (DataPlatformHiveCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_hive_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_hiveglue_platform_api_v1_platforms_hiveglue_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/hiveglue',
                'operation_id': 'create_hiveglue_platform_api_v1_platforms_hiveglue_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_hive_glue_create',
                ],
                'required': [
                    'data_platform_hive_glue_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_hive_glue_create':
                        (DataPlatformHiveGlueCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_hive_glue_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_looker_platform_api_v1_platforms_looker_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/looker',
                'operation_id': 'create_looker_platform_api_v1_platforms_looker_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_looker_create',
                ],
                'required': [
                    'data_platform_looker_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_looker_create':
                        (DataPlatformLookerCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_looker_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_mode_platform_api_v1_platforms_mode_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/mode',
                'operation_id': 'create_mode_platform_api_v1_platforms_mode_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_mode_create',
                ],
                'required': [
                    'data_platform_mode_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_mode_create':
                        (DataPlatformModeCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_mode_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_mssql_platform_api_v1_platforms_mssql_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/mssql',
                'operation_id': 'create_mssql_platform_api_v1_platforms_mssql_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_mssql_create',
                ],
                'required': [
                    'data_platform_mssql_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_mssql_create':
                        (DataPlatformMSSQLCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_mssql_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_mysql_platform_api_v1_platforms_mysql_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/mysql',
                'operation_id': 'create_mysql_platform_api_v1_platforms_mysql_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_my_sql_create',
                ],
                'required': [
                    'data_platform_my_sql_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_my_sql_create':
                        (DataPlatformMySQLCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_my_sql_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_postgres_platform_api_v1_platforms_postgres_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/postgres',
                'operation_id': 'create_postgres_platform_api_v1_platforms_postgres_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_postgres_create',
                ],
                'required': [
                    'data_platform_postgres_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_postgres_create':
                        (DataPlatformPostgresCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_postgres_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_powerbi_platform_api_v1_platforms_powerbi_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/powerbi',
                'operation_id': 'create_powerbi_platform_api_v1_platforms_powerbi_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_power_bi_create',
                ],
                'required': [
                    'data_platform_power_bi_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_power_bi_create':
                        (DataPlatformPowerBICreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_power_bi_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_redshift_platform_api_v1_platforms_redshift_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/redshift',
                'operation_id': 'create_redshift_platform_api_v1_platforms_redshift_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_redshift_create',
                ],
                'required': [
                    'data_platform_redshift_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_redshift_create':
                        (DataPlatformRedshiftCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_redshift_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_snowflake_platform_api_v1_platforms_snowflake_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/snowflake',
                'operation_id': 'create_snowflake_platform_api_v1_platforms_snowflake_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_snowflake_create',
                ],
                'required': [
                    'data_platform_snowflake_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_snowflake_create':
                        (DataPlatformSnowflakeCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_snowflake_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_tableau_platform_api_v1_platforms_tableau_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/tableau',
                'operation_id': 'create_tableau_platform_api_v1_platforms_tableau_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_tableau_create',
                ],
                'required': [
                    'data_platform_tableau_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_tableau_create':
                        (DataPlatformTableauCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_tableau_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_treasuredata_platform_api_v1_platforms_treasuredata_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/treasuredata',
                'operation_id': 'create_treasuredata_platform_api_v1_platforms_treasuredata_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_treasure_data_create',
                ],
                'required': [
                    'data_platform_treasure_data_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_treasure_data_create':
                        (DataPlatformTreasureDataCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_treasure_data_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_update_entity_description_api_v1_entity_alvin_description_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/alvin-description',
                'operation_id': 'create_update_entity_description_api_v1_entity_alvin_description_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'alvin_description_request',
                ],
                'required': [
                    'alvin_description_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'alvin_description_request':
                        (AlvinDescriptionRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'alvin_description_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_update_entity_links_api_v1_entity_links_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/links',
                'operation_id': 'create_update_entity_links_api_v1_entity_links_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'links_request',
                ],
                'required': [
                    'links_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'links_request':
                        (LinksRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'links_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.delete_api_key_api_v1_api_keys_api_key_prefix_delete_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/api-keys/{api_key_prefix}',
                'operation_id': 'delete_api_key_api_v1_api_keys_api_key_prefix_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'api_key_prefix',
                ],
                'required': [
                    'api_key_prefix',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'api_key_prefix':
                        (str,),
                },
                'attribute_map': {
                    'api_key_prefix': 'api_key_prefix',
                },
                'location_map': {
                    'api_key_prefix': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.delete_manual_lineage_api_v1_lineage_manual_delete_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/lineage/manual',
                'operation_id': 'delete_manual_lineage_api_v1_lineage_manual_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'manual_lineage_data_request',
                ],
                'required': [
                    'manual_lineage_data_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'manual_lineage_data_request':
                        (ManualLineageDataRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'manual_lineage_data_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.delete_platform_api_v1_platforms_platform_id_delete_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformDelete,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/{platform_id}',
                'operation_id': 'delete_platform_api_v1_platforms_platform_id_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.delete_saved_search_filter_api_v2_saved_search_delete_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/saved_search',
                'operation_id': 'delete_saved_search_filter_api_v2_saved_search_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'search_name',
                ],
                'required': [
                    'search_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'search_name':
                        (str,),
                },
                'attribute_map': {
                    'search_name': 'search_name',
                },
                'location_map': {
                    'search_name': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.delete_tag_rules_api_v1_tags_rules_delete_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/tags/rules',
                'operation_id': 'delete_tag_rules_api_v1_tags_rules_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_tag_rules_request_delete',
                ],
                'required': [
                    'data_tag_rules_request_delete',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_tag_rules_request_delete':
                        (DataTagRulesRequestDelete,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_tag_rules_request_delete': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.delete_tags_api_v1_tags_delete_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/tags',
                'operation_id': 'delete_tags_api_v1_tags_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_tag_request_delete',
                ],
                'required': [
                    'data_tag_request_delete',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_tag_request_delete':
                        (DataTagRequestDelete,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_tag_request_delete': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.delete_tags_entity_connections_api_v1_entity_tags_delete_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/tags',
                'operation_id': 'delete_tags_entity_connections_api_v1_entity_tags_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_entity_delete_tag_connection_request',
                ],
                'required': [
                    'data_entity_delete_tag_connection_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_entity_delete_tag_connection_request':
                        ([DataEntityDeleteTagConnectionRequest],),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_entity_delete_tag_connection_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.email_login_api_v1_auth_email_login_post_endpoint = _Endpoint(
            settings={
                'response_type': (EmailLoginRequest,),
                'auth': [],
                'endpoint_path': '/api/v1/auth/email-login',
                'operation_id': 'email_login_api_v1_auth_email_login_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'email_login_request',
                ],
                'required': [
                    'email_login_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'email_login_request':
                        (EmailLoginRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'email_login_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.exchange_token_api_v1_auth_exchange_token_post_endpoint = _Endpoint(
            settings={
                'response_type': (Token,),
                'auth': [],
                'endpoint_path': '/api/v1/auth/exchange-token',
                'operation_id': 'exchange_token_api_v1_auth_exchange_token_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'provider_id',
                    'exchange_token_request',
                    'org_id',
                ],
                'required': [
                    'provider_id',
                    'exchange_token_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'provider_id':
                        (AuthProvider,),
                    'exchange_token_request':
                        (ExchangeTokenRequest,),
                    'org_id':
                        (str,),
                },
                'attribute_map': {
                    'provider_id': 'provider_id',
                    'org_id': 'orgId',
                },
                'location_map': {
                    'provider_id': 'query',
                    'exchange_token_request': 'body',
                    'org_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.expand_node_children_api_v1_lineage_node_expand_children_post_endpoint = _Endpoint(
            settings={
                'response_type': (ProcessedLineageGraphData,),
                'auth': [],
                'endpoint_path': '/api/v1/lineage/node/expand-children',
                'operation_id': 'expand_node_children_api_v1_lineage_node_expand_children_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_entity_id',
                ],
                'required': [
                    'data_entity_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_entity_id':
                        (DataEntityID,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_entity_id': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.find_data_entity_dependencies_api_v1_entity_dependency_post_endpoint = _Endpoint(
            settings={
                'response_type': ([DataEntityDependencyGet],),
                'auth': [],
                'endpoint_path': '/api/v1/entity/dependency',
                'operation_id': 'find_data_entity_dependencies_api_v1_entity_dependency_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_entity_id',
                ],
                'required': [
                    'data_entity_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_entity_id':
                        ([DataEntityID],),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_entity_id': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.find_entity_by_id_api_v1_entity_find_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataEntityGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/find',
                'operation_id': 'find_entity_by_id_api_v1_entity_find_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_admin_config_api_v1_admin_config_get_endpoint = _Endpoint(
            settings={
                'response_type': (AdminConfig,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/admin-config',
                'operation_id': 'get_admin_config_api_v1_admin_config_get',
                'http_method': 'GET',
                '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
        )
        self.get_airflow_platform_api_v1_platforms_airflow_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformAirflowCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/airflow/{platform_id}',
                'operation_id': 'get_airflow_platform_api_v1_platforms_airflow_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_all_taxonomy_classifications_api_v1_taxonomy_all_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataTaxonomyClassification],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/taxonomy/all',
                'operation_id': 'get_all_taxonomy_classifications_api_v1_taxonomy_all_get',
                'http_method': 'GET',
                '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
        )
        self.get_api_key_info_api_v1_api_keys_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageAPIKeysResponse,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/api-keys',
                'operation_id': 'get_api_key_info_api_v1_api_keys_get',
                'http_method': 'GET',
                '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
        )
        self.get_bigquery_platform_api_v1_platforms_bigquery_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformBigQueryCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/bigquery/{platform_id}',
                'operation_id': 'get_bigquery_platform_api_v1_platforms_bigquery_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_child_taxonomy_classification_api_v1_taxonomy_children_classification_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataTaxonomyClassification],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/taxonomy/children/{classification}',
                'operation_id': 'get_child_taxonomy_classification_api_v1_taxonomy_children_classification_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'classification',
                ],
                'required': [
                    'classification',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'classification':
                        (str,),
                },
                'attribute_map': {
                    'classification': 'classification',
                },
                'location_map': {
                    'classification': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_client_config_api_v1_client_config_get_endpoint = _Endpoint(
            settings={
                'response_type': (ClientConfig,),
                'auth': [],
                'endpoint_path': '/api/v1/client-config',
                'operation_id': 'get_client_config_api_v1_client_config_get',
                'http_method': 'GET',
                '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
        )
        self.get_client_config_post_auth_api_v1_client_config_post_auth_get_endpoint = _Endpoint(
            settings={
                'response_type': (ClientConfigPostAuth,),
                'auth': [],
                'endpoint_path': '/api/v1/client-config-post-auth',
                'operation_id': 'get_client_config_post_auth_api_v1_client_config_post_auth_get',
                'http_method': 'GET',
                '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
        )
        self.get_data_entity_run_facets_api_v1_entity_runs_run_id_facets_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityRunFacetGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/runs/{runId}/facets',
                'operation_id': 'get_data_entity_run_facets_api_v1_entity_runs_run_id_facets_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'run_id',
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'limit',
                    'offset',
                ],
                'required': [
                    'run_id',
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'run_id':
                        (str,),
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'run_id': 'runId',
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'run_id': 'path',
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_data_entity_run_job_mapping_api_v1_entity_runs_run_id_job_mappings_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityRunJobMappingGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/runs/{runId}/job-mappings',
                'operation_id': 'get_data_entity_run_job_mapping_api_v1_entity_runs_run_id_job_mappings_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'run_id',
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'limit',
                    'offset',
                ],
                'required': [
                    'run_id',
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'run_id':
                        (str,),
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'run_id': 'runId',
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'run_id': 'path',
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_data_entity_run_job_step_mapping_api_v1_entity_runs_run_id_job_step_mapping_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataEntityRunJobStepMappingGet],),
                'auth': [],
                'endpoint_path': '/api/v1/entity/runs/{runId}/job-step-mapping',
                'operation_id': 'get_data_entity_run_job_step_mapping_api_v1_entity_runs_run_id_job_step_mapping_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'run_id',
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'required': [
                    'run_id',
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'run_id':
                        (str,),
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                },
                'attribute_map': {
                    'run_id': 'runId',
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                },
                'location_map': {
                    'run_id': 'path',
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_data_entity_runs_api_v1_entity_runs_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityRunGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/runs',
                'operation_id': 'get_data_entity_runs_api_v1_entity_runs_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'limit',
                    'offset',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_data_entity_runs_by_id_api_v1_entity_runs_run_id_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataEntityRunGet],),
                'auth': [],
                'endpoint_path': '/api/v1/entity/runs/{runId}',
                'operation_id': 'get_data_entity_runs_by_id_api_v1_entity_runs_run_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'run_id',
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'required': [
                    'run_id',
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'run_id':
                        (str,),
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                },
                'attribute_map': {
                    'run_id': 'runId',
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                },
                'location_map': {
                    'run_id': 'path',
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_databricks_platform_api_v1_platforms_databricks_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformDatabricksCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/databricks/{platform_id}',
                'operation_id': 'get_databricks_platform_api_v1_platforms_databricks_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entities_usage_stats_post_api_v1_entities_usage_stats_post_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityUsageStatsReport,),
                'auth': [],
                'endpoint_path': '/api/v1/entities/usage-stats',
                'operation_id': 'get_entities_usage_stats_post_api_v1_entities_usage_stats_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                    'data_entity_usage_stats_request',
                    'limit',
                    'offset',
                    'sort',
                ],
                'required': [
                    'platform_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                    'data_entity_usage_stats_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                    'sort',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                    ('sort',): {

                        'regex': {
                            'pattern': r'^[\w: ]*$',  # noqa: E501
                        },
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        ([str],),
                    'entity_type':
                        ([str],),
                    'start_timestamp':
                        (datetime,),
                    'end_timestamp':
                        (datetime,),
                    'data_entity_usage_stats_request':
                        (DataEntityUsageStatsRequest,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                    'sort':
                        ([str],),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_type': 'entityType',
                    'start_timestamp': 'startTimestamp',
                    'end_timestamp': 'endTimestamp',
                    'limit': 'limit',
                    'offset': 'offset',
                    'sort': 'sort',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_type': 'query',
                    'start_timestamp': 'query',
                    'end_timestamp': 'query',
                    'data_entity_usage_stats_request': 'body',
                    'limit': 'query',
                    'offset': 'query',
                    'sort': 'query',
                },
                'collection_format_map': {
                    'platform_id': 'multi',
                    'entity_type': 'multi',
                    'sort': 'multi',
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_entity_api_v1_entity_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataEntityGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity',
                'operation_id': 'get_entity_api_v1_entity_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_children_api_v1_entity_children_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity-children',
                'operation_id': 'get_entity_children_api_v1_entity_children_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'has_connections',
                    'limit',
                    'offset',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'has_connections',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'has_connections':
                        (bool,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'has_connections': 'hasConnections',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'has_connections': 'query',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_children_api_v1_most_recent_entity_numerical_stats_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityNumericalStat,),
                'auth': [],
                'endpoint_path': '/api/v1/most-recent-entity-numerical-stats',
                'operation_id': 'get_entity_children_api_v1_most_recent_entity_numerical_stats_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'limit',
                    'offset',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_data_taxonomy_api_v1_entity_taxonomy_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataTaxonomyClassification],),
                'auth': [],
                'endpoint_path': '/api/v1/entity/taxonomy',
                'operation_id': 'get_entity_data_taxonomy_api_v1_entity_taxonomy_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_jobs_api_v1_entity_jobs_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataPlatformJob,),
                'auth': [],
                'endpoint_path': '/api/v1/entity-jobs',
                'operation_id': 'get_entity_jobs_api_v1_entity_jobs_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'limit',
                    'offset',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_lineage_api_v2_lineage_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataEntityLineageV2Response,),
                'auth': [],
                'endpoint_path': '/api/v2/lineage',
                'operation_id': 'get_entity_lineage_api_v2_lineage_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_entity_lineage_v2_request',
                ],
                'required': [
                    'data_entity_lineage_v2_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_entity_lineage_v2_request':
                        (DataEntityLineageV2Request,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_entity_lineage_v2_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_entity_lineage_children_api_v2_lineage_children_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataEntityLineageChildrenResponse,),
                'auth': [],
                'endpoint_path': '/api/v2/lineage/children',
                'operation_id': 'get_entity_lineage_children_api_v2_lineage_children_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_entity_lineage_children_request',
                ],
                'required': [
                    'data_entity_lineage_children_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_entity_lineage_children_request':
                        (DataEntityLineageChildrenRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_entity_lineage_children_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_entity_lineage_list_api_v2_lineage_list_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataEntityLineageListResponse,),
                'auth': [],
                'endpoint_path': '/api/v2/lineage/list',
                'operation_id': 'get_entity_lineage_list_api_v2_lineage_list_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_entity_lineage_list_request',
                ],
                'required': [
                    'data_entity_lineage_list_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_entity_lineage_list_request':
                        (DataEntityLineageListRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_entity_lineage_list_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_entity_numerical_stats_api_v1_get_entity_numerical_stats_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataEntityNumericalStatResponse,),
                'auth': [],
                'endpoint_path': '/api/v1/get-entity-numerical-stats',
                'operation_id': 'get_entity_numerical_stats_api_v1_get_entity_numerical_stats_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'start_timestamp':
                        (datetime,),
                    'end_timestamp':
                        (datetime,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'start_timestamp': 'startTimestamp',
                    'end_timestamp': 'endTimestamp',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'start_timestamp': 'query',
                    'end_timestamp': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_owner_id_api_v1_entity_owner_get_endpoint = _Endpoint(
            settings={
                'response_type': (UserGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/owner',
                'operation_id': 'get_entity_owner_id_api_v1_entity_owner_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'entity_id',
                    'entity_type',
                    'platform_id',
                ],
                'required': [
                    'entity_id',
                    'entity_type',
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'entity_id':
                        (str,),
                    'entity_type':
                        (str,),
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'entity_id': 'entity_id',
                    'entity_type': 'entity_type',
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'platform_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_parents_api_v1_entity_parents_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataEntityGet],),
                'auth': [],
                'endpoint_path': '/api/v1/entity-parents',
                'operation_id': 'get_entity_parents_api_v1_entity_parents_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_schema_api_v1_entity_entity_schema_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/entity-schema',
                'operation_id': 'get_entity_schema_api_v1_entity_entity_schema_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'limit',
                    'offset',
                    'get_entity_classifications',
                    'omit_deleted_children',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                    'get_entity_classifications':
                        (bool,),
                    'omit_deleted_children':
                        (bool,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'limit': 'limit',
                    'offset': 'offset',
                    'get_entity_classifications': 'get_entity_classifications',
                    'omit_deleted_children': 'omitDeletedChildren',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'limit': 'query',
                    'offset': 'query',
                    'get_entity_classifications': 'query',
                    'omit_deleted_children': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_siblings_api_v1_entity_siblings_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity-siblings',
                'operation_id': 'get_entity_siblings_api_v1_entity_siblings_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'limit',
                    'offset',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_tags_api_v1_entity_tags_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataTagConnectionGet,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/tags',
                'operation_id': 'get_entity_tags_api_v1_entity_tags_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'data_tag_type',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'data_tag_type':
                        (DataTagType,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'data_tag_type': 'dataTagType',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'data_tag_type': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_usage_stats_api_v1_entity_usage_stats_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataEntityUsageStatsReport,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/usage-stats',
                'operation_id': 'get_entity_usage_stats_api_v1_entity_usage_stats_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                    'usage_type',
                    'user_name',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        ([str],),
                    'start_timestamp':
                        (datetime,),
                    'end_timestamp':
                        (datetime,),
                    'usage_type':
                        ([str],),
                    'user_name':
                        ([str],),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'start_timestamp': 'startTimestamp',
                    'end_timestamp': 'endTimestamp',
                    'usage_type': 'usageType',
                    'user_name': 'userName',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'start_timestamp': 'query',
                    'end_timestamp': 'query',
                    'usage_type': 'query',
                    'user_name': 'query',
                },
                'collection_format_map': {
                    'entity_type': 'multi',
                    'usage_type': 'multi',
                    'user_name': 'multi',
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_entity_usage_stats_raw_api_v1_entity_usage_stats_raw_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityUsageStatRaw,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/usage-stats-raw',
                'operation_id': 'get_entity_usage_stats_raw_api_v1_entity_usage_stats_raw_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                    'connection_type',
                    'connection_direction',
                    'connection_usage_classification',
                    'usage_type',
                    'user_name',
                    'sort',
                    'limit',
                    'offset',
                ],
                'required': [
                    'platform_id',
                    'entity_id',
                    'entity_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'sort',
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('sort',): {

                        'regex': {
                            'pattern': r'^[\w: ]*$',  # noqa: E501
                        },
                    },
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'entity_id':
                        (str,),
                    'entity_type':
                        (str,),
                    'start_timestamp':
                        (datetime,),
                    'end_timestamp':
                        (datetime,),
                    'connection_type':
                        (ConnectionType,),
                    'connection_direction':
                        (ConnectionDirection,),
                    'connection_usage_classification':
                        (ConnectionUsageClassification,),
                    'usage_type':
                        ([str],),
                    'user_name':
                        ([str],),
                    'sort':
                        ([str],),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_id': 'entityId',
                    'entity_type': 'entityType',
                    'start_timestamp': 'startTimestamp',
                    'end_timestamp': 'endTimestamp',
                    'connection_type': 'connectionType',
                    'connection_direction': 'connectionDirection',
                    'connection_usage_classification': 'connectionUsageClassification',
                    'usage_type': 'usageType',
                    'user_name': 'userName',
                    'sort': 'sort',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_id': 'query',
                    'entity_type': 'query',
                    'start_timestamp': 'query',
                    'end_timestamp': 'query',
                    'connection_type': 'query',
                    'connection_direction': 'query',
                    'connection_usage_classification': 'query',
                    'usage_type': 'query',
                    'user_name': 'query',
                    'sort': 'query',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                    'usage_type': 'multi',
                    'user_name': 'multi',
                    'sort': 'multi',
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_experiences_api_v1_experience_get_endpoint = _Endpoint(
            settings={
                'response_type': ([Experience],),
                'auth': [],
                'endpoint_path': '/api/v1/experience',
                'operation_id': 'get_experiences_api_v1_experience_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'lead_user_email',
                    'user_persona',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lead_user_email':
                        (str,),
                    'user_persona':
                        (str,),
                },
                'attribute_map': {
                    'lead_user_email': 'lead_user_email',
                    'user_persona': 'user_persona',
                },
                'location_map': {
                    'lead_user_email': 'query',
                    'user_persona': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_filter_api_v2_filters_get_endpoint = _Endpoint(
            settings={
                'response_type': ([FilterOptions],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/filters',
                'operation_id': 'get_filter_api_v2_filters_get',
                'http_method': 'GET',
                '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
        )
        self.get_filters_config_api_v1_filters_config_get_endpoint = _Endpoint(
            settings={
                'response_type': (FiltersResponse,),
                'auth': [],
                'endpoint_path': '/api/v1/filters/config',
                'operation_id': 'get_filters_config_api_v1_filters_config_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'filter_view',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'filter_view':
                        (bool, date, datetime, dict, float, int, list, str, none_type,),
                },
                'attribute_map': {
                    'filter_view': 'filterView',
                },
                'location_map': {
                    'filter_view': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_hive_platform_api_v1_platforms_hive_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformHiveCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/hive/{platform_id}',
                'operation_id': 'get_hive_platform_api_v1_platforms_hive_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_hiveglue_platform_api_v1_platforms_hiveglue_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformHiveGlueCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/hiveglue/{platform_id}',
                'operation_id': 'get_hiveglue_platform_api_v1_platforms_hiveglue_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_impact_analysis_platforms_api_v2_impact_analysis_platforms_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataPlatformGet],),
                'auth': [],
                'endpoint_path': '/api/v2/impact-analysis/platforms',
                'operation_id': 'get_impact_analysis_platforms_api_v2_impact_analysis_platforms_get',
                'http_method': 'GET',
                '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
        )
        self.get_impact_by_query_api_v2_impact_analysis_query_post_endpoint = _Endpoint(
            settings={
                'response_type': (ImpactAnalysisResponse,),
                'auth': [],
                'endpoint_path': '/api/v2/impact-analysis/query',
                'operation_id': 'get_impact_by_query_api_v2_impact_analysis_query_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'impact_analysis_request',
                ],
                'required': [
                    'impact_analysis_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'impact_analysis_request':
                        (ImpactAnalysisRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'impact_analysis_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_impact_from_validation_payload_api_v2_impact_analysis_query_entities_post_endpoint = _Endpoint(
            settings={
                'response_type': (ImpactAnalysisResponse,),
                'auth': [],
                'endpoint_path': '/api/v2/impact-analysis/query-entities',
                'operation_id': 'get_impact_from_validation_payload_api_v2_impact_analysis_query_entities_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'impact_analysis_validation_payload',
                ],
                'required': [
                    'impact_analysis_validation_payload',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'impact_analysis_validation_payload':
                        (ImpactAnalysisValidationPayload,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'impact_analysis_validation_payload': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_invited_users_to_org_api_v2_users_invite_get_endpoint = _Endpoint(
            settings={
                'response_type': ([UserInviteCreate],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/users/invite',
                'operation_id': 'get_invited_users_to_org_api_v2_users_invite_get',
                'http_method': 'GET',
                '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
        )
        self.get_job_entity_usage_stats_report_api_v1_job_usage_stats_get_endpoint = _Endpoint(
            settings={
                'response_type': (JobEntityUsageStatsReport,),
                'auth': [],
                'endpoint_path': '/api/v1/job/usage-stats',
                'operation_id': 'get_job_entity_usage_stats_report_api_v1_job_usage_stats_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'job_hash',
                    'platform_id',
                    'start_timestamp',
                    'end_timestamp',
                ],
                'required': [
                    'job_hash',
                    'platform_id',
                    'start_timestamp',
                    'end_timestamp',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'job_hash':
                        (str,),
                    'platform_id':
                        (str,),
                    'start_timestamp':
                        (datetime,),
                    'end_timestamp':
                        (datetime,),
                },
                'attribute_map': {
                    'job_hash': 'jobHash',
                    'platform_id': 'platformId',
                    'start_timestamp': 'startTimestamp',
                    'end_timestamp': 'endTimestamp',
                },
                'location_map': {
                    'job_hash': 'query',
                    'platform_id': 'query',
                    'start_timestamp': 'query',
                    'end_timestamp': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_job_steps_aggregated_stats_api_v1_job_steps_aggregated_stats_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformJobStepAggregatedReport,),
                'auth': [],
                'endpoint_path': '/api/v1/job/steps/aggregated-stats',
                'operation_id': 'get_job_steps_aggregated_stats_api_v1_job_steps_aggregated_stats_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'job_hash',
                    'platform_id',
                    'report_type',
                    'local_timezone',
                ],
                'required': [
                    'job_hash',
                    'platform_id',
                    'report_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'job_hash':
                        (str,),
                    'platform_id':
                        (str,),
                    'report_type':
                        (DataPlatformJobStepReportType,),
                    'local_timezone':
                        (str,),
                },
                'attribute_map': {
                    'job_hash': 'jobHash',
                    'platform_id': 'platformId',
                    'report_type': 'reportType',
                    'local_timezone': 'localTimezone',
                },
                'location_map': {
                    'job_hash': 'query',
                    'platform_id': 'query',
                    'report_type': 'query',
                    'local_timezone': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_job_steps_api_v1_jobs_steps_post_endpoint = _Endpoint(
            settings={
                'response_type': ([DataPlatformJobStep],),
                'auth': [],
                'endpoint_path': '/api/v1/jobs/steps',
                'operation_id': 'get_job_steps_api_v1_jobs_steps_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_job_step_request',
                    'metadata_fields',
                ],
                'required': [
                    'data_platform_job_step_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_job_step_request':
                        (DataPlatformJobStepRequest,),
                    'metadata_fields':
                        (str,),
                },
                'attribute_map': {
                    'metadata_fields': 'metadataFields',
                },
                'location_map': {
                    'data_platform_job_step_request': 'body',
                    'metadata_fields': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_jobs_steps_aggregated_stats_api_v1_jobs_steps_aggregated_stats_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataPlatformJobEntityAggregatedReport,),
                'auth': [],
                'endpoint_path': '/api/v1/jobs/steps/aggregated-stats',
                'operation_id': 'get_jobs_steps_aggregated_stats_api_v1_jobs_steps_aggregated_stats_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'entity_id',
                    'platform_id',
                    'platform_type',
                    'entity_type',
                    'report_type',
                    'level',
                    'limit',
                    'offset',
                    'local_timezone',
                    'upstream',
                ],
                'required': [
                    'entity_id',
                    'platform_id',
                    'platform_type',
                    'entity_type',
                    'report_type',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'entity_id':
                        (str,),
                    'platform_id':
                        (str,),
                    'platform_type':
                        (str,),
                    'entity_type':
                        (DataEntityType,),
                    'report_type':
                        (DataPlatformJobStepReportType,),
                    'level':
                        (int,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                    'local_timezone':
                        (str,),
                    'upstream':
                        (bool,),
                },
                'attribute_map': {
                    'entity_id': 'entityId',
                    'platform_id': 'platformId',
                    'platform_type': 'platformType',
                    'entity_type': 'entityType',
                    'report_type': 'reportType',
                    'level': 'level',
                    'limit': 'limit',
                    'offset': 'offset',
                    'local_timezone': 'localTimezone',
                    'upstream': 'upstream',
                },
                'location_map': {
                    'entity_id': 'query',
                    'platform_id': 'query',
                    'platform_type': 'query',
                    'entity_type': 'query',
                    'report_type': 'query',
                    'level': 'query',
                    'limit': 'query',
                    'offset': 'query',
                    'local_timezone': 'query',
                    'upstream': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_jobs_users_api_v1_jobs_users_post_endpoint = _Endpoint(
            settings={
                'response_type': ([DataPlatformJobStepUser],),
                'auth': [],
                'endpoint_path': '/api/v1/jobs/users',
                'operation_id': 'get_jobs_users_api_v1_jobs_users_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                    'data_entity_usage_stats_request',
                    'limit',
                    'offset',
                ],
                'required': [
                    'platform_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                    'data_entity_usage_stats_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        ([str],),
                    'entity_type':
                        ([str],),
                    'start_timestamp':
                        (datetime,),
                    'end_timestamp':
                        (datetime,),
                    'data_entity_usage_stats_request':
                        (DataEntityUsageStatsRequest,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_type': 'entityType',
                    'start_timestamp': 'startTimestamp',
                    'end_timestamp': 'endTimestamp',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_type': 'query',
                    'start_timestamp': 'query',
                    'end_timestamp': 'query',
                    'data_entity_usage_stats_request': 'body',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                    'platform_id': 'multi',
                    'entity_type': 'multi',
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_last_job_query_api_v1_job_query_post_endpoint = _Endpoint(
            settings={
                'response_type': (JobQueryV1Response,),
                'auth': [],
                'endpoint_path': '/api/v1/job/query',
                'operation_id': 'get_last_job_query_api_v1_job_query_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'job_query_request',
                ],
                'required': [
                    'job_query_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'job_query_request':
                        (JobQueryRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'job_query_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_lineage_job_steps_api_v1_lineage_jobs_steps_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataPlatformJobStep],),
                'auth': [],
                'endpoint_path': '/api/v1/lineage/jobs/steps',
                'operation_id': 'get_lineage_job_steps_api_v1_lineage_jobs_steps_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'from_entity_id',
                    'from_entity_type',
                    'from_entity_platform_id',
                    'to_entity_id',
                    'to_entity_type',
                    'to_entity_platform_id',
                ],
                'required': [
                    'from_entity_id',
                    'from_entity_type',
                    'from_entity_platform_id',
                    'to_entity_id',
                    'to_entity_type',
                    'to_entity_platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'from_entity_id':
                        (str,),
                    'from_entity_type':
                        (str,),
                    'from_entity_platform_id':
                        (str,),
                    'to_entity_id':
                        (str,),
                    'to_entity_type':
                        (str,),
                    'to_entity_platform_id':
                        (str,),
                },
                'attribute_map': {
                    'from_entity_id': 'fromEntityId',
                    'from_entity_type': 'fromEntityType',
                    'from_entity_platform_id': 'fromEntityPlatformId',
                    'to_entity_id': 'toEntityId',
                    'to_entity_type': 'toEntityType',
                    'to_entity_platform_id': 'toEntityPlatformId',
                },
                'location_map': {
                    'from_entity_id': 'query',
                    'from_entity_type': 'query',
                    'from_entity_platform_id': 'query',
                    'to_entity_id': 'query',
                    'to_entity_type': 'query',
                    'to_entity_platform_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_looker_platform_api_v1_platforms_looker_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformLookerCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/looker/{platform_id}',
                'operation_id': 'get_looker_platform_api_v1_platforms_looker_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_mode_platform_api_v1_platforms_mode_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformModeCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/mode/{platform_id}',
                'operation_id': 'get_mode_platform_api_v1_platforms_mode_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_mssql_platform_api_v1_platforms_mssql_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformMSSQLCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/mssql/{platform_id}',
                'operation_id': 'get_mssql_platform_api_v1_platforms_mssql_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_mysql_platform_api_v1_platforms_mysql_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformMySQLCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/mysql/{platform_id}',
                'operation_id': 'get_mysql_platform_api_v1_platforms_mysql_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_notifications_api_v1_notifications_get_endpoint = _Endpoint(
            settings={
                'response_type': ([Notification],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/notifications',
                'operation_id': 'get_notifications_api_v1_notifications_get',
                'http_method': 'GET',
                '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
        )
        self.get_parent_taxonomy_classifications_api_v1_taxonomy_parents_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataTaxonomyClassification],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/taxonomy/parents',
                'operation_id': 'get_parent_taxonomy_classifications_api_v1_taxonomy_parents_get',
                'http_method': 'GET',
                '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
        )
        self.get_platform_api_v1_platforms_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/{platform_id}',
                'operation_id': 'get_platform_api_v1_platforms_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_platforms_api_v1_platforms_get_endpoint = _Endpoint(
            settings={
                'response_type': ([DataPlatformGet],),
                'auth': [],
                'endpoint_path': '/api/v1/platforms',
                'operation_id': 'get_platforms_api_v1_platforms_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_classification',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_classification':
                        (PlatformClassification,),
                },
                'attribute_map': {
                    'platform_classification': 'platform_classification',
                },
                'location_map': {
                    'platform_classification': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_popular_user_entities_api_v2_user_entities_popular_get_endpoint = _Endpoint(
            settings={
                'response_type': ([UserActivityResponse],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/user/entities/popular',
                'operation_id': 'get_popular_user_entities_api_v2_user_entities_popular_get',
                'http_method': 'GET',
                '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
        )
        self.get_postgres_platform_api_v1_platforms_postgres_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformPostgresCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/postgres/{platform_id}',
                'operation_id': 'get_postgres_platform_api_v1_platforms_postgres_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_powerbi_platform_api_v1_platforms_powerbi_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformPowerBICreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/powerbi/{platform_id}',
                'operation_id': 'get_powerbi_platform_api_v1_platforms_powerbi_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_recent_user_entities_api_v2_user_entities_recent_get_endpoint = _Endpoint(
            settings={
                'response_type': ([UserActivityResponse],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/user/entities/recent',
                'operation_id': 'get_recent_user_entities_api_v2_user_entities_recent_get',
                'http_method': 'GET',
                '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
        )
        self.get_redshift_platform_api_v1_platforms_redshift_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformRedshiftCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/redshift/{platform_id}',
                'operation_id': 'get_redshift_platform_api_v1_platforms_redshift_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_snowflake_platform_api_v1_platforms_snowflake_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformSnowflakeCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/snowflake/{platform_id}',
                'operation_id': 'get_snowflake_platform_api_v1_platforms_snowflake_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_tableau_platform_api_v1_platforms_tableau_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformTableauCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/tableau/{platform_id}',
                'operation_id': 'get_tableau_platform_api_v1_platforms_tableau_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_tag_rules_api_v1_tags_rules_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataTagRuleGet,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/tags/rules',
                'operation_id': 'get_tag_rules_api_v1_tags_rules_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'tag_name',
                    'tag_domain',
                ],
                'required': [
                    'tag_name',
                    'tag_domain',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'tag_name':
                        (str,),
                    'tag_domain':
                        (str,),
                },
                'attribute_map': {
                    'tag_name': 'tagName',
                    'tag_domain': 'tagDomain',
                },
                'location_map': {
                    'tag_name': 'query',
                    'tag_domain': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_tags_api_v1_tags_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataTagGet,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/tags',
                'operation_id': 'get_tags_api_v1_tags_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_tag_type',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_tag_type':
                        (DataTagType,),
                },
                'attribute_map': {
                    'data_tag_type': 'dataTagType',
                },
                'location_map': {
                    'data_tag_type': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_tags_api_v2_tags_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataTagGet,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/tags',
                'operation_id': 'get_tags_api_v2_tags_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_tag_type',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_tag_type':
                        (DataTagType,),
                },
                'attribute_map': {
                    'data_tag_type': 'dataTagType',
                },
                'location_map': {
                    'data_tag_type': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_top_level_entities_api_v1_top_entities_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityGet,),
                'auth': [],
                'endpoint_path': '/api/v1/top-entities',
                'operation_id': 'get_top_level_entities_api_v1_top_entities_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'limit',
                    'offset',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'platform_id': 'query',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_top_level_entities_by_platform_api_v1_top_entities_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/top-entities/{platformId}',
                'operation_id': 'get_top_level_entities_by_platform_api_v1_top_entities_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_treasuredata_platform_api_v1_platforms_treasuredata_platform_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformTreasureDataCreate,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/treasuredata/{platform_id}',
                'operation_id': 'get_treasuredata_platform_api_v1_platforms_treasuredata_platform_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_user_id_api_v1_user_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (str,),
                'auth': [],
                'endpoint_path': '/api/v1/user/id',
                'operation_id': 'get_user_id_api_v1_user_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'user_email',
                ],
                'required': [
                    'user_email',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'user_email':
                        (str,),
                },
                'attribute_map': {
                    'user_email': 'userEmail',
                },
                'location_map': {
                    'user_email': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_user_info_api_v1_me_get_endpoint = _Endpoint(
            settings={
                'response_type': (UserGet,),
                'auth': [],
                'endpoint_path': '/api/v1/me',
                'operation_id': 'get_user_info_api_v1_me_get',
                'http_method': 'GET',
                '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
        )
        self.get_user_info_api_v1_organization_get_endpoint = _Endpoint(
            settings={
                'response_type': (OrganizationGet,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/organization',
                'operation_id': 'get_user_info_api_v1_organization_get',
                'http_method': 'GET',
                '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
        )
        self.get_user_invite_by_link_id_api_v2_users_invite_link_id_get_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v2/users/invite/{link_id}',
                'operation_id': 'get_user_invite_by_link_id_api_v2_users_invite_link_id_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'link_id',
                ],
                'required': [
                    'link_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'link_id':
                        (str,),
                },
                'attribute_map': {
                    'link_id': 'link_id',
                },
                'location_map': {
                    'link_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_user_popular_searches_api_v2_user_search_popular_get_endpoint = _Endpoint(
            settings={
                'response_type': ([UserActivityResponse],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/user/search/popular',
                'operation_id': 'get_user_popular_searches_api_v2_user_search_popular_get',
                'http_method': 'GET',
                '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
        )
        self.get_user_recent_searches_api_v2_user_search_recent_get_endpoint = _Endpoint(
            settings={
                'response_type': ([UserActivityResponse],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/user/search/recent',
                'operation_id': 'get_user_recent_searches_api_v2_user_search_recent_get',
                'http_method': 'GET',
                '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
        )
        self.get_users_by_id_api_v1_users_get_endpoint = _Endpoint(
            settings={
                'response_type': ({str: (UserGet,)},),
                'auth': [],
                'endpoint_path': '/api/v1/users',
                'operation_id': 'get_users_by_id_api_v1_users_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'user_ids',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'user_ids':
                        ([str],),
                },
                'attribute_map': {
                    'user_ids': 'userIds',
                },
                'location_map': {
                    'user_ids': 'query',
                },
                'collection_format_map': {
                    'user_ids': 'multi',
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_users_in_org_api_v1_org_users_get_endpoint = _Endpoint(
            settings={
                'response_type': ({str: (UserGet,)},),
                'auth': [],
                'endpoint_path': '/api/v1/org-users',
                'operation_id': 'get_users_in_org_api_v1_org_users_get',
                'http_method': 'GET',
                '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
        )
        self.healthcheck_health_get_endpoint = _Endpoint(
            settings={
                'response_type': (HealthcheckResponse,),
                'auth': [],
                'endpoint_path': '/health',
                'operation_id': 'healthcheck_health_get',
                'http_method': 'GET',
                '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
        )
        self.invite_user_to_org_api_v2_users_invite_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/users/invite',
                'operation_id': 'invite_user_to_org_api_v2_users_invite_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'user_create_request',
                ],
                'required': [
                    'user_create_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'user_create_request':
                        (UserCreateRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'user_create_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.lineage_api_v1_lineage_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/lineage',
                'operation_id': 'lineage_api_v1_lineage_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'unknown_base_type',
                ],
                'required': [
                    'unknown_base_type',
                ],
                'nullable': [
                    'unknown_base_type',
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'unknown_base_type':
                        (),
                },
                'attribute_map': {
                },
                'location_map': {
                    'unknown_base_type': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.lineage_spark_api_v1_lineage_spark_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/lineage/spark',
                'operation_id': 'lineage_spark_api_v1_lineage_spark_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'unknown_base_type',
                ],
                'required': [
                    'unknown_base_type',
                ],
                'nullable': [
                    'unknown_base_type',
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'unknown_base_type':
                        (),
                },
                'attribute_map': {
                },
                'location_map': {
                    'unknown_base_type': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.list_manual_lineage_api_v1_lineage_manual_get_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageManualLineageData,),
                'auth': [],
                'endpoint_path': '/api/v1/lineage/manual',
                'operation_id': 'list_manual_lineage_api_v1_lineage_manual_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'limit',
                    'offset',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_manual_lineage_valid_entity_types_api_v1_lineage_manual_valid_entity_types_get_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/lineage/manual/valid_entity_types',
                'operation_id': 'list_manual_lineage_valid_entity_types_api_v1_lineage_manual_valid_entity_types_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'manual_lineage_entity_type_validation',
                ],
                'required': [
                    'manual_lineage_entity_type_validation',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'manual_lineage_entity_type_validation':
                        (ManualLineageEntityTypeValidation,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'manual_lineage_entity_type_validation': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.list_saved_search_nodes_filter_api_v2_saved_search_nodes_get_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/saved_search/nodes',
                'operation_id': 'list_saved_search_nodes_filter_api_v2_saved_search_nodes_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'limit',
                    'offset',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_saved_search_string_filter_api_v2_saved_search_string_get_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/saved_search/string',
                'operation_id': 'list_saved_search_string_filter_api_v2_saved_search_string_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'limit',
                    'offset',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_users_in_org_api_v2_users_get_endpoint = _Endpoint(
            settings={
                'response_type': ([UserGet],),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/users',
                'operation_id': 'list_users_in_org_api_v2_users_get',
                'http_method': 'GET',
                '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
        )
        self.metadata_api_v1_metadata_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/metadata',
                'operation_id': 'metadata_api_v1_metadata_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'unknown_base_type',
                ],
                'required': [
                    'unknown_base_type',
                ],
                'nullable': [
                    'unknown_base_type',
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'unknown_base_type':
                        (),
                },
                'attribute_map': {
                },
                'location_map': {
                    'unknown_base_type': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.register_interest_api_v1_experiences_register_interest_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/experiences/register-interest',
                'operation_id': 'register_interest_api_v1_experiences_register_interest_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'experience_data',
                ],
                'required': [
                    'experience_data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'experience_data':
                        (ExperienceData,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'experience_data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.remove_user_from_org_api_v2_user_delete_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/user',
                'operation_id': 'remove_user_from_org_api_v2_user_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'user_id',
                ],
                'required': [
                    'user_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'user_id':
                        (str,),
                },
                'attribute_map': {
                    'user_id': 'user_id',
                },
                'location_map': {
                    'user_id': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.request_access_api_v1_experiences_request_access_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/experiences/request-access',
                'operation_id': 'request_access_api_v1_experiences_request_access_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'experience_data',
                ],
                'required': [
                    'experience_data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'experience_data':
                        (ExperienceData,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'experience_data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.run_impact_node_query_api_v2_impact_analysis_query_string_nodes_post_endpoint = _Endpoint(
            settings={
                'response_type': (ImpactAnalysisNodeListResponse,),
                'auth': [],
                'endpoint_path': '/api/v2/impact-analysis/query-string-nodes',
                'operation_id': 'run_impact_node_query_api_v2_impact_analysis_query_string_nodes_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'impact_analysis_request',
                ],
                'required': [
                    'impact_analysis_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'impact_analysis_request':
                        (ImpactAnalysisRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'impact_analysis_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.run_validated_impact_node_query_api_v2_impact_analysis_query_nodes_post_endpoint = _Endpoint(
            settings={
                'response_type': (ImpactAnalysisNodeListResponse,),
                'auth': [],
                'endpoint_path': '/api/v2/impact-analysis/query-nodes',
                'operation_id': 'run_validated_impact_node_query_api_v2_impact_analysis_query_nodes_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'impact_analysis_validation_payload',
                ],
                'required': [
                    'impact_analysis_validation_payload',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'impact_analysis_validation_payload':
                        (ImpactAnalysisValidationPayload,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'impact_analysis_validation_payload': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.save_tag_api_v1_tags_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/tags',
                'operation_id': 'save_tag_api_v1_tags_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_tag_request',
                ],
                'required': [
                    'data_tag_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_tag_request':
                        (DataTagRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_tag_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.save_tag_category_api_v2_tags_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/tags',
                'operation_id': 'save_tag_category_api_v2_tags_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_tag_request_v2',
                ],
                'required': [
                    'data_tag_request_v2',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_tag_request_v2':
                        (DataTagRequestV2,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_tag_request_v2': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.save_tags_entity_connections_api_v1_entity_tags_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/entity/tags',
                'operation_id': 'save_tags_entity_connections_api_v1_entity_tags_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_entity_save_tag_connection_request',
                ],
                'required': [
                    'data_entity_save_tag_connection_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_entity_save_tag_connection_request':
                        ([DataEntitySaveTagConnectionRequest],),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_entity_save_tag_connection_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.saved_search_nodes_filter_api_v2_saved_search_nodes_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/saved_search/nodes',
                'operation_id': 'saved_search_nodes_filter_api_v2_saved_search_nodes_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'save_search_filter',
                ],
                'required': [
                    'save_search_filter',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'save_search_filter':
                        (SaveSearchFilter,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'save_search_filter': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.saved_search_string_filter_api_v2_saved_search_string_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/saved_search/string',
                'operation_id': 'saved_search_string_filter_api_v2_saved_search_string_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'save_search_string_filter',
                ],
                'required': [
                    'save_search_string_filter',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'save_search_string_filter':
                        (SaveSearchStringFilter,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'save_search_string_filter': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.search_api_v2_search_all_post_endpoint = _Endpoint(
            settings={
                'response_type': (SearchV2Response,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/search/all',
                'operation_id': 'search_api_v2_search_all_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'search_string',
                    'page',
                    'size',
                    'search_node',
                ],
                'required': [
                    'search_string',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'page',
                    'size',
                ]
            },
            root_map={
                'validations': {
                    ('page',): {

                        'inclusive_minimum': 1,
                    },
                    ('size',): {

                        'inclusive_maximum': 100,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'search_string':
                        (str,),
                    'page':
                        (int,),
                    'size':
                        (int,),
                    'search_node':
                        ([SearchNode],),
                },
                'attribute_map': {
                    'search_string': 'search_string',
                    'page': 'page',
                    'size': 'size',
                },
                'location_map': {
                    'search_string': 'query',
                    'page': 'query',
                    'size': 'query',
                    'search_node': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.search_entities_api_v2_search_get_endpoint = _Endpoint(
            settings={
                'response_type': (SearchV2Response,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/search',
                'operation_id': 'search_entities_api_v2_search_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'search_string',
                    'page',
                    'size',
                ],
                'required': [
                    'search_string',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'page',
                    'size',
                ]
            },
            root_map={
                'validations': {
                    ('page',): {

                        'inclusive_minimum': 1,
                    },
                    ('size',): {

                        'inclusive_maximum': 100,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'search_string':
                        (str,),
                    'page':
                        (int,),
                    'size':
                        (int,),
                },
                'attribute_map': {
                    'search_string': 'search_string',
                    'page': 'page',
                    'size': 'size',
                },
                'location_map': {
                    'search_string': 'query',
                    'page': 'query',
                    'size': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.search_entities_stats_post_api_v1_search_entities_usage_stats_post_endpoint = _Endpoint(
            settings={
                'response_type': (LimitOffsetPageDataEntityUsageStatsReport,),
                'auth': [],
                'endpoint_path': '/api/v1/search/entities/usage-stats',
                'operation_id': 'search_entities_stats_post_api_v1_search_entities_usage_stats_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                    'data_entity_usage_stats_request',
                    'limit',
                    'offset',
                    'sort',
                ],
                'required': [
                    'platform_id',
                    'entity_type',
                    'start_timestamp',
                    'end_timestamp',
                    'data_entity_usage_stats_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'limit',
                    'sort',
                ]
            },
            root_map={
                'validations': {
                    ('limit',): {

                        'inclusive_maximum': 1000,
                        'inclusive_minimum': 1,
                    },
                    ('sort',): {

                        'regex': {
                            'pattern': r'^[\w: ]*$',  # noqa: E501
                        },
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        ([str],),
                    'entity_type':
                        ([str],),
                    'start_timestamp':
                        (datetime,),
                    'end_timestamp':
                        (datetime,),
                    'data_entity_usage_stats_request':
                        (DataEntityUsageStatsRequest,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                    'sort':
                        ([str],),
                },
                'attribute_map': {
                    'platform_id': 'platformId',
                    'entity_type': 'entityType',
                    'start_timestamp': 'startTimestamp',
                    'end_timestamp': 'endTimestamp',
                    'limit': 'limit',
                    'offset': 'offset',
                    'sort': 'sort',
                },
                'location_map': {
                    'platform_id': 'query',
                    'entity_type': 'query',
                    'start_timestamp': 'query',
                    'end_timestamp': 'query',
                    'data_entity_usage_stats_request': 'body',
                    'limit': 'query',
                    'offset': 'query',
                    'sort': 'query',
                },
                'collection_format_map': {
                    'platform_id': 'multi',
                    'entity_type': 'multi',
                    'sort': 'multi',
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.search_with_nodes_api_v2_search_nodes_post_endpoint = _Endpoint(
            settings={
                'response_type': (SearchV2Response,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/search_nodes',
                'operation_id': 'search_with_nodes_api_v2_search_nodes_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'page',
                    'size',
                    'search_node',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                    'page',
                    'size',
                ]
            },
            root_map={
                'validations': {
                    ('page',): {

                        'inclusive_minimum': 1,
                    },
                    ('size',): {

                        'inclusive_maximum': 100,
                        'inclusive_minimum': 1,
                    },
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'page':
                        (int,),
                    'size':
                        (int,),
                    'search_node':
                        ([SearchNode],),
                },
                'attribute_map': {
                    'page': 'page',
                    'size': 'size',
                },
                'location_map': {
                    'page': 'query',
                    'size': 'query',
                    'search_node': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.set_org_status_api_v1_organization_status_post_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [],
                'endpoint_path': '/api/v1/organization/status',
                'operation_id': 'set_org_status_api_v1_organization_status_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'status',
                ],
                'required': [
                    'status',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'status':
                        (str,),
                },
                'attribute_map': {
                    'status': 'status',
                },
                'location_map': {
                    'status': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.sync_platform_rpc_api_v1_platforms_platform_id_rpc_sync_get_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformGet,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/{platform_id}/rpc-sync',
                'operation_id': 'sync_platform_rpc_api_v1_platforms_platform_id_rpc_sync_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'platform_id',
                ],
                'required': [
                    'platform_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'platform_id':
                        (str,),
                },
                'attribute_map': {
                    'platform_id': 'platform_id',
                },
                'location_map': {
                    'platform_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.sync_sheet_api_v1_sync_sheet_get_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v1/sync-sheet',
                'operation_id': 'sync_sheet_api_v1_sync_sheet_get',
                'http_method': 'GET',
                '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
        )
        self.test_airflow_platform_api_v1_platforms_airflow_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/airflow-test',
                'operation_id': 'test_airflow_platform_api_v1_platforms_airflow_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_airflow_create',
                ],
                'required': [
                    'data_platform_airflow_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_airflow_create':
                        (DataPlatformAirflowCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_airflow_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_bigquery_platform_api_v1_platforms_bigquery_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/bigquery-test',
                'operation_id': 'test_bigquery_platform_api_v1_platforms_bigquery_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_big_query_create',
                ],
                'required': [
                    'data_platform_big_query_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_big_query_create':
                        (DataPlatformBigQueryCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_big_query_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_databricks_platform_api_v1_platforms_databricks_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/databricks-test',
                'operation_id': 'test_databricks_platform_api_v1_platforms_databricks_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_databricks_create',
                ],
                'required': [
                    'data_platform_databricks_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_databricks_create':
                        (DataPlatformDatabricksCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_databricks_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_hive_platform_api_v1_platforms_hive_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/hive-test',
                'operation_id': 'test_hive_platform_api_v1_platforms_hive_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_hive_create',
                ],
                'required': [
                    'data_platform_hive_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_hive_create':
                        (DataPlatformHiveCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_hive_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_hiveglue_platform_api_v1_platforms_hiveglue_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/hiveglue-test',
                'operation_id': 'test_hiveglue_platform_api_v1_platforms_hiveglue_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_hive_glue_create',
                ],
                'required': [
                    'data_platform_hive_glue_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_hive_glue_create':
                        (DataPlatformHiveGlueCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_hive_glue_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_looker_platform_api_v1_platforms_looker_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/looker-test',
                'operation_id': 'test_looker_platform_api_v1_platforms_looker_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_looker_create',
                ],
                'required': [
                    'data_platform_looker_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_looker_create':
                        (DataPlatformLookerCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_looker_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_mode_platform_api_v1_platforms_mode_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/mode-test',
                'operation_id': 'test_mode_platform_api_v1_platforms_mode_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_mode_create',
                ],
                'required': [
                    'data_platform_mode_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_mode_create':
                        (DataPlatformModeCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_mode_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_mssql_platform_api_v1_platforms_mssql_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/mssql-test',
                'operation_id': 'test_mssql_platform_api_v1_platforms_mssql_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_mssql_create',
                ],
                'required': [
                    'data_platform_mssql_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_mssql_create':
                        (DataPlatformMSSQLCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_mssql_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_mysql_platform_api_v1_platforms_mysql_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/mysql-test',
                'operation_id': 'test_mysql_platform_api_v1_platforms_mysql_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_my_sql_create',
                ],
                'required': [
                    'data_platform_my_sql_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_my_sql_create':
                        (DataPlatformMySQLCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_my_sql_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_postgres_platform_api_v1_platforms_postgres_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/postgres-test',
                'operation_id': 'test_postgres_platform_api_v1_platforms_postgres_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_postgres_create',
                ],
                'required': [
                    'data_platform_postgres_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_postgres_create':
                        (DataPlatformPostgresCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_postgres_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_powerbi_platform_api_v1_platforms_powerbi_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/powerbi-test',
                'operation_id': 'test_powerbi_platform_api_v1_platforms_powerbi_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_power_bi_create',
                ],
                'required': [
                    'data_platform_power_bi_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_power_bi_create':
                        (DataPlatformPowerBICreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_power_bi_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_redshift_platform_api_v1_platforms_redshift_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/redshift-test',
                'operation_id': 'test_redshift_platform_api_v1_platforms_redshift_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_redshift_create',
                ],
                'required': [
                    'data_platform_redshift_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_redshift_create':
                        (DataPlatformRedshiftCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_redshift_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_snowflake_platform_api_v1_platforms_snowflake_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/snowflake-test',
                'operation_id': 'test_snowflake_platform_api_v1_platforms_snowflake_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_snowflake_create',
                ],
                'required': [
                    'data_platform_snowflake_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_snowflake_create':
                        (DataPlatformSnowflakeCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_snowflake_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_tableau_platform_api_v1_platforms_tableau_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/tableau-test',
                'operation_id': 'test_tableau_platform_api_v1_platforms_tableau_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_tableau_create',
                ],
                'required': [
                    'data_platform_tableau_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_tableau_create':
                        (DataPlatformTableauCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_tableau_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.test_treasuredata_platform_api_v1_platforms_treasuredata_test_post_endpoint = _Endpoint(
            settings={
                'response_type': (DataPlatformFull,),
                'auth': [],
                'endpoint_path': '/api/v1/platforms/treasuredata-test',
                'operation_id': 'test_treasuredata_platform_api_v1_platforms_treasuredata_test_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data_platform_treasure_data_create',
                ],
                'required': [
                    'data_platform_treasure_data_create',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data_platform_treasure_data_create':
                        (DataPlatformTreasureDataCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data_platform_treasure_data_create': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.tinyurl_api_v1_tinyurl_get_endpoint = _Endpoint(
            settings={
                'response_type': (TinyURLResponse,),
                'auth': [],
                'endpoint_path': '/api/v1/tinyurl',
                'operation_id': 'tinyurl_api_v1_tinyurl_get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'code',
                ],
                'required': [
                    'code',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'code':
                        (str,),
                },
                'attribute_map': {
                    'code': 'code',
                },
                'location_map': {
                    'code': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.update_invite_to_organization_status_api_v2_users_invite_put_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/users/invite',
                'operation_id': 'update_invite_to_organization_status_api_v2_users_invite_put',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'invite_id',
                    'status',
                ],
                'required': [
                    'invite_id',
                    'status',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'invite_id':
                        (str,),
                    'status':
                        (str,),
                },
                'attribute_map': {
                    'invite_id': 'invite_id',
                    'status': 'status',
                },
                'location_map': {
                    'invite_id': 'query',
                    'status': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.update_user_in_org_api_v2_user_put_endpoint = _Endpoint(
            settings={
                'response_type': (bool, date, datetime, dict, float, int, list, str, none_type,),
                'auth': [
                    'HTTPBearer'
                ],
                'endpoint_path': '/api/v2/user',
                'operation_id': 'update_user_in_org_api_v2_user_put',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'user_create_request',
                ],
                'required': [
                    'user_create_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'user_create_request':
                        (UserCreateRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'user_create_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.validate_impact_analysis_query_api_v2_impact_analysis_validate_query_post_endpoint = _Endpoint(
            settings={
                'response_type': (ImpactAnalysisQueryValidation,),
                'auth': [],
                'endpoint_path': '/api/v2/impact-analysis/validate-query',
                'operation_id': 'validate_impact_analysis_query_api_v2_impact_analysis_validate_query_post',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'impact_analysis_request',
                ],
                'required': [
                    'impact_analysis_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'impact_analysis_request':
                        (ImpactAnalysisRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'impact_analysis_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )

    def accept_invite_to_organization_api_v2_users_accept_invite_put(
        self,
        accept_invite_request,
        **kwargs
    ):
        """Accept Invite To Organization  # noqa: E501

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

        >>> thread = api.accept_invite_to_organization_api_v2_users_accept_invite_put(accept_invite_request, async_req=True)
        >>> result = thread.get()

        Args:
            accept_invite_request (AcceptInviteRequest):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['accept_invite_request'] = \
            accept_invite_request
        return self.accept_invite_to_organization_api_v2_users_accept_invite_put_endpoint.call_with_http_info(**kwargs)

    def add_manual_lineage_api_v1_lineage_manual_post(
        self,
        manual_lineage_data_request,
        **kwargs
    ):
        """Add Manual Lineage  # 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_manual_lineage_api_v1_lineage_manual_post(manual_lineage_data_request, async_req=True)
        >>> result = thread.get()

        Args:
            manual_lineage_data_request (ManualLineageDataRequest):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['manual_lineage_data_request'] = \
            manual_lineage_data_request
        return self.add_manual_lineage_api_v1_lineage_manual_post_endpoint.call_with_http_info(**kwargs)

    def add_user_stat_api_v2_user_analytics_add_post(
        self,
        **kwargs
    ):
        """Add User Stat  # 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_user_stat_api_v2_user_analytics_add_post(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            user_activity_request (UserActivityRequest): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        return self.add_user_stat_api_v2_user_analytics_add_post_endpoint.call_with_http_info(**kwargs)

    def add_users_to_org_api_v2_users_post(
        self,
        user_create_request,
        **kwargs
    ):
        """Add Users To Org  # 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_users_to_org_api_v2_users_post(user_create_request, async_req=True)
        >>> result = thread.get()

        Args:
            user_create_request (UserCreateRequest):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['user_create_request'] = \
            user_create_request
        return self.add_users_to_org_api_v2_users_post_endpoint.call_with_http_info(**kwargs)

    def bulk_apply_api_v1_tags_bulk_apply_post(
        self,
        data_tag_bulk_apply,
        **kwargs
    ):
        """Bulk Apply  # noqa: E501

        Bulk apply tags to entities based on rule type and rule text  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.bulk_apply_api_v1_tags_bulk_apply_post(data_tag_bulk_apply, async_req=True)
        >>> result = thread.get()

        Args:
            data_tag_bulk_apply (DataTagBulkApply):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['data_tag_bulk_apply'] = \
            data_tag_bulk_apply
        return self.bulk_apply_api_v1_tags_bulk_apply_post_endpoint.call_with_http_info(**kwargs)

    def bulk_delete_api_v1_tags_bulk_delete_delete(
        self,
        data_tag_bulk_delete,
        **kwargs
    ):
        """Bulk Delete  # noqa: E501

        Bulk delete tags from entities based on rule type and rule text  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.bulk_delete_api_v1_tags_bulk_delete_delete(data_tag_bulk_delete, async_req=True)
        >>> result = thread.get()

        Args:
            data_tag_bulk_delete (DataTagBulkDelete):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['data_tag_bulk_delete'] = \
            data_tag_bulk_delete
        return self.bulk_delete_api_v1_tags_bulk_delete_delete_endpoint.call_with_http_info(**kwargs)

    def clear_platform_api_v1_platforms_platform_id_clear_post(
        self,
        platform_id,
        **kwargs
    ):
        """Clear Platform  # noqa: E501

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

        >>> thread = api.clear_platform_api_v1_platforms_platform_id_clear_post(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformDelete
                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['platform_id'] = \
            platform_id
        return self.clear_platform_api_v1_platforms_platform_id_clear_post_endpoint.call_with_http_info(**kwargs)

    def create_airflow_platform_api_v1_platforms_airflow_post(
        self,
        data_platform_airflow_create,
        **kwargs
    ):
        """Create Airflow Platform  # noqa: E501

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

        >>> thread = api.create_airflow_platform_api_v1_platforms_airflow_post(data_platform_airflow_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_airflow_create (DataPlatformAirflowCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_airflow_create'] = \
            data_platform_airflow_create
        return self.create_airflow_platform_api_v1_platforms_airflow_post_endpoint.call_with_http_info(**kwargs)

    def create_api_key_api_v1_api_key_post(
        self,
        user_organization_api_key_request,
        **kwargs
    ):
        """Create Api Key  # noqa: E501

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

        >>> thread = api.create_api_key_api_v1_api_key_post(user_organization_api_key_request, async_req=True)
        >>> result = thread.get()

        Args:
            user_organization_api_key_request (UserOrganizationAPIKeyRequest):

        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 (int/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:
            UserOrganizationAPIKeyResponse
                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['user_organization_api_key_request'] = \
            user_organization_api_key_request
        return self.create_api_key_api_v1_api_key_post_endpoint.call_with_http_info(**kwargs)

    def create_bigquery_platform_api_v1_platforms_bigquery_post(
        self,
        data_platform_big_query_create,
        **kwargs
    ):
        """Create Bigquery Platform  # noqa: E501

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

        >>> thread = api.create_bigquery_platform_api_v1_platforms_bigquery_post(data_platform_big_query_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_big_query_create (DataPlatformBigQueryCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_big_query_create'] = \
            data_platform_big_query_create
        return self.create_bigquery_platform_api_v1_platforms_bigquery_post_endpoint.call_with_http_info(**kwargs)

    def create_databricks_platform_api_v1_platforms_databricks_post(
        self,
        data_platform_databricks_create,
        **kwargs
    ):
        """Create Databricks Platform  # noqa: E501

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

        >>> thread = api.create_databricks_platform_api_v1_platforms_databricks_post(data_platform_databricks_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_databricks_create (DataPlatformDatabricksCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_databricks_create'] = \
            data_platform_databricks_create
        return self.create_databricks_platform_api_v1_platforms_databricks_post_endpoint.call_with_http_info(**kwargs)

    def create_dbt_platform_api_v1_platforms_dbt_post(
        self,
        data_platform_dbt_create,
        **kwargs
    ):
        """Create Dbt Platform  # noqa: E501

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

        >>> thread = api.create_dbt_platform_api_v1_platforms_dbt_post(data_platform_dbt_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_dbt_create (DataPlatformDBTCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_dbt_create'] = \
            data_platform_dbt_create
        return self.create_dbt_platform_api_v1_platforms_dbt_post_endpoint.call_with_http_info(**kwargs)

    def create_hive_platform_api_v1_platforms_hive_post(
        self,
        data_platform_hive_create,
        **kwargs
    ):
        """Create Hive Platform  # noqa: E501

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

        >>> thread = api.create_hive_platform_api_v1_platforms_hive_post(data_platform_hive_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_hive_create (DataPlatformHiveCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_hive_create'] = \
            data_platform_hive_create
        return self.create_hive_platform_api_v1_platforms_hive_post_endpoint.call_with_http_info(**kwargs)

    def create_hiveglue_platform_api_v1_platforms_hiveglue_post(
        self,
        data_platform_hive_glue_create,
        **kwargs
    ):
        """Create Hiveglue Platform  # noqa: E501

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

        >>> thread = api.create_hiveglue_platform_api_v1_platforms_hiveglue_post(data_platform_hive_glue_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_hive_glue_create (DataPlatformHiveGlueCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_hive_glue_create'] = \
            data_platform_hive_glue_create
        return self.create_hiveglue_platform_api_v1_platforms_hiveglue_post_endpoint.call_with_http_info(**kwargs)

    def create_looker_platform_api_v1_platforms_looker_post(
        self,
        data_platform_looker_create,
        **kwargs
    ):
        """Create Looker Platform  # noqa: E501

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

        >>> thread = api.create_looker_platform_api_v1_platforms_looker_post(data_platform_looker_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_looker_create (DataPlatformLookerCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_looker_create'] = \
            data_platform_looker_create
        return self.create_looker_platform_api_v1_platforms_looker_post_endpoint.call_with_http_info(**kwargs)

    def create_mode_platform_api_v1_platforms_mode_post(
        self,
        data_platform_mode_create,
        **kwargs
    ):
        """Create Mode Platform  # noqa: E501

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

        >>> thread = api.create_mode_platform_api_v1_platforms_mode_post(data_platform_mode_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_mode_create (DataPlatformModeCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_mode_create'] = \
            data_platform_mode_create
        return self.create_mode_platform_api_v1_platforms_mode_post_endpoint.call_with_http_info(**kwargs)

    def create_mssql_platform_api_v1_platforms_mssql_post(
        self,
        data_platform_mssql_create,
        **kwargs
    ):
        """Create Mssql Platform  # noqa: E501

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

        >>> thread = api.create_mssql_platform_api_v1_platforms_mssql_post(data_platform_mssql_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_mssql_create (DataPlatformMSSQLCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_mssql_create'] = \
            data_platform_mssql_create
        return self.create_mssql_platform_api_v1_platforms_mssql_post_endpoint.call_with_http_info(**kwargs)

    def create_mysql_platform_api_v1_platforms_mysql_post(
        self,
        data_platform_my_sql_create,
        **kwargs
    ):
        """Create Mysql Platform  # noqa: E501

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

        >>> thread = api.create_mysql_platform_api_v1_platforms_mysql_post(data_platform_my_sql_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_my_sql_create (DataPlatformMySQLCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_my_sql_create'] = \
            data_platform_my_sql_create
        return self.create_mysql_platform_api_v1_platforms_mysql_post_endpoint.call_with_http_info(**kwargs)

    def create_postgres_platform_api_v1_platforms_postgres_post(
        self,
        data_platform_postgres_create,
        **kwargs
    ):
        """Create Postgres Platform  # noqa: E501

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

        >>> thread = api.create_postgres_platform_api_v1_platforms_postgres_post(data_platform_postgres_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_postgres_create (DataPlatformPostgresCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_postgres_create'] = \
            data_platform_postgres_create
        return self.create_postgres_platform_api_v1_platforms_postgres_post_endpoint.call_with_http_info(**kwargs)

    def create_powerbi_platform_api_v1_platforms_powerbi_post(
        self,
        data_platform_power_bi_create,
        **kwargs
    ):
        """Create Powerbi Platform  # noqa: E501

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

        >>> thread = api.create_powerbi_platform_api_v1_platforms_powerbi_post(data_platform_power_bi_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_power_bi_create (DataPlatformPowerBICreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_power_bi_create'] = \
            data_platform_power_bi_create
        return self.create_powerbi_platform_api_v1_platforms_powerbi_post_endpoint.call_with_http_info(**kwargs)

    def create_redshift_platform_api_v1_platforms_redshift_post(
        self,
        data_platform_redshift_create,
        **kwargs
    ):
        """Create Redshift Platform  # noqa: E501

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

        >>> thread = api.create_redshift_platform_api_v1_platforms_redshift_post(data_platform_redshift_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_redshift_create (DataPlatformRedshiftCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_redshift_create'] = \
            data_platform_redshift_create
        return self.create_redshift_platform_api_v1_platforms_redshift_post_endpoint.call_with_http_info(**kwargs)

    def create_snowflake_platform_api_v1_platforms_snowflake_post(
        self,
        data_platform_snowflake_create,
        **kwargs
    ):
        """Create Snowflake Platform  # noqa: E501

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

        >>> thread = api.create_snowflake_platform_api_v1_platforms_snowflake_post(data_platform_snowflake_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_snowflake_create (DataPlatformSnowflakeCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_snowflake_create'] = \
            data_platform_snowflake_create
        return self.create_snowflake_platform_api_v1_platforms_snowflake_post_endpoint.call_with_http_info(**kwargs)

    def create_tableau_platform_api_v1_platforms_tableau_post(
        self,
        data_platform_tableau_create,
        **kwargs
    ):
        """Create Tableau Platform  # noqa: E501

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

        >>> thread = api.create_tableau_platform_api_v1_platforms_tableau_post(data_platform_tableau_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_tableau_create (DataPlatformTableauCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_tableau_create'] = \
            data_platform_tableau_create
        return self.create_tableau_platform_api_v1_platforms_tableau_post_endpoint.call_with_http_info(**kwargs)

    def create_treasuredata_platform_api_v1_platforms_treasuredata_post(
        self,
        data_platform_treasure_data_create,
        **kwargs
    ):
        """Create Treasuredata Platform  # noqa: E501

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

        >>> thread = api.create_treasuredata_platform_api_v1_platforms_treasuredata_post(data_platform_treasure_data_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_treasure_data_create (DataPlatformTreasureDataCreate):

        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 (int/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:
            DataPlatformGet
                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['data_platform_treasure_data_create'] = \
            data_platform_treasure_data_create
        return self.create_treasuredata_platform_api_v1_platforms_treasuredata_post_endpoint.call_with_http_info(**kwargs)

    def create_update_entity_description_api_v1_entity_alvin_description_post(
        self,
        alvin_description_request,
        **kwargs
    ):
        """Create Update Entity Description  # noqa: E501

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

        >>> thread = api.create_update_entity_description_api_v1_entity_alvin_description_post(alvin_description_request, async_req=True)
        >>> result = thread.get()

        Args:
            alvin_description_request (AlvinDescriptionRequest):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['alvin_description_request'] = \
            alvin_description_request
        return self.create_update_entity_description_api_v1_entity_alvin_description_post_endpoint.call_with_http_info(**kwargs)

    def create_update_entity_links_api_v1_entity_links_post(
        self,
        links_request,
        **kwargs
    ):
        """Create Update Entity Links  # noqa: E501

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

        >>> thread = api.create_update_entity_links_api_v1_entity_links_post(links_request, async_req=True)
        >>> result = thread.get()

        Args:
            links_request (LinksRequest):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['links_request'] = \
            links_request
        return self.create_update_entity_links_api_v1_entity_links_post_endpoint.call_with_http_info(**kwargs)

    def delete_api_key_api_v1_api_keys_api_key_prefix_delete(
        self,
        api_key_prefix,
        **kwargs
    ):
        """Delete Api Key  # 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_api_key_api_v1_api_keys_api_key_prefix_delete(api_key_prefix, async_req=True)
        >>> result = thread.get()

        Args:
            api_key_prefix (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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['api_key_prefix'] = \
            api_key_prefix
        return self.delete_api_key_api_v1_api_keys_api_key_prefix_delete_endpoint.call_with_http_info(**kwargs)

    def delete_manual_lineage_api_v1_lineage_manual_delete(
        self,
        manual_lineage_data_request,
        **kwargs
    ):
        """Delete Manual Lineage  # 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_manual_lineage_api_v1_lineage_manual_delete(manual_lineage_data_request, async_req=True)
        >>> result = thread.get()

        Args:
            manual_lineage_data_request (ManualLineageDataRequest):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['manual_lineage_data_request'] = \
            manual_lineage_data_request
        return self.delete_manual_lineage_api_v1_lineage_manual_delete_endpoint.call_with_http_info(**kwargs)

    def delete_platform_api_v1_platforms_platform_id_delete(
        self,
        platform_id,
        **kwargs
    ):
        """Delete Platform  # 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_platform_api_v1_platforms_platform_id_delete(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformDelete
                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['platform_id'] = \
            platform_id
        return self.delete_platform_api_v1_platforms_platform_id_delete_endpoint.call_with_http_info(**kwargs)

    def delete_saved_search_filter_api_v2_saved_search_delete(
        self,
        search_name,
        **kwargs
    ):
        """Delete Saved Search Filter  # noqa: E501

        Delete saved search filters based on search_name, this will delete both the string and node based filters base  # 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_saved_search_filter_api_v2_saved_search_delete(search_name, async_req=True)
        >>> result = thread.get()

        Args:
            search_name (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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['search_name'] = \
            search_name
        return self.delete_saved_search_filter_api_v2_saved_search_delete_endpoint.call_with_http_info(**kwargs)

    def delete_tag_rules_api_v1_tags_rules_delete(
        self,
        data_tag_rules_request_delete,
        **kwargs
    ):
        """Delete Tag Rules  # 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_tag_rules_api_v1_tags_rules_delete(data_tag_rules_request_delete, async_req=True)
        >>> result = thread.get()

        Args:
            data_tag_rules_request_delete (DataTagRulesRequestDelete):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['data_tag_rules_request_delete'] = \
            data_tag_rules_request_delete
        return self.delete_tag_rules_api_v1_tags_rules_delete_endpoint.call_with_http_info(**kwargs)

    def delete_tags_api_v1_tags_delete(
        self,
        data_tag_request_delete,
        **kwargs
    ):
        """Delete Tags  # 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_tags_api_v1_tags_delete(data_tag_request_delete, async_req=True)
        >>> result = thread.get()

        Args:
            data_tag_request_delete (DataTagRequestDelete):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['data_tag_request_delete'] = \
            data_tag_request_delete
        return self.delete_tags_api_v1_tags_delete_endpoint.call_with_http_info(**kwargs)

    def delete_tags_entity_connections_api_v1_entity_tags_delete(
        self,
        data_entity_delete_tag_connection_request,
        **kwargs
    ):
        """Delete Tags Entity Connections  # 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_tags_entity_connections_api_v1_entity_tags_delete(data_entity_delete_tag_connection_request, async_req=True)
        >>> result = thread.get()

        Args:
            data_entity_delete_tag_connection_request ([DataEntityDeleteTagConnectionRequest]):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['data_entity_delete_tag_connection_request'] = \
            data_entity_delete_tag_connection_request
        return self.delete_tags_entity_connections_api_v1_entity_tags_delete_endpoint.call_with_http_info(**kwargs)

    def email_login_api_v1_auth_email_login_post(
        self,
        email_login_request,
        **kwargs
    ):
        """Email 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.email_login_api_v1_auth_email_login_post(email_login_request, async_req=True)
        >>> result = thread.get()

        Args:
            email_login_request (EmailLoginRequest):

        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 (int/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:
            EmailLoginRequest
                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['email_login_request'] = \
            email_login_request
        return self.email_login_api_v1_auth_email_login_post_endpoint.call_with_http_info(**kwargs)

    def exchange_token_api_v1_auth_exchange_token_post(
        self,
        provider_id,
        exchange_token_request,
        **kwargs
    ):
        """Exchange Token  # noqa: E501

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

        >>> thread = api.exchange_token_api_v1_auth_exchange_token_post(provider_id, exchange_token_request, async_req=True)
        >>> result = thread.get()

        Args:
            provider_id (AuthProvider):
            exchange_token_request (ExchangeTokenRequest):

        Keyword Args:
            org_id (str): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            Token
                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['provider_id'] = \
            provider_id
        kwargs['exchange_token_request'] = \
            exchange_token_request
        return self.exchange_token_api_v1_auth_exchange_token_post_endpoint.call_with_http_info(**kwargs)

    def expand_node_children_api_v1_lineage_node_expand_children_post(
        self,
        data_entity_id,
        **kwargs
    ):
        """Expand Node Children  # noqa: E501

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

        >>> thread = api.expand_node_children_api_v1_lineage_node_expand_children_post(data_entity_id, async_req=True)
        >>> result = thread.get()

        Args:
            data_entity_id (DataEntityID):

        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 (int/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:
            ProcessedLineageGraphData
                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['data_entity_id'] = \
            data_entity_id
        return self.expand_node_children_api_v1_lineage_node_expand_children_post_endpoint.call_with_http_info(**kwargs)

    def find_data_entity_dependencies_api_v1_entity_dependency_post(
        self,
        data_entity_id,
        **kwargs
    ):
        """Find Data Entity Dependencies  # noqa: E501

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

        >>> thread = api.find_data_entity_dependencies_api_v1_entity_dependency_post(data_entity_id, async_req=True)
        >>> result = thread.get()

        Args:
            data_entity_id ([DataEntityID]):

        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 (int/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:
            [DataEntityDependencyGet]
                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['data_entity_id'] = \
            data_entity_id
        return self.find_data_entity_dependencies_api_v1_entity_dependency_post_endpoint.call_with_http_info(**kwargs)

    def find_entity_by_id_api_v1_entity_find_get(
        self,
        platform_id,
        entity_id,
        **kwargs
    ):
        """Find Entity By 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.find_entity_by_id_api_v1_entity_find_get(platform_id, entity_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (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 (int/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:
            DataEntityGet
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        return self.find_entity_by_id_api_v1_entity_find_get_endpoint.call_with_http_info(**kwargs)

    def get_admin_config_api_v1_admin_config_get(
        self,
        **kwargs
    ):
        """Get Admin Config  # 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_admin_config_api_v1_admin_config_get(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 (int/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:
            AdminConfig
                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.get_admin_config_api_v1_admin_config_get_endpoint.call_with_http_info(**kwargs)

    def get_airflow_platform_api_v1_platforms_airflow_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Airflow Platform  # 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_airflow_platform_api_v1_platforms_airflow_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformAirflowCreate
                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['platform_id'] = \
            platform_id
        return self.get_airflow_platform_api_v1_platforms_airflow_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_all_taxonomy_classifications_api_v1_taxonomy_all_get(
        self,
        **kwargs
    ):
        """Get All Taxonomy Classifications  # 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_all_taxonomy_classifications_api_v1_taxonomy_all_get(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 (int/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:
            [DataTaxonomyClassification]
                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.get_all_taxonomy_classifications_api_v1_taxonomy_all_get_endpoint.call_with_http_info(**kwargs)

    def get_api_key_info_api_v1_api_keys_get(
        self,
        **kwargs
    ):
        """Get Api Key Info  # 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_api_key_info_api_v1_api_keys_get(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 (int/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:
            LimitOffsetPageAPIKeysResponse
                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.get_api_key_info_api_v1_api_keys_get_endpoint.call_with_http_info(**kwargs)

    def get_bigquery_platform_api_v1_platforms_bigquery_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Bigquery Platform  # 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_bigquery_platform_api_v1_platforms_bigquery_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformBigQueryCreate
                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['platform_id'] = \
            platform_id
        return self.get_bigquery_platform_api_v1_platforms_bigquery_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_child_taxonomy_classification_api_v1_taxonomy_children_classification_get(
        self,
        classification,
        **kwargs
    ):
        """Get Child Taxonomy Classification  # 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_child_taxonomy_classification_api_v1_taxonomy_children_classification_get(classification, async_req=True)
        >>> result = thread.get()

        Args:
            classification (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 (int/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:
            [DataTaxonomyClassification]
                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['classification'] = \
            classification
        return self.get_child_taxonomy_classification_api_v1_taxonomy_children_classification_get_endpoint.call_with_http_info(**kwargs)

    def get_client_config_api_v1_client_config_get(
        self,
        **kwargs
    ):
        """Get Client Config  # 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_client_config_api_v1_client_config_get(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 (int/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:
            ClientConfig
                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.get_client_config_api_v1_client_config_get_endpoint.call_with_http_info(**kwargs)

    def get_client_config_post_auth_api_v1_client_config_post_auth_get(
        self,
        **kwargs
    ):
        """Get Client Config Post Auth  # 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_client_config_post_auth_api_v1_client_config_post_auth_get(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 (int/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:
            ClientConfigPostAuth
                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.get_client_config_post_auth_api_v1_client_config_post_auth_get_endpoint.call_with_http_info(**kwargs)

    def get_data_entity_run_facets_api_v1_entity_runs_run_id_facets_get(
        self,
        run_id,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Data Entity Run Facets  # 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_data_entity_run_facets_api_v1_entity_runs_run_id_facets_get(run_id, platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            run_id (str):
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataEntityRunFacetGet
                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['run_id'] = \
            run_id
        kwargs['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_data_entity_run_facets_api_v1_entity_runs_run_id_facets_get_endpoint.call_with_http_info(**kwargs)

    def get_data_entity_run_job_mapping_api_v1_entity_runs_run_id_job_mappings_get(
        self,
        run_id,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Data Entity Run Job Mapping  # 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_data_entity_run_job_mapping_api_v1_entity_runs_run_id_job_mappings_get(run_id, platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            run_id (str):
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataEntityRunJobMappingGet
                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['run_id'] = \
            run_id
        kwargs['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_data_entity_run_job_mapping_api_v1_entity_runs_run_id_job_mappings_get_endpoint.call_with_http_info(**kwargs)

    def get_data_entity_run_job_step_mapping_api_v1_entity_runs_run_id_job_step_mapping_get(
        self,
        run_id,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Data Entity Run Job Step Mapping  # 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_data_entity_run_job_step_mapping_api_v1_entity_runs_run_id_job_step_mapping_get(run_id, platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            run_id (str):
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        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 (int/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:
            [DataEntityRunJobStepMappingGet]
                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['run_id'] = \
            run_id
        kwargs['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_data_entity_run_job_step_mapping_api_v1_entity_runs_run_id_job_step_mapping_get_endpoint.call_with_http_info(**kwargs)

    def get_data_entity_runs_api_v1_entity_runs_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Data Entity Runs  # 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_data_entity_runs_api_v1_entity_runs_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataEntityRunGet
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_data_entity_runs_api_v1_entity_runs_get_endpoint.call_with_http_info(**kwargs)

    def get_data_entity_runs_by_id_api_v1_entity_runs_run_id_get(
        self,
        run_id,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Data Entity Runs By 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_data_entity_runs_by_id_api_v1_entity_runs_run_id_get(run_id, platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            run_id (str):
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        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 (int/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:
            [DataEntityRunGet]
                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['run_id'] = \
            run_id
        kwargs['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_data_entity_runs_by_id_api_v1_entity_runs_run_id_get_endpoint.call_with_http_info(**kwargs)

    def get_databricks_platform_api_v1_platforms_databricks_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Databricks Platform  # 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_databricks_platform_api_v1_platforms_databricks_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformDatabricksCreate
                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['platform_id'] = \
            platform_id
        return self.get_databricks_platform_api_v1_platforms_databricks_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_entities_usage_stats_post_api_v1_entities_usage_stats_post(
        self,
        platform_id,
        entity_type,
        start_timestamp,
        end_timestamp,
        data_entity_usage_stats_request,
        **kwargs
    ):
        """Get Entities Usage Stats Post  # 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_entities_usage_stats_post_api_v1_entities_usage_stats_post(platform_id, entity_type, start_timestamp, end_timestamp, data_entity_usage_stats_request, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id ([str]):
            entity_type ([str]):
            start_timestamp (datetime):
            end_timestamp (datetime):
            data_entity_usage_stats_request (DataEntityUsageStatsRequest):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            sort ([str]): [optional] if omitted the server will use the default value of ["usageCount:asc"]
            _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 (int/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:
            LimitOffsetPageDataEntityUsageStatsReport
                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['platform_id'] = \
            platform_id
        kwargs['entity_type'] = \
            entity_type
        kwargs['start_timestamp'] = \
            start_timestamp
        kwargs['end_timestamp'] = \
            end_timestamp
        kwargs['data_entity_usage_stats_request'] = \
            data_entity_usage_stats_request
        return self.get_entities_usage_stats_post_api_v1_entities_usage_stats_post_endpoint.call_with_http_info(**kwargs)

    def get_entity_api_v1_entity_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Entity  # 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_entity_api_v1_entity_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        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 (int/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:
            DataEntityGet
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_entity_api_v1_entity_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_children_api_v1_entity_children_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        has_connections,
        **kwargs
    ):
        """Get Entity Children  # 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_entity_children_api_v1_entity_children_get(platform_id, entity_id, entity_type, has_connections, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):
            has_connections (bool):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataEntityGet
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        kwargs['has_connections'] = \
            has_connections
        return self.get_entity_children_api_v1_entity_children_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_children_api_v1_most_recent_entity_numerical_stats_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Entity Children  # 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_entity_children_api_v1_most_recent_entity_numerical_stats_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataEntityNumericalStat
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_entity_children_api_v1_most_recent_entity_numerical_stats_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_data_taxonomy_api_v1_entity_taxonomy_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Entity Data Taxonomy  # 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_entity_data_taxonomy_api_v1_entity_taxonomy_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        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 (int/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:
            [DataTaxonomyClassification]
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_entity_data_taxonomy_api_v1_entity_taxonomy_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_jobs_api_v1_entity_jobs_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Entity 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_entity_jobs_api_v1_entity_jobs_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataPlatformJob
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_entity_jobs_api_v1_entity_jobs_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_lineage_api_v2_lineage_post(
        self,
        data_entity_lineage_v2_request,
        **kwargs
    ):
        """Get Entity Lineage  # 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_entity_lineage_api_v2_lineage_post(data_entity_lineage_v2_request, async_req=True)
        >>> result = thread.get()

        Args:
            data_entity_lineage_v2_request (DataEntityLineageV2Request):

        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 (int/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:
            DataEntityLineageV2Response
                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['data_entity_lineage_v2_request'] = \
            data_entity_lineage_v2_request
        return self.get_entity_lineage_api_v2_lineage_post_endpoint.call_with_http_info(**kwargs)

    def get_entity_lineage_children_api_v2_lineage_children_post(
        self,
        data_entity_lineage_children_request,
        **kwargs
    ):
        """Get Entity Lineage Children  # 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_entity_lineage_children_api_v2_lineage_children_post(data_entity_lineage_children_request, async_req=True)
        >>> result = thread.get()

        Args:
            data_entity_lineage_children_request (DataEntityLineageChildrenRequest):

        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 (int/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:
            DataEntityLineageChildrenResponse
                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['data_entity_lineage_children_request'] = \
            data_entity_lineage_children_request
        return self.get_entity_lineage_children_api_v2_lineage_children_post_endpoint.call_with_http_info(**kwargs)

    def get_entity_lineage_list_api_v2_lineage_list_post(
        self,
        data_entity_lineage_list_request,
        **kwargs
    ):
        """Get Entity Lineage 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_entity_lineage_list_api_v2_lineage_list_post(data_entity_lineage_list_request, async_req=True)
        >>> result = thread.get()

        Args:
            data_entity_lineage_list_request (DataEntityLineageListRequest):

        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 (int/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:
            DataEntityLineageListResponse
                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['data_entity_lineage_list_request'] = \
            data_entity_lineage_list_request
        return self.get_entity_lineage_list_api_v2_lineage_list_post_endpoint.call_with_http_info(**kwargs)

    def get_entity_numerical_stats_api_v1_get_entity_numerical_stats_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        start_timestamp,
        end_timestamp,
        **kwargs
    ):
        """Get Entity Numerical Stats  # 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_entity_numerical_stats_api_v1_get_entity_numerical_stats_get(platform_id, entity_id, entity_type, start_timestamp, end_timestamp, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):
            start_timestamp (datetime):
            end_timestamp (datetime):

        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 (int/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:
            DataEntityNumericalStatResponse
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        kwargs['start_timestamp'] = \
            start_timestamp
        kwargs['end_timestamp'] = \
            end_timestamp
        return self.get_entity_numerical_stats_api_v1_get_entity_numerical_stats_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_owner_id_api_v1_entity_owner_get(
        self,
        entity_id,
        entity_type,
        platform_id,
        **kwargs
    ):
        """Get Entity Owner 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_entity_owner_id_api_v1_entity_owner_get(entity_id, entity_type, platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            entity_id (str):
            entity_type (str):
            platform_id (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 (int/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:
            UserGet
                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['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        kwargs['platform_id'] = \
            platform_id
        return self.get_entity_owner_id_api_v1_entity_owner_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_parents_api_v1_entity_parents_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Entity Parents  # 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_entity_parents_api_v1_entity_parents_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        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 (int/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:
            [DataEntityGet]
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_entity_parents_api_v1_entity_parents_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_schema_api_v1_entity_entity_schema_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Entity Schema  # 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_entity_schema_api_v1_entity_entity_schema_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            get_entity_classifications (bool): [optional] if omitted the server will use the default value of True
            omit_deleted_children (bool): [optional] if omitted the server will use the default value of False
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataEntityGet
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_entity_schema_api_v1_entity_entity_schema_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_siblings_api_v1_entity_siblings_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Entity Siblings  # 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_entity_siblings_api_v1_entity_siblings_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataEntityGet
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_entity_siblings_api_v1_entity_siblings_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_tags_api_v1_entity_tags_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Entity Tags  # 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_entity_tags_api_v1_entity_tags_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (DataEntityType):

        Keyword Args:
            data_tag_type (DataTagType): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataTagConnectionGet
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_entity_tags_api_v1_entity_tags_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_usage_stats_api_v1_entity_usage_stats_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        start_timestamp,
        end_timestamp,
        **kwargs
    ):
        """Get Entity Usage Stats  # 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_entity_usage_stats_api_v1_entity_usage_stats_get(platform_id, entity_id, entity_type, start_timestamp, end_timestamp, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type ([str]):
            start_timestamp (datetime):
            end_timestamp (datetime):

        Keyword Args:
            usage_type ([str]): [optional]
            user_name ([str]): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            DataEntityUsageStatsReport
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        kwargs['start_timestamp'] = \
            start_timestamp
        kwargs['end_timestamp'] = \
            end_timestamp
        return self.get_entity_usage_stats_api_v1_entity_usage_stats_get_endpoint.call_with_http_info(**kwargs)

    def get_entity_usage_stats_raw_api_v1_entity_usage_stats_raw_get(
        self,
        platform_id,
        entity_id,
        entity_type,
        **kwargs
    ):
        """Get Entity Usage Stats Raw  # 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_entity_usage_stats_raw_api_v1_entity_usage_stats_raw_get(platform_id, entity_id, entity_type, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (str):
            entity_id (str):
            entity_type (str):

        Keyword Args:
            start_timestamp (datetime): [optional]
            end_timestamp (datetime): [optional]
            connection_type (ConnectionType): [optional]
            connection_direction (ConnectionDirection): [optional]
            connection_usage_classification (ConnectionUsageClassification): [optional]
            usage_type ([str]): [optional]
            user_name ([str]): [optional]
            sort ([str]): [optional] if omitted the server will use the default value of ["start:desc"]
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataEntityUsageStatRaw
                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['platform_id'] = \
            platform_id
        kwargs['entity_id'] = \
            entity_id
        kwargs['entity_type'] = \
            entity_type
        return self.get_entity_usage_stats_raw_api_v1_entity_usage_stats_raw_get_endpoint.call_with_http_info(**kwargs)

    def get_experiences_api_v1_experience_get(
        self,
        **kwargs
    ):
        """Get Experiences  # 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_experiences_api_v1_experience_get(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            lead_user_email (str): [optional]
            user_persona (str): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            [Experience]
                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.get_experiences_api_v1_experience_get_endpoint.call_with_http_info(**kwargs)

    def get_filter_api_v2_filters_get(
        self,
        **kwargs
    ):
        """Get Filter  # 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_filter_api_v2_filters_get(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 (int/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:
            [FilterOptions]
                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.get_filter_api_v2_filters_get_endpoint.call_with_http_info(**kwargs)

    def get_filters_config_api_v1_filters_config_get(
        self,
        **kwargs
    ):
        """Get Filters Config  # 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_filters_config_api_v1_filters_config_get(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            filter_view (bool, date, datetime, dict, float, int, list, str, none_type): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            FiltersResponse
                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.get_filters_config_api_v1_filters_config_get_endpoint.call_with_http_info(**kwargs)

    def get_hive_platform_api_v1_platforms_hive_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Hive Platform  # 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_hive_platform_api_v1_platforms_hive_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformHiveCreate
                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['platform_id'] = \
            platform_id
        return self.get_hive_platform_api_v1_platforms_hive_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_hiveglue_platform_api_v1_platforms_hiveglue_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Hiveglue Platform  # 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_hiveglue_platform_api_v1_platforms_hiveglue_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformHiveGlueCreate
                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['platform_id'] = \
            platform_id
        return self.get_hiveglue_platform_api_v1_platforms_hiveglue_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_impact_analysis_platforms_api_v2_impact_analysis_platforms_get(
        self,
        **kwargs
    ):
        """Get Impact Analysis Platforms  # 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_impact_analysis_platforms_api_v2_impact_analysis_platforms_get(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 (int/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:
            [DataPlatformGet]
                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.get_impact_analysis_platforms_api_v2_impact_analysis_platforms_get_endpoint.call_with_http_info(**kwargs)

    def get_impact_by_query_api_v2_impact_analysis_query_post(
        self,
        impact_analysis_request,
        **kwargs
    ):
        """Get Impact By Query  # 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_impact_by_query_api_v2_impact_analysis_query_post(impact_analysis_request, async_req=True)
        >>> result = thread.get()

        Args:
            impact_analysis_request (ImpactAnalysisRequest):

        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 (int/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:
            ImpactAnalysisResponse
                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['impact_analysis_request'] = \
            impact_analysis_request
        return self.get_impact_by_query_api_v2_impact_analysis_query_post_endpoint.call_with_http_info(**kwargs)

    def get_impact_from_validation_payload_api_v2_impact_analysis_query_entities_post(
        self,
        impact_analysis_validation_payload,
        **kwargs
    ):
        """Get Impact From Validation Payload  # 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_impact_from_validation_payload_api_v2_impact_analysis_query_entities_post(impact_analysis_validation_payload, async_req=True)
        >>> result = thread.get()

        Args:
            impact_analysis_validation_payload (ImpactAnalysisValidationPayload):

        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 (int/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:
            ImpactAnalysisResponse
                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['impact_analysis_validation_payload'] = \
            impact_analysis_validation_payload
        return self.get_impact_from_validation_payload_api_v2_impact_analysis_query_entities_post_endpoint.call_with_http_info(**kwargs)

    def get_invited_users_to_org_api_v2_users_invite_get(
        self,
        **kwargs
    ):
        """Get Invited Users To Org  # 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_invited_users_to_org_api_v2_users_invite_get(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 (int/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:
            [UserInviteCreate]
                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.get_invited_users_to_org_api_v2_users_invite_get_endpoint.call_with_http_info(**kwargs)

    def get_job_entity_usage_stats_report_api_v1_job_usage_stats_get(
        self,
        job_hash,
        platform_id,
        start_timestamp,
        end_timestamp,
        **kwargs
    ):
        """Get Job Entity Usage Stats Report  # 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_job_entity_usage_stats_report_api_v1_job_usage_stats_get(job_hash, platform_id, start_timestamp, end_timestamp, async_req=True)
        >>> result = thread.get()

        Args:
            job_hash (str):
            platform_id (str):
            start_timestamp (datetime):
            end_timestamp (datetime):

        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 (int/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:
            JobEntityUsageStatsReport
                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['job_hash'] = \
            job_hash
        kwargs['platform_id'] = \
            platform_id
        kwargs['start_timestamp'] = \
            start_timestamp
        kwargs['end_timestamp'] = \
            end_timestamp
        return self.get_job_entity_usage_stats_report_api_v1_job_usage_stats_get_endpoint.call_with_http_info(**kwargs)

    def get_job_steps_aggregated_stats_api_v1_job_steps_aggregated_stats_get(
        self,
        job_hash,
        platform_id,
        report_type,
        **kwargs
    ):
        """Get Job Steps Aggregated Stats  # 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_job_steps_aggregated_stats_api_v1_job_steps_aggregated_stats_get(job_hash, platform_id, report_type, async_req=True)
        >>> result = thread.get()

        Args:
            job_hash (str):
            platform_id (str):
            report_type (DataPlatformJobStepReportType):

        Keyword Args:
            local_timezone (str): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            DataPlatformJobStepAggregatedReport
                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['job_hash'] = \
            job_hash
        kwargs['platform_id'] = \
            platform_id
        kwargs['report_type'] = \
            report_type
        return self.get_job_steps_aggregated_stats_api_v1_job_steps_aggregated_stats_get_endpoint.call_with_http_info(**kwargs)

    def get_job_steps_api_v1_jobs_steps_post(
        self,
        data_platform_job_step_request,
        **kwargs
    ):
        """Get Job Steps  # 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_job_steps_api_v1_jobs_steps_post(data_platform_job_step_request, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_job_step_request (DataPlatformJobStepRequest):

        Keyword Args:
            metadata_fields (str): [optional] if omitted the server will use the default value of "source_text,fingerprint,job_step_metadata"
            _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 (int/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:
            [DataPlatformJobStep]
                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['data_platform_job_step_request'] = \
            data_platform_job_step_request
        return self.get_job_steps_api_v1_jobs_steps_post_endpoint.call_with_http_info(**kwargs)

    def get_jobs_steps_aggregated_stats_api_v1_jobs_steps_aggregated_stats_get(
        self,
        entity_id,
        platform_id,
        platform_type,
        entity_type,
        report_type,
        **kwargs
    ):
        """Get Jobs Steps Aggregated Stats  # 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_steps_aggregated_stats_api_v1_jobs_steps_aggregated_stats_get(entity_id, platform_id, platform_type, entity_type, report_type, async_req=True)
        >>> result = thread.get()

        Args:
            entity_id (str):
            platform_id (str):
            platform_type (str):
            entity_type (DataEntityType):
            report_type (DataPlatformJobStepReportType):

        Keyword Args:
            level (int): [optional] if omitted the server will use the default value of 1
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            local_timezone (str): [optional]
            upstream (bool): [optional] if omitted the server will use the default value of True
            _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 (int/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:
            LimitOffsetPageDataPlatformJobEntityAggregatedReport
                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['entity_id'] = \
            entity_id
        kwargs['platform_id'] = \
            platform_id
        kwargs['platform_type'] = \
            platform_type
        kwargs['entity_type'] = \
            entity_type
        kwargs['report_type'] = \
            report_type
        return self.get_jobs_steps_aggregated_stats_api_v1_jobs_steps_aggregated_stats_get_endpoint.call_with_http_info(**kwargs)

    def get_jobs_users_api_v1_jobs_users_post(
        self,
        platform_id,
        entity_type,
        start_timestamp,
        end_timestamp,
        data_entity_usage_stats_request,
        **kwargs
    ):
        """Get Jobs Users  # 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_users_api_v1_jobs_users_post(platform_id, entity_type, start_timestamp, end_timestamp, data_entity_usage_stats_request, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id ([str]):
            entity_type ([str]):
            start_timestamp (datetime):
            end_timestamp (datetime):
            data_entity_usage_stats_request (DataEntityUsageStatsRequest):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 1000
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            [DataPlatformJobStepUser]
                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['platform_id'] = \
            platform_id
        kwargs['entity_type'] = \
            entity_type
        kwargs['start_timestamp'] = \
            start_timestamp
        kwargs['end_timestamp'] = \
            end_timestamp
        kwargs['data_entity_usage_stats_request'] = \
            data_entity_usage_stats_request
        return self.get_jobs_users_api_v1_jobs_users_post_endpoint.call_with_http_info(**kwargs)

    def get_last_job_query_api_v1_job_query_post(
        self,
        job_query_request,
        **kwargs
    ):
        """Get Last Job Query  # 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_last_job_query_api_v1_job_query_post(job_query_request, async_req=True)
        >>> result = thread.get()

        Args:
            job_query_request (JobQueryRequest):

        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 (int/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:
            JobQueryV1Response
                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['job_query_request'] = \
            job_query_request
        return self.get_last_job_query_api_v1_job_query_post_endpoint.call_with_http_info(**kwargs)

    def get_lineage_job_steps_api_v1_lineage_jobs_steps_get(
        self,
        from_entity_id,
        from_entity_type,
        from_entity_platform_id,
        to_entity_id,
        to_entity_type,
        to_entity_platform_id,
        **kwargs
    ):
        """Get Lineage Job Steps  # 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_lineage_job_steps_api_v1_lineage_jobs_steps_get(from_entity_id, from_entity_type, from_entity_platform_id, to_entity_id, to_entity_type, to_entity_platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            from_entity_id (str):
            from_entity_type (str):
            from_entity_platform_id (str):
            to_entity_id (str):
            to_entity_type (str):
            to_entity_platform_id (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 (int/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:
            [DataPlatformJobStep]
                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['from_entity_id'] = \
            from_entity_id
        kwargs['from_entity_type'] = \
            from_entity_type
        kwargs['from_entity_platform_id'] = \
            from_entity_platform_id
        kwargs['to_entity_id'] = \
            to_entity_id
        kwargs['to_entity_type'] = \
            to_entity_type
        kwargs['to_entity_platform_id'] = \
            to_entity_platform_id
        return self.get_lineage_job_steps_api_v1_lineage_jobs_steps_get_endpoint.call_with_http_info(**kwargs)

    def get_looker_platform_api_v1_platforms_looker_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Looker Platform  # 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_looker_platform_api_v1_platforms_looker_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformLookerCreate
                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['platform_id'] = \
            platform_id
        return self.get_looker_platform_api_v1_platforms_looker_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_mode_platform_api_v1_platforms_mode_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Mode Platform  # 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_mode_platform_api_v1_platforms_mode_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformModeCreate
                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['platform_id'] = \
            platform_id
        return self.get_mode_platform_api_v1_platforms_mode_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_mssql_platform_api_v1_platforms_mssql_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Mssql Platform  # 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_mssql_platform_api_v1_platforms_mssql_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformMSSQLCreate
                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['platform_id'] = \
            platform_id
        return self.get_mssql_platform_api_v1_platforms_mssql_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_mysql_platform_api_v1_platforms_mysql_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Mysql Platform  # 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_mysql_platform_api_v1_platforms_mysql_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformMySQLCreate
                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['platform_id'] = \
            platform_id
        return self.get_mysql_platform_api_v1_platforms_mysql_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_notifications_api_v1_notifications_get(
        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_api_v1_notifications_get(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 (int/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:
            [Notification]
                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.get_notifications_api_v1_notifications_get_endpoint.call_with_http_info(**kwargs)

    def get_parent_taxonomy_classifications_api_v1_taxonomy_parents_get(
        self,
        **kwargs
    ):
        """Get Parent Taxonomy Classifications  # 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_parent_taxonomy_classifications_api_v1_taxonomy_parents_get(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 (int/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:
            [DataTaxonomyClassification]
                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.get_parent_taxonomy_classifications_api_v1_taxonomy_parents_get_endpoint.call_with_http_info(**kwargs)

    def get_platform_api_v1_platforms_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Platform  # 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_platform_api_v1_platforms_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformGet
                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['platform_id'] = \
            platform_id
        return self.get_platform_api_v1_platforms_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_platforms_api_v1_platforms_get(
        self,
        **kwargs
    ):
        """Get Platforms  # 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_platforms_api_v1_platforms_get(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            platform_classification (PlatformClassification): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            [DataPlatformGet]
                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.get_platforms_api_v1_platforms_get_endpoint.call_with_http_info(**kwargs)

    def get_popular_user_entities_api_v2_user_entities_popular_get(
        self,
        **kwargs
    ):
        """Get Popular User Entities  # 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_popular_user_entities_api_v2_user_entities_popular_get(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 (int/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:
            [UserActivityResponse]
                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.get_popular_user_entities_api_v2_user_entities_popular_get_endpoint.call_with_http_info(**kwargs)

    def get_postgres_platform_api_v1_platforms_postgres_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Postgres Platform  # 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_postgres_platform_api_v1_platforms_postgres_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformPostgresCreate
                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['platform_id'] = \
            platform_id
        return self.get_postgres_platform_api_v1_platforms_postgres_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_powerbi_platform_api_v1_platforms_powerbi_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Powerbi Platform  # 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_powerbi_platform_api_v1_platforms_powerbi_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformPowerBICreate
                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['platform_id'] = \
            platform_id
        return self.get_powerbi_platform_api_v1_platforms_powerbi_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_recent_user_entities_api_v2_user_entities_recent_get(
        self,
        **kwargs
    ):
        """Get Recent User Entities  # 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_user_entities_api_v2_user_entities_recent_get(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 (int/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:
            [UserActivityResponse]
                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.get_recent_user_entities_api_v2_user_entities_recent_get_endpoint.call_with_http_info(**kwargs)

    def get_redshift_platform_api_v1_platforms_redshift_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Redshift Platform  # 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_redshift_platform_api_v1_platforms_redshift_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformRedshiftCreate
                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['platform_id'] = \
            platform_id
        return self.get_redshift_platform_api_v1_platforms_redshift_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_snowflake_platform_api_v1_platforms_snowflake_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Snowflake Platform  # 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_snowflake_platform_api_v1_platforms_snowflake_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformSnowflakeCreate
                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['platform_id'] = \
            platform_id
        return self.get_snowflake_platform_api_v1_platforms_snowflake_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_tableau_platform_api_v1_platforms_tableau_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Tableau Platform  # 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_tableau_platform_api_v1_platforms_tableau_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformTableauCreate
                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['platform_id'] = \
            platform_id
        return self.get_tableau_platform_api_v1_platforms_tableau_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_tag_rules_api_v1_tags_rules_get(
        self,
        tag_name,
        tag_domain,
        **kwargs
    ):
        """Get Tag Rules  # 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_tag_rules_api_v1_tags_rules_get(tag_name, tag_domain, async_req=True)
        >>> result = thread.get()

        Args:
            tag_name (str):
            tag_domain (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 (int/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:
            LimitOffsetPageDataTagRuleGet
                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['tag_name'] = \
            tag_name
        kwargs['tag_domain'] = \
            tag_domain
        return self.get_tag_rules_api_v1_tags_rules_get_endpoint.call_with_http_info(**kwargs)

    def get_tags_api_v1_tags_get(
        self,
        **kwargs
    ):
        """Get Tags  # 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_tags_api_v1_tags_get(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            data_tag_type (DataTagType): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataTagGet
                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.get_tags_api_v1_tags_get_endpoint.call_with_http_info(**kwargs)

    def get_tags_api_v2_tags_get(
        self,
        **kwargs
    ):
        """Get Tags  # 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_tags_api_v2_tags_get(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            data_tag_type (DataTagType): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataTagGet
                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.get_tags_api_v2_tags_get_endpoint.call_with_http_info(**kwargs)

    def get_top_level_entities_api_v1_top_entities_get(
        self,
        **kwargs
    ):
        """Get Top Level Entities  # 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_top_level_entities_api_v1_top_entities_get(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            platform_id (str): [optional]
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageDataEntityGet
                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.get_top_level_entities_api_v1_top_entities_get_endpoint.call_with_http_info(**kwargs)

    def get_top_level_entities_by_platform_api_v1_top_entities_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Top Level Entities By Platform  # 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_top_level_entities_by_platform_api_v1_top_entities_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['platform_id'] = \
            platform_id
        return self.get_top_level_entities_by_platform_api_v1_top_entities_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_treasuredata_platform_api_v1_platforms_treasuredata_platform_id_get(
        self,
        platform_id,
        **kwargs
    ):
        """Get Treasuredata Platform  # 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_treasuredata_platform_api_v1_platforms_treasuredata_platform_id_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformTreasureDataCreate
                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['platform_id'] = \
            platform_id
        return self.get_treasuredata_platform_api_v1_platforms_treasuredata_platform_id_get_endpoint.call_with_http_info(**kwargs)

    def get_user_id_api_v1_user_id_get(
        self,
        user_email,
        **kwargs
    ):
        """Get User 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_user_id_api_v1_user_id_get(user_email, async_req=True)
        >>> result = thread.get()

        Args:
            user_email (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 (int/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')
        kwargs['user_email'] = \
            user_email
        return self.get_user_id_api_v1_user_id_get_endpoint.call_with_http_info(**kwargs)

    def get_user_info_api_v1_me_get(
        self,
        **kwargs
    ):
        """Get User Info  # 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_user_info_api_v1_me_get(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 (int/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:
            UserGet
                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.get_user_info_api_v1_me_get_endpoint.call_with_http_info(**kwargs)

    def get_user_info_api_v1_organization_get(
        self,
        **kwargs
    ):
        """Get User Info  # 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_user_info_api_v1_organization_get(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 (int/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:
            OrganizationGet
                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.get_user_info_api_v1_organization_get_endpoint.call_with_http_info(**kwargs)

    def get_user_invite_by_link_id_api_v2_users_invite_link_id_get(
        self,
        link_id,
        **kwargs
    ):
        """Get User Invite By Link 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_user_invite_by_link_id_api_v2_users_invite_link_id_get(link_id, async_req=True)
        >>> result = thread.get()

        Args:
            link_id (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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['link_id'] = \
            link_id
        return self.get_user_invite_by_link_id_api_v2_users_invite_link_id_get_endpoint.call_with_http_info(**kwargs)

    def get_user_popular_searches_api_v2_user_search_popular_get(
        self,
        **kwargs
    ):
        """Get User Popular Searches  # 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_user_popular_searches_api_v2_user_search_popular_get(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 (int/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:
            [UserActivityResponse]
                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.get_user_popular_searches_api_v2_user_search_popular_get_endpoint.call_with_http_info(**kwargs)

    def get_user_recent_searches_api_v2_user_search_recent_get(
        self,
        **kwargs
    ):
        """Get User Recent Searches  # 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_user_recent_searches_api_v2_user_search_recent_get(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 (int/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:
            [UserActivityResponse]
                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.get_user_recent_searches_api_v2_user_search_recent_get_endpoint.call_with_http_info(**kwargs)

    def get_users_by_id_api_v1_users_get(
        self,
        **kwargs
    ):
        """Get Users By 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_users_by_id_api_v1_users_get(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            user_ids ([str]): [optional] if omitted the server will use the default value of []
            _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 (int/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: (UserGet,)}
                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.get_users_by_id_api_v1_users_get_endpoint.call_with_http_info(**kwargs)

    def get_users_in_org_api_v1_org_users_get(
        self,
        **kwargs
    ):
        """Get Users In Org  # 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_users_in_org_api_v1_org_users_get(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 (int/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: (UserGet,)}
                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.get_users_in_org_api_v1_org_users_get_endpoint.call_with_http_info(**kwargs)

    def healthcheck_health_get(
        self,
        **kwargs
    ):
        """Healthcheck  # noqa: E501

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

        >>> thread = api.healthcheck_health_get(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 (int/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:
            HealthcheckResponse
                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.healthcheck_health_get_endpoint.call_with_http_info(**kwargs)

    def invite_user_to_org_api_v2_users_invite_post(
        self,
        user_create_request,
        **kwargs
    ):
        """Invite User To Org  # noqa: E501

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

        >>> thread = api.invite_user_to_org_api_v2_users_invite_post(user_create_request, async_req=True)
        >>> result = thread.get()

        Args:
            user_create_request (UserCreateRequest):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['user_create_request'] = \
            user_create_request
        return self.invite_user_to_org_api_v2_users_invite_post_endpoint.call_with_http_info(**kwargs)

    def lineage_api_v1_lineage_post(
        self,
        unknown_base_type,
        **kwargs
    ):
        """Lineage  # noqa: E501

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

        >>> thread = api.lineage_api_v1_lineage_post(unknown_base_type, async_req=True)
        >>> result = thread.get()

        Args:
            unknown_base_type ():

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['unknown_base_type'] = \
            unknown_base_type
        return self.lineage_api_v1_lineage_post_endpoint.call_with_http_info(**kwargs)

    def lineage_spark_api_v1_lineage_spark_post(
        self,
        unknown_base_type,
        **kwargs
    ):
        """Lineage Spark  # noqa: E501

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

        >>> thread = api.lineage_spark_api_v1_lineage_spark_post(unknown_base_type, async_req=True)
        >>> result = thread.get()

        Args:
            unknown_base_type ():

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['unknown_base_type'] = \
            unknown_base_type
        return self.lineage_spark_api_v1_lineage_spark_post_endpoint.call_with_http_info(**kwargs)

    def list_manual_lineage_api_v1_lineage_manual_get(
        self,
        **kwargs
    ):
        """List Manual Lineage  # noqa: E501

        Return paginated result of Manual Lineage Data  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

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


        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            LimitOffsetPageManualLineageData
                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.list_manual_lineage_api_v1_lineage_manual_get_endpoint.call_with_http_info(**kwargs)

    def list_manual_lineage_valid_entity_types_api_v1_lineage_manual_valid_entity_types_get(
        self,
        manual_lineage_entity_type_validation,
        **kwargs
    ):
        """List Manual Lineage Valid Entity Types  # noqa: E501

        List of valid entity types for manual lineage data connection  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_manual_lineage_valid_entity_types_api_v1_lineage_manual_valid_entity_types_get(manual_lineage_entity_type_validation, async_req=True)
        >>> result = thread.get()

        Args:
            manual_lineage_entity_type_validation (ManualLineageEntityTypeValidation):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['manual_lineage_entity_type_validation'] = \
            manual_lineage_entity_type_validation
        return self.list_manual_lineage_valid_entity_types_api_v1_lineage_manual_valid_entity_types_get_endpoint.call_with_http_info(**kwargs)

    def list_saved_search_nodes_filter_api_v2_saved_search_nodes_get(
        self,
        **kwargs
    ):
        """List Saved Search Nodes Filter  # noqa: E501

        List all the saved search node based filters  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

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


        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        return self.list_saved_search_nodes_filter_api_v2_saved_search_nodes_get_endpoint.call_with_http_info(**kwargs)

    def list_saved_search_string_filter_api_v2_saved_search_string_get(
        self,
        **kwargs
    ):
        """List Saved Search String Filter  # noqa: E501

        List all the saved search string based filters  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

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


        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        return self.list_saved_search_string_filter_api_v2_saved_search_string_get_endpoint.call_with_http_info(**kwargs)

    def list_users_in_org_api_v2_users_get(
        self,
        **kwargs
    ):
        """List Users In Org  # noqa: E501

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

        >>> thread = api.list_users_in_org_api_v2_users_get(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 (int/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:
            [UserGet]
                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.list_users_in_org_api_v2_users_get_endpoint.call_with_http_info(**kwargs)

    def metadata_api_v1_metadata_post(
        self,
        unknown_base_type,
        **kwargs
    ):
        """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.metadata_api_v1_metadata_post(unknown_base_type, async_req=True)
        >>> result = thread.get()

        Args:
            unknown_base_type ():

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['unknown_base_type'] = \
            unknown_base_type
        return self.metadata_api_v1_metadata_post_endpoint.call_with_http_info(**kwargs)

    def register_interest_api_v1_experiences_register_interest_post(
        self,
        experience_data,
        **kwargs
    ):
        """Register Interest  # noqa: E501

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

        >>> thread = api.register_interest_api_v1_experiences_register_interest_post(experience_data, async_req=True)
        >>> result = thread.get()

        Args:
            experience_data (ExperienceData):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['experience_data'] = \
            experience_data
        return self.register_interest_api_v1_experiences_register_interest_post_endpoint.call_with_http_info(**kwargs)

    def remove_user_from_org_api_v2_user_delete(
        self,
        user_id,
        **kwargs
    ):
        """Remove User From Org  # 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_user_from_org_api_v2_user_delete(user_id, async_req=True)
        >>> result = thread.get()

        Args:
            user_id (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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['user_id'] = \
            user_id
        return self.remove_user_from_org_api_v2_user_delete_endpoint.call_with_http_info(**kwargs)

    def request_access_api_v1_experiences_request_access_post(
        self,
        experience_data,
        **kwargs
    ):
        """Request Access  # 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_access_api_v1_experiences_request_access_post(experience_data, async_req=True)
        >>> result = thread.get()

        Args:
            experience_data (ExperienceData):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['experience_data'] = \
            experience_data
        return self.request_access_api_v1_experiences_request_access_post_endpoint.call_with_http_info(**kwargs)

    def run_impact_node_query_api_v2_impact_analysis_query_string_nodes_post(
        self,
        impact_analysis_request,
        **kwargs
    ):
        """Run Impact Node Query  # noqa: E501

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

        >>> thread = api.run_impact_node_query_api_v2_impact_analysis_query_string_nodes_post(impact_analysis_request, async_req=True)
        >>> result = thread.get()

        Args:
            impact_analysis_request (ImpactAnalysisRequest):

        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 (int/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:
            ImpactAnalysisNodeListResponse
                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['impact_analysis_request'] = \
            impact_analysis_request
        return self.run_impact_node_query_api_v2_impact_analysis_query_string_nodes_post_endpoint.call_with_http_info(**kwargs)

    def run_validated_impact_node_query_api_v2_impact_analysis_query_nodes_post(
        self,
        impact_analysis_validation_payload,
        **kwargs
    ):
        """Run Validated Impact Node Query  # noqa: E501

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

        >>> thread = api.run_validated_impact_node_query_api_v2_impact_analysis_query_nodes_post(impact_analysis_validation_payload, async_req=True)
        >>> result = thread.get()

        Args:
            impact_analysis_validation_payload (ImpactAnalysisValidationPayload):

        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 (int/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:
            ImpactAnalysisNodeListResponse
                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['impact_analysis_validation_payload'] = \
            impact_analysis_validation_payload
        return self.run_validated_impact_node_query_api_v2_impact_analysis_query_nodes_post_endpoint.call_with_http_info(**kwargs)

    def save_tag_api_v1_tags_post(
        self,
        data_tag_request,
        **kwargs
    ):
        """Save Tag  # 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_tag_api_v1_tags_post(data_tag_request, async_req=True)
        >>> result = thread.get()

        Args:
            data_tag_request (DataTagRequest):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['data_tag_request'] = \
            data_tag_request
        return self.save_tag_api_v1_tags_post_endpoint.call_with_http_info(**kwargs)

    def save_tag_category_api_v2_tags_post(
        self,
        data_tag_request_v2,
        **kwargs
    ):
        """Save Tag Category  # 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_tag_category_api_v2_tags_post(data_tag_request_v2, async_req=True)
        >>> result = thread.get()

        Args:
            data_tag_request_v2 (DataTagRequestV2):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['data_tag_request_v2'] = \
            data_tag_request_v2
        return self.save_tag_category_api_v2_tags_post_endpoint.call_with_http_info(**kwargs)

    def save_tags_entity_connections_api_v1_entity_tags_post(
        self,
        data_entity_save_tag_connection_request,
        **kwargs
    ):
        """Save Tags Entity Connections  # 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_tags_entity_connections_api_v1_entity_tags_post(data_entity_save_tag_connection_request, async_req=True)
        >>> result = thread.get()

        Args:
            data_entity_save_tag_connection_request ([DataEntitySaveTagConnectionRequest]):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['data_entity_save_tag_connection_request'] = \
            data_entity_save_tag_connection_request
        return self.save_tags_entity_connections_api_v1_entity_tags_post_endpoint.call_with_http_info(**kwargs)

    def saved_search_nodes_filter_api_v2_saved_search_nodes_post(
        self,
        save_search_filter,
        **kwargs
    ):
        """Saved Search Nodes Filter  # noqa: E501

        Save the search nodes based filter  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.saved_search_nodes_filter_api_v2_saved_search_nodes_post(save_search_filter, async_req=True)
        >>> result = thread.get()

        Args:
            save_search_filter (SaveSearchFilter):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['save_search_filter'] = \
            save_search_filter
        return self.saved_search_nodes_filter_api_v2_saved_search_nodes_post_endpoint.call_with_http_info(**kwargs)

    def saved_search_string_filter_api_v2_saved_search_string_post(
        self,
        save_search_string_filter,
        **kwargs
    ):
        """Saved Search String Filter  # noqa: E501

        Save the string based search filter along with the search nodes if they exists  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.saved_search_string_filter_api_v2_saved_search_string_post(save_search_string_filter, async_req=True)
        >>> result = thread.get()

        Args:
            save_search_string_filter (SaveSearchStringFilter):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['save_search_string_filter'] = \
            save_search_string_filter
        return self.saved_search_string_filter_api_v2_saved_search_string_post_endpoint.call_with_http_info(**kwargs)

    def search_api_v2_search_all_post(
        self,
        search_string,
        **kwargs
    ):
        """Search  # noqa: E501

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

        >>> thread = api.search_api_v2_search_all_post(search_string, async_req=True)
        >>> result = thread.get()

        Args:
            search_string (str):

        Keyword Args:
            page (int): [optional] if omitted the server will use the default value of 1
            size (int): [optional] if omitted the server will use the default value of 50
            search_node ([SearchNode]): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            SearchV2Response
                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['search_string'] = \
            search_string
        return self.search_api_v2_search_all_post_endpoint.call_with_http_info(**kwargs)

    def search_entities_api_v2_search_get(
        self,
        search_string,
        **kwargs
    ):
        """Search Entities  # noqa: E501

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

        >>> thread = api.search_entities_api_v2_search_get(search_string, async_req=True)
        >>> result = thread.get()

        Args:
            search_string (str):

        Keyword Args:
            page (int): [optional] if omitted the server will use the default value of 1
            size (int): [optional] if omitted the server will use the default value of 50
            _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 (int/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:
            SearchV2Response
                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['search_string'] = \
            search_string
        return self.search_entities_api_v2_search_get_endpoint.call_with_http_info(**kwargs)

    def search_entities_stats_post_api_v1_search_entities_usage_stats_post(
        self,
        platform_id,
        entity_type,
        start_timestamp,
        end_timestamp,
        data_entity_usage_stats_request,
        **kwargs
    ):
        """Search Entities Stats Post  # noqa: E501

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

        >>> thread = api.search_entities_stats_post_api_v1_search_entities_usage_stats_post(platform_id, entity_type, start_timestamp, end_timestamp, data_entity_usage_stats_request, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id ([str]):
            entity_type ([str]):
            start_timestamp (datetime):
            end_timestamp (datetime):
            data_entity_usage_stats_request (DataEntityUsageStatsRequest):

        Keyword Args:
            limit (int): [optional] if omitted the server will use the default value of 50
            offset (int): [optional] if omitted the server will use the default value of 0
            sort ([str]): [optional] if omitted the server will use the default value of ["usageCount:asc"]
            _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 (int/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:
            LimitOffsetPageDataEntityUsageStatsReport
                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['platform_id'] = \
            platform_id
        kwargs['entity_type'] = \
            entity_type
        kwargs['start_timestamp'] = \
            start_timestamp
        kwargs['end_timestamp'] = \
            end_timestamp
        kwargs['data_entity_usage_stats_request'] = \
            data_entity_usage_stats_request
        return self.search_entities_stats_post_api_v1_search_entities_usage_stats_post_endpoint.call_with_http_info(**kwargs)

    def search_with_nodes_api_v2_search_nodes_post(
        self,
        **kwargs
    ):
        """Search With Nodes  # noqa: E501

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

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


        Keyword Args:
            page (int): [optional] if omitted the server will use the default value of 1
            size (int): [optional] if omitted the server will use the default value of 50
            search_node ([SearchNode]): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/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:
            SearchV2Response
                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.search_with_nodes_api_v2_search_nodes_post_endpoint.call_with_http_info(**kwargs)

    def set_org_status_api_v1_organization_status_post(
        self,
        status,
        **kwargs
    ):
        """Set Org Status  # 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_org_status_api_v1_organization_status_post(status, async_req=True)
        >>> result = thread.get()

        Args:
            status (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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['status'] = \
            status
        return self.set_org_status_api_v1_organization_status_post_endpoint.call_with_http_info(**kwargs)

    def sync_platform_rpc_api_v1_platforms_platform_id_rpc_sync_get(
        self,
        platform_id,
        **kwargs
    ):
        """Sync Platform Rpc  # noqa: E501

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

        >>> thread = api.sync_platform_rpc_api_v1_platforms_platform_id_rpc_sync_get(platform_id, async_req=True)
        >>> result = thread.get()

        Args:
            platform_id (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 (int/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:
            DataPlatformGet
                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['platform_id'] = \
            platform_id
        return self.sync_platform_rpc_api_v1_platforms_platform_id_rpc_sync_get_endpoint.call_with_http_info(**kwargs)

    def sync_sheet_api_v1_sync_sheet_get(
        self,
        **kwargs
    ):
        """Sync Sheet  # noqa: E501

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

        >>> thread = api.sync_sheet_api_v1_sync_sheet_get(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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        return self.sync_sheet_api_v1_sync_sheet_get_endpoint.call_with_http_info(**kwargs)

    def test_airflow_platform_api_v1_platforms_airflow_test_post(
        self,
        data_platform_airflow_create,
        **kwargs
    ):
        """Test Airflow Platform  # 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_airflow_platform_api_v1_platforms_airflow_test_post(data_platform_airflow_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_airflow_create (DataPlatformAirflowCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_airflow_create'] = \
            data_platform_airflow_create
        return self.test_airflow_platform_api_v1_platforms_airflow_test_post_endpoint.call_with_http_info(**kwargs)

    def test_bigquery_platform_api_v1_platforms_bigquery_test_post(
        self,
        data_platform_big_query_create,
        **kwargs
    ):
        """Test Bigquery Platform  # 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_bigquery_platform_api_v1_platforms_bigquery_test_post(data_platform_big_query_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_big_query_create (DataPlatformBigQueryCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_big_query_create'] = \
            data_platform_big_query_create
        return self.test_bigquery_platform_api_v1_platforms_bigquery_test_post_endpoint.call_with_http_info(**kwargs)

    def test_databricks_platform_api_v1_platforms_databricks_test_post(
        self,
        data_platform_databricks_create,
        **kwargs
    ):
        """Test Databricks Platform  # 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_databricks_platform_api_v1_platforms_databricks_test_post(data_platform_databricks_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_databricks_create (DataPlatformDatabricksCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_databricks_create'] = \
            data_platform_databricks_create
        return self.test_databricks_platform_api_v1_platforms_databricks_test_post_endpoint.call_with_http_info(**kwargs)

    def test_hive_platform_api_v1_platforms_hive_test_post(
        self,
        data_platform_hive_create,
        **kwargs
    ):
        """Test Hive Platform  # 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_hive_platform_api_v1_platforms_hive_test_post(data_platform_hive_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_hive_create (DataPlatformHiveCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_hive_create'] = \
            data_platform_hive_create
        return self.test_hive_platform_api_v1_platforms_hive_test_post_endpoint.call_with_http_info(**kwargs)

    def test_hiveglue_platform_api_v1_platforms_hiveglue_test_post(
        self,
        data_platform_hive_glue_create,
        **kwargs
    ):
        """Test Hiveglue Platform  # 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_hiveglue_platform_api_v1_platforms_hiveglue_test_post(data_platform_hive_glue_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_hive_glue_create (DataPlatformHiveGlueCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_hive_glue_create'] = \
            data_platform_hive_glue_create
        return self.test_hiveglue_platform_api_v1_platforms_hiveglue_test_post_endpoint.call_with_http_info(**kwargs)

    def test_looker_platform_api_v1_platforms_looker_test_post(
        self,
        data_platform_looker_create,
        **kwargs
    ):
        """Test Looker Platform  # 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_looker_platform_api_v1_platforms_looker_test_post(data_platform_looker_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_looker_create (DataPlatformLookerCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_looker_create'] = \
            data_platform_looker_create
        return self.test_looker_platform_api_v1_platforms_looker_test_post_endpoint.call_with_http_info(**kwargs)

    def test_mode_platform_api_v1_platforms_mode_test_post(
        self,
        data_platform_mode_create,
        **kwargs
    ):
        """Test Mode Platform  # 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_mode_platform_api_v1_platforms_mode_test_post(data_platform_mode_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_mode_create (DataPlatformModeCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_mode_create'] = \
            data_platform_mode_create
        return self.test_mode_platform_api_v1_platforms_mode_test_post_endpoint.call_with_http_info(**kwargs)

    def test_mssql_platform_api_v1_platforms_mssql_test_post(
        self,
        data_platform_mssql_create,
        **kwargs
    ):
        """Test Mssql Platform  # 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_mssql_platform_api_v1_platforms_mssql_test_post(data_platform_mssql_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_mssql_create (DataPlatformMSSQLCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_mssql_create'] = \
            data_platform_mssql_create
        return self.test_mssql_platform_api_v1_platforms_mssql_test_post_endpoint.call_with_http_info(**kwargs)

    def test_mysql_platform_api_v1_platforms_mysql_test_post(
        self,
        data_platform_my_sql_create,
        **kwargs
    ):
        """Test Mysql Platform  # 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_mysql_platform_api_v1_platforms_mysql_test_post(data_platform_my_sql_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_my_sql_create (DataPlatformMySQLCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_my_sql_create'] = \
            data_platform_my_sql_create
        return self.test_mysql_platform_api_v1_platforms_mysql_test_post_endpoint.call_with_http_info(**kwargs)

    def test_postgres_platform_api_v1_platforms_postgres_test_post(
        self,
        data_platform_postgres_create,
        **kwargs
    ):
        """Test Postgres Platform  # 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_postgres_platform_api_v1_platforms_postgres_test_post(data_platform_postgres_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_postgres_create (DataPlatformPostgresCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_postgres_create'] = \
            data_platform_postgres_create
        return self.test_postgres_platform_api_v1_platforms_postgres_test_post_endpoint.call_with_http_info(**kwargs)

    def test_powerbi_platform_api_v1_platforms_powerbi_test_post(
        self,
        data_platform_power_bi_create,
        **kwargs
    ):
        """Test Powerbi Platform  # 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_powerbi_platform_api_v1_platforms_powerbi_test_post(data_platform_power_bi_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_power_bi_create (DataPlatformPowerBICreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_power_bi_create'] = \
            data_platform_power_bi_create
        return self.test_powerbi_platform_api_v1_platforms_powerbi_test_post_endpoint.call_with_http_info(**kwargs)

    def test_redshift_platform_api_v1_platforms_redshift_test_post(
        self,
        data_platform_redshift_create,
        **kwargs
    ):
        """Test Redshift Platform  # 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_redshift_platform_api_v1_platforms_redshift_test_post(data_platform_redshift_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_redshift_create (DataPlatformRedshiftCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_redshift_create'] = \
            data_platform_redshift_create
        return self.test_redshift_platform_api_v1_platforms_redshift_test_post_endpoint.call_with_http_info(**kwargs)

    def test_snowflake_platform_api_v1_platforms_snowflake_test_post(
        self,
        data_platform_snowflake_create,
        **kwargs
    ):
        """Test Snowflake Platform  # 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_snowflake_platform_api_v1_platforms_snowflake_test_post(data_platform_snowflake_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_snowflake_create (DataPlatformSnowflakeCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_snowflake_create'] = \
            data_platform_snowflake_create
        return self.test_snowflake_platform_api_v1_platforms_snowflake_test_post_endpoint.call_with_http_info(**kwargs)

    def test_tableau_platform_api_v1_platforms_tableau_test_post(
        self,
        data_platform_tableau_create,
        **kwargs
    ):
        """Test Tableau Platform  # 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_tableau_platform_api_v1_platforms_tableau_test_post(data_platform_tableau_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_tableau_create (DataPlatformTableauCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_tableau_create'] = \
            data_platform_tableau_create
        return self.test_tableau_platform_api_v1_platforms_tableau_test_post_endpoint.call_with_http_info(**kwargs)

    def test_treasuredata_platform_api_v1_platforms_treasuredata_test_post(
        self,
        data_platform_treasure_data_create,
        **kwargs
    ):
        """Test Treasuredata Platform  # 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_treasuredata_platform_api_v1_platforms_treasuredata_test_post(data_platform_treasure_data_create, async_req=True)
        >>> result = thread.get()

        Args:
            data_platform_treasure_data_create (DataPlatformTreasureDataCreate):

        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 (int/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:
            DataPlatformFull
                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['data_platform_treasure_data_create'] = \
            data_platform_treasure_data_create
        return self.test_treasuredata_platform_api_v1_platforms_treasuredata_test_post_endpoint.call_with_http_info(**kwargs)

    def tinyurl_api_v1_tinyurl_get(
        self,
        code,
        **kwargs
    ):
        """Tinyurl  # noqa: E501

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

        >>> thread = api.tinyurl_api_v1_tinyurl_get(code, async_req=True)
        >>> result = thread.get()

        Args:
            code (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 (int/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:
            TinyURLResponse
                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['code'] = \
            code
        return self.tinyurl_api_v1_tinyurl_get_endpoint.call_with_http_info(**kwargs)

    def update_invite_to_organization_status_api_v2_users_invite_put(
        self,
        invite_id,
        status,
        **kwargs
    ):
        """Update Invite To Organization Status  # 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_invite_to_organization_status_api_v2_users_invite_put(invite_id, status, async_req=True)
        >>> result = thread.get()

        Args:
            invite_id (str):
            status (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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['invite_id'] = \
            invite_id
        kwargs['status'] = \
            status
        return self.update_invite_to_organization_status_api_v2_users_invite_put_endpoint.call_with_http_info(**kwargs)

    def update_user_in_org_api_v2_user_put(
        self,
        user_create_request,
        **kwargs
    ):
        """Update User In Org  # 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_user_in_org_api_v2_user_put(user_create_request, async_req=True)
        >>> result = thread.get()

        Args:
            user_create_request (UserCreateRequest):

        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 (int/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:
            bool, date, datetime, dict, float, int, list, str, none_type
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['user_create_request'] = \
            user_create_request
        return self.update_user_in_org_api_v2_user_put_endpoint.call_with_http_info(**kwargs)

    def validate_impact_analysis_query_api_v2_impact_analysis_validate_query_post(
        self,
        impact_analysis_request,
        **kwargs
    ):
        """Validate Impact Analysis Query  # noqa: E501

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

        >>> thread = api.validate_impact_analysis_query_api_v2_impact_analysis_validate_query_post(impact_analysis_request, async_req=True)
        >>> result = thread.get()

        Args:
            impact_analysis_request (ImpactAnalysisRequest):

        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 (int/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:
            ImpactAnalysisQueryValidation
                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['impact_analysis_request'] = \
            impact_analysis_request
        return self.validate_impact_analysis_query_api_v2_impact_analysis_validate_query_post_endpoint.call_with_http_info(**kwargs)

