text: """
      OpenAPI Petstore
  
      This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\  # noqa: E501
  
      The version of the OpenAPI document: 1.0.0
      Generated by: https://openapi-generator.tech
  """
  
  
  import re  # noqa: F401
  import sys  # noqa: F401
  
  from petstore_api.api_client import ApiClient, Endpoint as _Endpoint
  from petstore_api.model_utils import (  # noqa: F401
      check_allowed_values,
      check_validations,
      date,
      datetime,
      file_type,
      none_type,
      validate_and_convert_types
  )
  from petstore_api.model.additional_properties_with_array_of_enums import AdditionalPropertiesWithArrayOfEnums
  from petstore_api.model.animal_farm import AnimalFarm
  from petstore_api.model.api_response import ApiResponse
  from petstore_api.model.array_of_enums import ArrayOfEnums
  from petstore_api.model.client import Client
  from petstore_api.model.composed_one_of_number_with_validations import ComposedOneOfNumberWithValidations
  from petstore_api.model.enum_test import EnumTest
  from petstore_api.model.file_schema_test_class import FileSchemaTestClass
  from petstore_api.model.gm_fruit_no_properties import GmFruitNoProperties
  from petstore_api.model.health_check_result import HealthCheckResult
  from petstore_api.model.inline_additional_properties_ref_payload import InlineAdditionalPropertiesRefPayload
  from petstore_api.model.inline_object6 import InlineObject6
  from petstore_api.model.mammal import Mammal
  from petstore_api.model.number_with_validations import NumberWithValidations
  from petstore_api.model.object_model_with_ref_props import ObjectModelWithRefProps
  from petstore_api.model.string_enum import StringEnum
  from petstore_api.model.user import User
  
  
  class FakeApi(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.additional_properties_with_array_of_enums_endpoint = _Endpoint(
              settings={
                  'response_type': (AdditionalPropertiesWithArrayOfEnums,),
                  'auth': [],
                  'endpoint_path': '/fake/additional-properties-with-array-of-enums',
                  'operation_id': 'additional_properties_with_array_of_enums',
                  'http_method': 'GET',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'additional_properties_with_array_of_enums',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'additional_properties_with_array_of_enums':
                          (AdditionalPropertiesWithArrayOfEnums,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'additional_properties_with_array_of_enums': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.array_model_endpoint = _Endpoint(
              settings={
                  'response_type': (AnimalFarm,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/arraymodel',
                  'operation_id': 'array_model',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'body',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'body':
                          (AnimalFarm,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'body': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.array_of_enums_endpoint = _Endpoint(
              settings={
                  'response_type': (ArrayOfEnums,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/array-of-enums',
                  'operation_id': 'array_of_enums',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'array_of_enums',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'array_of_enums':
                          (ArrayOfEnums,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'array_of_enums': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.boolean_endpoint = _Endpoint(
              settings={
                  'response_type': (bool,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/boolean',
                  'operation_id': 'boolean',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'body',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'body':
                          (bool,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'body': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.composed_one_of_number_with_validations_endpoint = _Endpoint(
              settings={
                  'response_type': (ComposedOneOfNumberWithValidations,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/composed_one_of_number_with_validations',
                  'operation_id': 'composed_one_of_number_with_validations',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'composed_one_of_number_with_validations',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'composed_one_of_number_with_validations':
                          (ComposedOneOfNumberWithValidations,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'composed_one_of_number_with_validations': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.download_attachment_endpoint = _Endpoint(
              settings={
                  'response_type': (file_type,),
                  'auth': [],
                  'endpoint_path': '/{fileName}',
                  'operation_id': 'download_attachment',
                  'http_method': 'GET',
                  'servers': [
                      {
                          'url': "http://www.jtricks.com",
                          'description': "No description provided",
                      },
                  ]
              },
              params_map={
                  'all': [
                      'file_name',
                  ],
                  'required': [
                      'file_name',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'file_name':
                          (str,),
                  },
                  'attribute_map': {
                      'file_name': 'fileName',
                  },
                  'location_map': {
                      'file_name': 'path',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'text/plain'
                  ],
                  'content_type': [],
              },
              api_client=api_client
          )
          self.enum_test_endpoint = _Endpoint(
              settings={
                  'response_type': (EnumTest,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/enum-test',
                  'operation_id': 'enum_test',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'enum_test',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'enum_test':
                          (EnumTest,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'enum_test': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.fake_health_get_endpoint = _Endpoint(
              settings={
                  'response_type': (HealthCheckResult,),
                  'auth': [],
                  'endpoint_path': '/fake/health',
                  'operation_id': 'fake_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.mammal_endpoint = _Endpoint(
              settings={
                  'response_type': (Mammal,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/mammal',
                  'operation_id': 'mammal',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'mammal',
                  ],
                  'required': [
                      'mammal',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'mammal':
                          (Mammal,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'mammal': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.number_with_validations_endpoint = _Endpoint(
              settings={
                  'response_type': (NumberWithValidations,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/number',
                  'operation_id': 'number_with_validations',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'body',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'body':
                          (NumberWithValidations,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'body': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.object_model_with_ref_props_endpoint = _Endpoint(
              settings={
                  'response_type': (ObjectModelWithRefProps,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/object_model_with_ref_props',
                  'operation_id': 'object_model_with_ref_props',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'body',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'body':
                          (ObjectModelWithRefProps,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'body': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.post_inline_additional_properties_payload_endpoint = _Endpoint(
              settings={
                  'response_type': (InlineObject6,),
                  'auth': [],
                  'endpoint_path': '/fake/postInlineAdditionalPropertiesPayload',
                  'operation_id': 'post_inline_additional_properties_payload',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'inline_object6',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'inline_object6':
                          (InlineObject6,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'inline_object6': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.post_inline_additional_properties_ref_payload_endpoint = _Endpoint(
              settings={
                  'response_type': (InlineAdditionalPropertiesRefPayload,),
                  'auth': [],
                  'endpoint_path': '/fake/postInlineAdditionalPropertiesRefPayload',
                  'operation_id': 'post_inline_additional_properties_ref_payload',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'inline_additional_properties_ref_payload',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'inline_additional_properties_ref_payload':
                          (InlineAdditionalPropertiesRefPayload,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'inline_additional_properties_ref_payload': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.string_endpoint = _Endpoint(
              settings={
                  'response_type': (str,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/string',
                  'operation_id': 'string',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'body',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'body':
                          (str,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'body': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.string_enum_endpoint = _Endpoint(
              settings={
                  'response_type': (StringEnum,),
                  'auth': [],
                  'endpoint_path': '/fake/refs/enum',
                  'operation_id': 'string_enum',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'body',
                  ],
                  'required': [],
                  'nullable': [
                      'body',
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'body':
                          (StringEnum,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'body': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.test_body_with_file_schema_endpoint = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [],
                  'endpoint_path': '/fake/body-with-file-schema',
                  'operation_id': 'test_body_with_file_schema',
                  'http_method': 'PUT',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'file_schema_test_class',
                  ],
                  'required': [
                      'file_schema_test_class',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'file_schema_test_class':
                          (FileSchemaTestClass,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'file_schema_test_class': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.test_body_with_query_params_endpoint = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [],
                  'endpoint_path': '/fake/body-with-query-params',
                  'operation_id': 'test_body_with_query_params',
                  'http_method': 'PUT',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'query',
                      'user',
                  ],
                  'required': [
                      'query',
                      'user',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'query':
                          (str,),
                      'user':
                          (User,),
                  },
                  'attribute_map': {
                      'query': 'query',
                  },
                  'location_map': {
                      'query': 'query',
                      'user': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.test_client_model_endpoint = _Endpoint(
              settings={
                  'response_type': (Client,),
                  'auth': [],
                  'endpoint_path': '/fake',
                  'operation_id': 'test_client_model',
                  'http_method': 'PATCH',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'client',
                  ],
                  'required': [
                      'client',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'client':
                          (Client,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'client': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.test_endpoint_parameters_endpoint = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [
                      'http_basic_test'
                  ],
                  'endpoint_path': '/fake',
                  'operation_id': 'test_endpoint_parameters',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'number',
                      'double',
                      'pattern_without_delimiter',
                      'byte',
                      'integer',
                      'int32',
                      'int64',
                      'float',
                      'string',
                      'binary',
                      'date',
                      'date_time',
                      'password',
                      'param_callback',
                  ],
                  'required': [
                      'number',
                      'double',
                      'pattern_without_delimiter',
                      'byte',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                      'number',
                      'double',
                      'pattern_without_delimiter',
                      'integer',
                      'int32',
                      'float',
                      'string',
                      'password',
                  ]
              },
              root_map={
                  'validations': {
                      ('number',): {
  
                          'inclusive_maximum': 543.2,
                          'inclusive_minimum': 32.1,
                      },
                      ('double',): {
  
                          'exclusive_maximum': 123.4,
                          'inclusive_minimum': 67.8,
                      },
                      ('pattern_without_delimiter',): {
  
                          'regex': {
                              'pattern': r'^[A-Z].*',  # noqa: E501
                          },
                      },
                      ('integer',): {
  
                          'inclusive_maximum': 100,
                          'inclusive_minimum': 10,
                      },
                      ('int32',): {
  
                          'inclusive_maximum': 200,
                          'inclusive_minimum': 20,
                      },
                      ('float',): {
  
                          'exclusive_maximum': 987.6,
                      },
                      ('string',): {
  
                          'regex': {
                              'pattern': r'[a-z]',  # noqa: E501
                              'flags': (re.IGNORECASE)
                          },
                      },
                      ('password',): {
                          'max_length': 64,
                          'min_length': 10,
                      },
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'number':
                          (float,),
                      'double':
                          (float,),
                      'pattern_without_delimiter':
                          (str,),
                      'byte':
                          (str,),
                      'integer':
                          (int,),
                      'int32':
                          (int,),
                      'int64':
                          (int,),
                      'float':
                          (float,),
                      'string':
                          (str,),
                      'binary':
                          (file_type,),
                      'date':
                          (date,),
                      'date_time':
                          (datetime,),
                      'password':
                          (str,),
                      'param_callback':
                          (str,),
                  },
                  'attribute_map': {
                      'number': 'number',
                      'double': 'double',
                      'pattern_without_delimiter': 'pattern_without_delimiter',
                      'byte': 'byte',
                      'integer': 'integer',
                      'int32': 'int32',
                      'int64': 'int64',
                      'float': 'float',
                      'string': 'string',
                      'binary': 'binary',
                      'date': 'date',
                      'date_time': 'dateTime',
                      'password': 'password',
                      'param_callback': 'callback',
                  },
                  'location_map': {
                      'number': 'form',
                      'double': 'form',
                      'pattern_without_delimiter': 'form',
                      'byte': 'form',
                      'integer': 'form',
                      'int32': 'form',
                      'int64': 'form',
                      'float': 'form',
                      'string': 'form',
                      'binary': 'form',
                      'date': 'form',
                      'date_time': 'form',
                      'password': 'form',
                      'param_callback': 'form',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [],
                  'content_type': [
                      'application/x-www-form-urlencoded'
                  ]
              },
              api_client=api_client
          )
          self.test_enum_parameters_endpoint = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [],
                  'endpoint_path': '/fake',
                  'operation_id': 'test_enum_parameters',
                  'http_method': 'GET',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'enum_header_string_array',
                      'enum_header_string',
                      'enum_query_string_array',
                      'enum_query_string',
                      'enum_query_integer',
                      'enum_query_double',
                      'enum_form_string_array',
                      'enum_form_string',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                      'enum_header_string_array',
                      'enum_header_string',
                      'enum_query_string_array',
                      'enum_query_string',
                      'enum_query_integer',
                      'enum_query_double',
                      'enum_form_string_array',
                      'enum_form_string',
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                      ('enum_header_string_array',): {
  
                          "&gt;": ">",
                          "$": "$"
                      },
                      ('enum_header_string',): {
  
                          "_ABC": "_abc",
                          "-EFG": "-efg",
                          "(XYZ)": "(xyz)"
                      },
                      ('enum_query_string_array',): {
  
                          "&gt;": ">",
                          "$": "$"
                      },
                      ('enum_query_string',): {
  
                          "_ABC": "_abc",
                          "-EFG": "-efg",
                          "(XYZ)": "(xyz)"
                      },
                      ('enum_query_integer',): {
  
                          "1": 1,
                          "-2": -2
                      },
                      ('enum_query_double',): {
  
                          "1.1": 1.1,
                          "-1.2": -1.2
                      },
                      ('enum_form_string_array',): {
  
                          "&gt;": ">",
                          "$": "$"
                      },
                      ('enum_form_string',): {
  
                          "_ABC": "_abc",
                          "-EFG": "-efg",
                          "(XYZ)": "(xyz)"
                      },
                  },
                  'openapi_types': {
                      'enum_header_string_array':
                          ([str],),
                      'enum_header_string':
                          (str,),
                      'enum_query_string_array':
                          ([str],),
                      'enum_query_string':
                          (str,),
                      'enum_query_integer':
                          (int,),
                      'enum_query_double':
                          (float,),
                      'enum_form_string_array':
                          ([str],),
                      'enum_form_string':
                          (str,),
                  },
                  'attribute_map': {
                      'enum_header_string_array': 'enum_header_string_array',
                      'enum_header_string': 'enum_header_string',
                      'enum_query_string_array': 'enum_query_string_array',
                      'enum_query_string': 'enum_query_string',
                      'enum_query_integer': 'enum_query_integer',
                      'enum_query_double': 'enum_query_double',
                      'enum_form_string_array': 'enum_form_string_array',
                      'enum_form_string': 'enum_form_string',
                  },
                  'location_map': {
                      'enum_header_string_array': 'header',
                      'enum_header_string': 'header',
                      'enum_query_string_array': 'query',
                      'enum_query_string': 'query',
                      'enum_query_integer': 'query',
                      'enum_query_double': 'query',
                      'enum_form_string_array': 'form',
                      'enum_form_string': 'form',
                  },
                  'collection_format_map': {
                      'enum_header_string_array': 'csv',
                      'enum_query_string_array': 'multi',
                      'enum_form_string_array': 'csv',
                  }
              },
              headers_map={
                  'accept': [],
                  'content_type': [
                      'application/x-www-form-urlencoded'
                  ]
              },
              api_client=api_client
          )
          self.test_group_parameters_endpoint = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [
                      'bearer_test'
                  ],
                  'endpoint_path': '/fake',
                  'operation_id': 'test_group_parameters',
                  'http_method': 'DELETE',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'required_string_group',
                      'required_boolean_group',
                      'required_int64_group',
                      'string_group',
                      'boolean_group',
                      'int64_group',
                  ],
                  'required': [
                      'required_string_group',
                      'required_boolean_group',
                      'required_int64_group',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'required_string_group':
                          (int,),
                      'required_boolean_group':
                          (bool,),
                      'required_int64_group':
                          (int,),
                      'string_group':
                          (int,),
                      'boolean_group':
                          (bool,),
                      'int64_group':
                          (int,),
                  },
                  'attribute_map': {
                      'required_string_group': 'required_string_group',
                      'required_boolean_group': 'required_boolean_group',
                      'required_int64_group': 'required_int64_group',
                      'string_group': 'string_group',
                      'boolean_group': 'boolean_group',
                      'int64_group': 'int64_group',
                  },
                  'location_map': {
                      'required_string_group': 'query',
                      'required_boolean_group': 'header',
                      'required_int64_group': 'query',
                      'string_group': 'query',
                      'boolean_group': 'header',
                      'int64_group': 'query',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [],
                  'content_type': [],
              },
              api_client=api_client
          )
          self.test_inline_additional_properties_endpoint = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [],
                  'endpoint_path': '/fake/inline-additionalProperties',
                  'operation_id': 'test_inline_additional_properties',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'request_body',
                  ],
                  'required': [
                      'request_body',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'request_body':
                          ({str: (str,)},),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'request_body': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.test_json_form_data_endpoint = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [],
                  'endpoint_path': '/fake/jsonFormData',
                  'operation_id': 'test_json_form_data',
                  'http_method': 'GET',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'param',
                      'param2',
                  ],
                  'required': [
                      'param',
                      'param2',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'param':
                          (str,),
                      'param2':
                          (str,),
                  },
                  'attribute_map': {
                      'param': 'param',
                      'param2': 'param2',
                  },
                  'location_map': {
                      'param': 'form',
                      'param2': 'form',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [],
                  'content_type': [
                      'application/x-www-form-urlencoded'
                  ]
              },
              api_client=api_client
          )
          self.test_query_parameter_collection_format_endpoint = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [],
                  'endpoint_path': '/fake/test-query-parameters',
                  'operation_id': 'test_query_parameter_collection_format',
                  'http_method': 'PUT',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'pipe',
                      'ioutil',
                      'http',
                      'url',
                      'context',
                  ],
                  'required': [
                      'pipe',
                      'ioutil',
                      'http',
                      'url',
                      'context',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'pipe':
                          ([str],),
                      'ioutil':
                          ([str],),
                      'http':
                          ([str],),
                      'url':
                          ([str],),
                      'context':
                          ([str],),
                  },
                  'attribute_map': {
                      'pipe': 'pipe',
                      'ioutil': 'ioutil',
                      'http': 'http',
                      'url': 'url',
                      'context': 'context',
                  },
                  'location_map': {
                      'pipe': 'query',
                      'ioutil': 'query',
                      'http': 'query',
                      'url': 'query',
                      'context': 'query',
                  },
                  'collection_format_map': {
                      'pipe': 'multi',
                      'ioutil': 'csv',
                      'http': 'ssv',
                      'url': 'csv',
                      'context': 'multi',
                  }
              },
              headers_map={
                  'accept': [],
                  'content_type': [],
              },
              api_client=api_client
          )
          self.tx_rx_any_of_model_endpoint = _Endpoint(
              settings={
                  'response_type': (GmFruitNoProperties,),
                  'auth': [],
                  'endpoint_path': '/fake/TxRxAnyOfModel',
                  'operation_id': 'tx_rx_any_of_model',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'gm_fruit_no_properties',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'gm_fruit_no_properties':
                          (GmFruitNoProperties,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'gm_fruit_no_properties': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/json'
                  ]
              },
              api_client=api_client
          )
          self.upload_download_file_endpoint = _Endpoint(
              settings={
                  'response_type': (file_type,),
                  'auth': [],
                  'endpoint_path': '/fake/uploadDownloadFile',
                  'operation_id': 'upload_download_file',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'body',
                  ],
                  'required': [
                      'body',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'body':
                          (file_type,),
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                      'body': 'body',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/octet-stream'
                  ],
                  'content_type': [
                      'application/octet-stream'
                  ]
              },
              api_client=api_client
          )
          self.upload_file_endpoint = _Endpoint(
              settings={
                  'response_type': (ApiResponse,),
                  'auth': [],
                  'endpoint_path': '/fake/uploadFile',
                  'operation_id': 'upload_file',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'file',
                      'additional_metadata',
                  ],
                  'required': [
                      'file',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'file':
                          (file_type,),
                      'additional_metadata':
                          (str,),
                  },
                  'attribute_map': {
                      'file': 'file',
                      'additional_metadata': 'additionalMetadata',
                  },
                  'location_map': {
                      'file': 'form',
                      'additional_metadata': 'form',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'multipart/form-data'
                  ]
              },
              api_client=api_client
          )
          self.upload_files_endpoint = _Endpoint(
              settings={
                  'response_type': (ApiResponse,),
                  'auth': [],
                  'endpoint_path': '/fake/uploadFiles',
                  'operation_id': 'upload_files',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'files',
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'files':
                          ([file_type],),
                  },
                  'attribute_map': {
                      'files': 'files',
                  },
                  'location_map': {
                      'files': 'form',
                  },
                  'collection_format_map': {
                      'files': 'csv',
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'multipart/form-data'
                  ]
              },
              api_client=api_client
          )
  
      def additional_properties_with_array_of_enums(
          self,
          **kwargs
      ):
          """Additional Properties with Array of Enums  # noqa: E501
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.additional_properties_with_array_of_enums(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              additional_properties_with_array_of_enums (AdditionalPropertiesWithArrayOfEnums): Input enum. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              AdditionalPropertiesWithArrayOfEnums
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.additional_properties_with_array_of_enums_endpoint.call_with_http_info(**kwargs)
  
      def array_model(
          self,
          **kwargs
      ):
          """array_model  # noqa: E501
  
          Test serialization of ArrayModel  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.array_model(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              body (AnimalFarm): Input model. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              AnimalFarm
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.array_model_endpoint.call_with_http_info(**kwargs)
  
      def array_of_enums(
          self,
          **kwargs
      ):
          """Array of Enums  # noqa: E501
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.array_of_enums(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              array_of_enums (ArrayOfEnums): Input enum. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              ArrayOfEnums
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.array_of_enums_endpoint.call_with_http_info(**kwargs)
  
      def boolean(
          self,
          **kwargs
      ):
          """boolean  # noqa: E501
  
          Test serialization of outer boolean types  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.boolean(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              body (bool): Input boolean as post body. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.boolean_endpoint.call_with_http_info(**kwargs)
  
      def composed_one_of_number_with_validations(
          self,
          **kwargs
      ):
          """composed_one_of_number_with_validations  # noqa: E501
  
          Test serialization of object with $refed properties  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.composed_one_of_number_with_validations(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              composed_one_of_number_with_validations (ComposedOneOfNumberWithValidations): Input model. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              ComposedOneOfNumberWithValidations
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.composed_one_of_number_with_validations_endpoint.call_with_http_info(**kwargs)
  
      def download_attachment(
          self,
          file_name,
          **kwargs
      ):
          """downloads a file using Content-Disposition  # noqa: E501
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.download_attachment(file_name, async_req=True)
          >>> result = thread.get()
  
          Args:
              file_name (str): file name
  
          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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              file_type
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['file_name'] = \
              file_name
          return self.download_attachment_endpoint.call_with_http_info(**kwargs)
  
      def enum_test(
          self,
          **kwargs
      ):
          """Object contains enum properties and array properties containing enums  # noqa: E501
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.enum_test(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              enum_test (EnumTest): Input object. [optional]
              _return_http_data_only (bool): response data without head status
                  code and headers. Default is True.
              _preload_content (bool): if False, the urllib3.HTTPResponse object
                  will be returned without reading/decoding response data.
                  Default is True.
              _request_timeout (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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              EnumTest
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.enum_test_endpoint.call_with_http_info(**kwargs)
  
      def fake_health_get(
          self,
          **kwargs
      ):
          """Health check endpoint  # noqa: E501
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.fake_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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              HealthCheckResult
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.fake_health_get_endpoint.call_with_http_info(**kwargs)
  
      def mammal(
          self,
          mammal,
          **kwargs
      ):
          """mammal  # noqa: E501
  
          Test serialization of mammals  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.mammal(mammal, async_req=True)
          >>> result = thread.get()
  
          Args:
              mammal (Mammal): Input mammal
  
          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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              Mammal
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['mammal'] = \
              mammal
          return self.mammal_endpoint.call_with_http_info(**kwargs)
  
      def number_with_validations(
          self,
          **kwargs
      ):
          """number_with_validations  # noqa: E501
  
          Test serialization of outer number types  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.number_with_validations(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              body (NumberWithValidations): Input number as post body. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              NumberWithValidations
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.number_with_validations_endpoint.call_with_http_info(**kwargs)
  
      def object_model_with_ref_props(
          self,
          **kwargs
      ):
          """object_model_with_ref_props  # noqa: E501
  
          Test serialization of object with $refed properties  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.object_model_with_ref_props(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              body (ObjectModelWithRefProps): Input model. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              ObjectModelWithRefProps
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.object_model_with_ref_props_endpoint.call_with_http_info(**kwargs)
  
      def post_inline_additional_properties_payload(
          self,
          **kwargs
      ):
          """post_inline_additional_properties_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.post_inline_additional_properties_payload(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              inline_object6 (InlineObject6): [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              InlineObject6
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.post_inline_additional_properties_payload_endpoint.call_with_http_info(**kwargs)
  
      def post_inline_additional_properties_ref_payload(
          self,
          **kwargs
      ):
          """post_inline_additional_properties_ref_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.post_inline_additional_properties_ref_payload(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              inline_additional_properties_ref_payload (InlineAdditionalPropertiesRefPayload): [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              InlineAdditionalPropertiesRefPayload
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.post_inline_additional_properties_ref_payload_endpoint.call_with_http_info(**kwargs)
  
      def string(
          self,
          **kwargs
      ):
          """string  # noqa: E501
  
          Test serialization of outer string types  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.string(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              body (str): Input string as post body. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.string_endpoint.call_with_http_info(**kwargs)
  
      def string_enum(
          self,
          **kwargs
      ):
          """string_enum  # noqa: E501
  
          Test serialization of outer enum  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.string_enum(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              body (StringEnum): Input enum. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              StringEnum
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.string_enum_endpoint.call_with_http_info(**kwargs)
  
      def test_body_with_file_schema(
          self,
          file_schema_test_class,
          **kwargs
      ):
          """test_body_with_file_schema  # noqa: E501
  
          For this test, the body for this request much reference a schema named `File`.  # 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_body_with_file_schema(file_schema_test_class, async_req=True)
          >>> result = thread.get()
  
          Args:
              file_schema_test_class (FileSchemaTestClass):
  
          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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _host_index (int/None): specifies the index of the server
                  that we want to use.
                  Default is read from the configuration.
              async_req (bool): execute request asynchronously
  
          Returns:
              None
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['file_schema_test_class'] = \
              file_schema_test_class
          return self.test_body_with_file_schema_endpoint.call_with_http_info(**kwargs)
  
      def test_body_with_query_params(
          self,
          query,
          user,
          **kwargs
      ):
          """test_body_with_query_params  # 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_body_with_query_params(query, user, async_req=True)
          >>> result = thread.get()
  
          Args:
              query (str):
              user (User):
  
          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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _host_index (int/None): specifies the index of the server
                  that we want to use.
                  Default is read from the configuration.
              async_req (bool): execute request asynchronously
  
          Returns:
              None
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['query'] = \
              query
          kwargs['user'] = \
              user
          return self.test_body_with_query_params_endpoint.call_with_http_info(**kwargs)
  
      def test_client_model(
          self,
          client,
          **kwargs
      ):
          """To test \"client\" model  # noqa: E501
  
          To test \"client\" model  # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.test_client_model(client, async_req=True)
          >>> result = thread.get()
  
          Args:
              client (Client): client model
  
          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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              Client
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['client'] = \
              client
          return self.test_client_model_endpoint.call_with_http_info(**kwargs)
  
      def test_endpoint_parameters(
          self,
          number,
          double,
          pattern_without_delimiter,
          byte,
          **kwargs
      ):
          """Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트   # noqa: E501
  
          Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트   # 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_endpoint_parameters(number, double, pattern_without_delimiter, byte, async_req=True)
          >>> result = thread.get()
  
          Args:
              number (float): None
              double (float): None
              pattern_without_delimiter (str): None
              byte (str): None
  
          Keyword Args:
              integer (int): None. [optional]
              int32 (int): None. [optional]
              int64 (int): None. [optional]
              float (float): None. [optional]
              string (str): None. [optional]
              binary (file_type): None. [optional]
              date (date): None. [optional]
              date_time (datetime): None. [optional] if omitted the server will use the default value of dateutil_parser('2010-02-01T10:20:10.11111+01:00')
              password (str): None. [optional]
              param_callback (str): None. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _host_index (int/None): specifies the index of the server
                  that we want to use.
                  Default is read from the configuration.
              async_req (bool): execute request asynchronously
  
          Returns:
              None
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['number'] = \
              number
          kwargs['double'] = \
              double
          kwargs['pattern_without_delimiter'] = \
              pattern_without_delimiter
          kwargs['byte'] = \
              byte
          return self.test_endpoint_parameters_endpoint.call_with_http_info(**kwargs)
  
      def test_enum_parameters(
          self,
          **kwargs
      ):
          """To test enum parameters  # noqa: E501
  
          To test enum parameters  # 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_enum_parameters(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              enum_header_string_array ([str]): Header parameter enum test (string array). [optional]
              enum_header_string (str): Header parameter enum test (string). [optional] if omitted the server will use the default value of "-efg"
              enum_query_string_array ([str]): Query parameter enum test (string array). [optional]
              enum_query_string (str): Query parameter enum test (string). [optional] if omitted the server will use the default value of "-efg"
              enum_query_integer (int): Query parameter enum test (double). [optional]
              enum_query_double (float): Query parameter enum test (double). [optional]
              enum_form_string_array ([str]): Form parameter enum test (string array). [optional] if omitted the server will use the default value of "$"
              enum_form_string (str): Form parameter enum test (string). [optional] if omitted the server will use the default value of "-efg"
              _return_http_data_only (bool): response data without head status
                  code and headers. Default 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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _host_index (int/None): specifies the index of the server
                  that we want to use.
                  Default is read from the configuration.
              async_req (bool): execute request asynchronously
  
          Returns:
              None
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.test_enum_parameters_endpoint.call_with_http_info(**kwargs)
  
      def test_group_parameters(
          self,
          required_string_group,
          required_boolean_group,
          required_int64_group,
          **kwargs
      ):
          """Fake endpoint to test group parameters (optional)  # noqa: E501
  
          Fake endpoint to test group parameters (optional)  # 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_group_parameters(required_string_group, required_boolean_group, required_int64_group, async_req=True)
          >>> result = thread.get()
  
          Args:
              required_string_group (int): Required String in group parameters
              required_boolean_group (bool): Required Boolean in group parameters
              required_int64_group (int): Required Integer in group parameters
  
          Keyword Args:
              string_group (int): String in group parameters. [optional]
              boolean_group (bool): Boolean in group parameters. [optional]
              int64_group (int): Integer in group parameters. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _host_index (int/None): specifies the index of the server
                  that we want to use.
                  Default is read from the configuration.
              async_req (bool): execute request asynchronously
  
          Returns:
              None
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['required_string_group'] = \
              required_string_group
          kwargs['required_boolean_group'] = \
              required_boolean_group
          kwargs['required_int64_group'] = \
              required_int64_group
          return self.test_group_parameters_endpoint.call_with_http_info(**kwargs)
  
      def test_inline_additional_properties(
          self,
          request_body,
          **kwargs
      ):
          """test inline additionalProperties  # noqa: E501
  
            # 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_inline_additional_properties(request_body, async_req=True)
          >>> result = thread.get()
  
          Args:
              request_body ({str: (str,)}): request body
  
          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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _host_index (int/None): specifies the index of the server
                  that we want to use.
                  Default is read from the configuration.
              async_req (bool): execute request asynchronously
  
          Returns:
              None
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['request_body'] = \
              request_body
          return self.test_inline_additional_properties_endpoint.call_with_http_info(**kwargs)
  
      def test_json_form_data(
          self,
          param,
          param2,
          **kwargs
      ):
          """test json serialization of form data  # noqa: E501
  
            # 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_json_form_data(param, param2, async_req=True)
          >>> result = thread.get()
  
          Args:
              param (str): field1
              param2 (str): field2
  
          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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _host_index (int/None): specifies the index of the server
                  that we want to use.
                  Default is read from the configuration.
              async_req (bool): execute request asynchronously
  
          Returns:
              None
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['param'] = \
              param
          kwargs['param2'] = \
              param2
          return self.test_json_form_data_endpoint.call_with_http_info(**kwargs)
  
      def test_query_parameter_collection_format(
          self,
          pipe,
          ioutil,
          http,
          url,
          context,
          **kwargs
      ):
          """test_query_parameter_collection_format  # noqa: E501
  
          To test the collection format in query parameters  # 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_query_parameter_collection_format(pipe, ioutil, http, url, context, async_req=True)
          >>> result = thread.get()
  
          Args:
              pipe ([str]):
              ioutil ([str]):
              http ([str]):
              url ([str]):
              context ([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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _host_index (int/None): specifies the index of the server
                  that we want to use.
                  Default is read from the configuration.
              async_req (bool): execute request asynchronously
  
          Returns:
              None
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['pipe'] = \
              pipe
          kwargs['ioutil'] = \
              ioutil
          kwargs['http'] = \
              http
          kwargs['url'] = \
              url
          kwargs['context'] = \
              context
          return self.test_query_parameter_collection_format_endpoint.call_with_http_info(**kwargs)
  
      def tx_rx_any_of_model(
          self,
          **kwargs
      ):
          """tx_rx_any_of_model  # noqa: E501
  
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.tx_rx_any_of_model(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              gm_fruit_no_properties (GmFruitNoProperties): [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              GmFruitNoProperties
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.tx_rx_any_of_model_endpoint.call_with_http_info(**kwargs)
  
      def upload_download_file(
          self,
          body,
          **kwargs
      ):
          """uploads a file and downloads a file using application/octet-stream  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.upload_download_file(body, async_req=True)
          >>> result = thread.get()
  
          Args:
              body (file_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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              file_type
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['body'] = \
              body
          return self.upload_download_file_endpoint.call_with_http_info(**kwargs)
  
      def upload_file(
          self,
          file,
          **kwargs
      ):
          """uploads a file using multipart/form-data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.upload_file(file, async_req=True)
          >>> result = thread.get()
  
          Args:
              file (file_type): file to upload
  
          Keyword Args:
              additional_metadata (str): Additional data to pass to server. [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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              ApiResponse
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          kwargs['file'] = \
              file
          return self.upload_file_endpoint.call_with_http_info(**kwargs)
  
      def upload_files(
          self,
          **kwargs
      ):
          """uploads files using multipart/form-data  # noqa: E501
  
            # noqa: E501
          This method makes a synchronous HTTP request by default. To make an
          asynchronous HTTP request, please pass async_req=True
  
          >>> thread = api.upload_files(async_req=True)
          >>> result = thread.get()
  
  
          Keyword Args:
              files ([file_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.
              _spec_property_naming (bool): True if the variable names in the input data
                  are serialized names, as specified in the OpenAPI document.
                  False if the variable names in the input data
                  are pythonic names, e.g. snake case (default)
              _content_type (str/None): force body content-type.
                  Default is None and content-type will be predicted by allowed
                  content-types and body.
              _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:
              ApiResponse
                  If the method is called asynchronously, returns the request
                  thread.
          """
          kwargs['async_req'] = kwargs.get(
              'async_req', False
          )
          kwargs['_return_http_data_only'] = kwargs.get(
              '_return_http_data_only', True
          )
          kwargs['_preload_content'] = kwargs.get(
              '_preload_content', True
          )
          kwargs['_request_timeout'] = kwargs.get(
              '_request_timeout', None
          )
          kwargs['_check_input_type'] = kwargs.get(
              '_check_input_type', True
          )
          kwargs['_check_return_type'] = kwargs.get(
              '_check_return_type', True
          )
          kwargs['_spec_property_naming'] = kwargs.get(
              '_spec_property_naming', False
          )
          kwargs['_content_type'] = kwargs.get(
              '_content_type')
          kwargs['_host_index'] = kwargs.get('_host_index')
          return self.upload_files_endpoint.call_with_http_info(**kwargs)
  
  