def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.get_tags_endpoint = _Endpoint(
settings={
'response_type': (TagCollection,),
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/tags',
'operation_id': 'get_tags',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'kind',
'pre',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'kind':
(str,),
'pre':
(str,),
},
'attribute_map': {
'kind': 'kind',
'pre': 'pre',
},
'location_map': {
'kind': 'query',
'pre': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.get_user_attribute_names_endpoint = _Endpoint(
settings={
'response_type': (UserAttributeNamesRep, ),
'auth': ['ApiKey'],
'endpoint_path':
'/api/v2/user-attributes/{projectKey}/{environmentKey}',
'operation_id': 'get_user_attribute_names',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
],
'required': [
'project_key',
'environment_key',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'project_key': (str, ),
'environment_key': (str, ),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.get_audit_log_entries_endpoint = _Endpoint(
settings={
'response_type': (AuditLogEntryListingRepCollection, ),
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/auditlog',
'operation_id': 'get_audit_log_entries',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'before',
'after',
'q',
'limit',
'spec',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'before': (int, ),
'after': (int, ),
'q': (str, ),
'limit': (int, ),
'spec': (str, ),
},
'attribute_map': {
'before': 'before',
'after': 'after',
'q': 'q',
'limit': 'limit',
'spec': 'spec',
},
'location_map': {
'before': 'query',
'after': 'query',
'q': 'query',
'limit': 'query',
'spec': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
self.get_audit_log_entry_endpoint = _Endpoint(
settings={
'response_type': (AuditLogEntryRep, ),
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/auditlog/{id}',
'operation_id': 'get_audit_log_entry',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.create_subscription_endpoint = _Endpoint(
settings={
'response_type': (Integration, ),
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/integrations/{integrationKey}',
'operation_id': 'create_subscription',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'integration_key',
'subscription_post',
],
'required': [
'integration_key',
'subscription_post',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'integration_key': (str, ),
'subscription_post': (SubscriptionPost, ),
},
'attribute_map': {
'integration_key': 'integrationKey',
},
'location_map': {
'integration_key': 'path',
'subscription_post': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client)
self.delete_subscription_endpoint = _Endpoint(
settings={
'response_type': None,
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/integrations/{integrationKey}/{id}',
'operation_id': 'delete_subscription',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'integration_key',
'id',
],
'required': [
'integration_key',
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'integration_key': (str, ),
'id': (str, ),
},
'attribute_map': {
'integration_key': 'integrationKey',
'id': 'id',
},
'location_map': {
'integration_key': 'path',
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
self.get_subscription_by_id_endpoint = _Endpoint(
settings={
'response_type': (Integration, ),
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/integrations/{integrationKey}/{id}',
'operation_id': 'get_subscription_by_id',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'integration_key',
'id',
],
'required': [
'integration_key',
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'integration_key': (str, ),
'id': (str, ),
},
'attribute_map': {
'integration_key': 'integrationKey',
'id': 'id',
},
'location_map': {
'integration_key': 'path',
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
self.get_subscriptions_endpoint = _Endpoint(
settings={
'response_type': (Integrations, ),
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/integrations/{integrationKey}',
'operation_id': 'get_subscriptions',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'integration_key',
],
'required': [
'integration_key',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'integration_key': (str, ),
},
'attribute_map': {
'integration_key': 'integrationKey',
},
'location_map': {
'integration_key': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
self.update_subscription_endpoint = _Endpoint(
settings={
'response_type': (Integration, ),
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/integrations/{integrationKey}/{id}',
'operation_id': 'update_subscription',
'http_method': 'PATCH',
'servers': None,
},
params_map={
'all': [
'integration_key',
'id',
'json_patch',
],
'required': [
'integration_key',
'id',
'json_patch',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'integration_key': (str, ),
'id': (str, ),
'json_patch': (JSONPatch, ),
},
'attribute_map': {
'integration_key': 'integrationKey',
'id': 'id',
},
'location_map': {
'integration_key': 'path',
'id': 'path',
'json_patch': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.delete_user_endpoint = _Endpoint(
settings={
'response_type': None,
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/users/{projectKey}/{environmentKey}/{userKey}',
'operation_id': 'delete_user',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
'user_key',
],
'required': [
'project_key',
'environment_key',
'user_key',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'project_key':
(str,),
'environment_key':
(str,),
'user_key':
(str,),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
'user_key': 'userKey',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
'user_key': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client
)
self.get_search_users_endpoint = _Endpoint(
settings={
'response_type': (Users,),
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/user-search/{projectKey}/{environmentKey}',
'operation_id': 'get_search_users',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
'q',
'limit',
'offset',
'after',
'sort',
'search_after',
'filter',
],
'required': [
'project_key',
'environment_key',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'project_key':
(str,),
'environment_key':
(str,),
'q':
(str,),
'limit':
(int,),
'offset':
(int,),
'after':
(int,),
'sort':
(str,),
'search_after':
(str,),
'filter':
(str,),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
'q': 'q',
'limit': 'limit',
'offset': 'offset',
'after': 'after',
'sort': 'sort',
'search_after': 'searchAfter',
'filter': 'filter',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
'q': 'query',
'limit': 'query',
'offset': 'query',
'after': 'query',
'sort': 'query',
'search_after': 'query',
'filter': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client
)
self.get_user_endpoint = _Endpoint(
settings={
'response_type': (UserRecord,),
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/users/{projectKey}/{environmentKey}/{userKey}',
'operation_id': 'get_user',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
'user_key',
],
'required': [
'project_key',
'environment_key',
'user_key',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'project_key':
(str,),
'environment_key':
(str,),
'user_key':
(str,),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
'user_key': 'userKey',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
'user_key': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client
)
self.get_users_endpoint = _Endpoint(
settings={
'response_type': (UsersRep,),
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/users/{projectKey}/{environmentKey}',
'operation_id': 'get_users',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
'limit',
'search_after',
],
'required': [
'project_key',
'environment_key',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'project_key':
(str,),
'environment_key':
(str,),
'limit':
(int,),
'search_after':
(str,),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
'limit': 'limit',
'search_after': 'searchAfter',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
'limit': 'query',
'search_after': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.create_big_segment_export_endpoint = _Endpoint(
settings={
'response_type': None,
'auth': ['ApiKey'],
'endpoint_path':
'/api/v2/segments/{projectKey}/{environmentKey}/{segmentKey}/exports',
'operation_id': 'create_big_segment_export',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
'segment_key',
],
'required': [
'project_key',
'environment_key',
'segment_key',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'project_key': (str, ),
'environment_key': (str, ),
'segment_key': (str, ),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
'segment_key': 'segmentKey',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
'segment_key': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
self.create_big_segment_import_endpoint = _Endpoint(
settings={
'response_type': None,
'auth': ['ApiKey'],
'endpoint_path':
'/api/v2/segments/{projectKey}/{environmentKey}/{segmentKey}/imports',
'operation_id': 'create_big_segment_import',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
'segment_key',
'file',
'mode',
],
'required': [
'project_key',
'environment_key',
'segment_key',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'project_key': (str, ),
'environment_key': (str, ),
'segment_key': (str, ),
'file': (file_type, ),
'mode': (str, ),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
'segment_key': 'segmentKey',
'file': 'file',
'mode': 'mode',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
'segment_key': 'path',
'file': 'form',
'mode': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['multipart/form-data']
},
api_client=api_client)
self.get_big_segment_export_endpoint = _Endpoint(
settings={
'response_type': (Export, ),
'auth': ['ApiKey'],
'endpoint_path':
'/api/v2/segments/{projectKey}/{environmentKey}/{segmentKey}/exports/{exportID}',
'operation_id': 'get_big_segment_export',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
'segment_key',
'export_id',
],
'required': [
'project_key',
'environment_key',
'segment_key',
'export_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'project_key': (str, ),
'environment_key': (str, ),
'segment_key': (str, ),
'export_id': (str, ),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
'segment_key': 'segmentKey',
'export_id': 'exportID',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
'segment_key': 'path',
'export_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
self.get_big_segment_import_endpoint = _Endpoint(
settings={
'response_type': (ModelImport, ),
'auth': ['ApiKey'],
'endpoint_path':
'/api/v2/segments/{projectKey}/{environmentKey}/{segmentKey}/imports/{importID}',
'operation_id': 'get_big_segment_import',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
'segment_key',
'import_id',
],
'required': [
'project_key',
'environment_key',
'segment_key',
'import_id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'project_key': (str, ),
'environment_key': (str, ),
'segment_key': (str, ),
'import_id': (str, ),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
'segment_key': 'segmentKey',
'import_id': 'importID',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
'segment_key': 'path',
'import_id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.get_dependent_flags_endpoint = _Endpoint(
settings={
'response_type': (MultiEnvironmentDependentFlags, ),
'auth': ['ApiKey'],
'endpoint_path':
'/api/v2/flags/{projectKey}/{featureFlagKey}/dependent-flags',
'operation_id': 'get_dependent_flags',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'project_key',
'feature_flag_key',
],
'required': [
'project_key',
'feature_flag_key',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'project_key': (str, ),
'feature_flag_key': (str, ),
},
'attribute_map': {
'project_key': 'projectKey',
'feature_flag_key': 'featureFlagKey',
},
'location_map': {
'project_key': 'path',
'feature_flag_key': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
self.get_dependent_flags_by_env_endpoint = _Endpoint(
settings={
'response_type': (DependentFlagsByEnvironment, ),
'auth': ['ApiKey'],
'endpoint_path':
'/api/v2/flags/{projectKey}/{environmentKey}/{featureFlagKey}/dependent-flags',
'operation_id': 'get_dependent_flags_by_env',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'project_key',
'environment_key',
'feature_flag_key',
],
'required': [
'project_key',
'environment_key',
'feature_flag_key',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'project_key': (str, ),
'environment_key': (str, ),
'feature_flag_key': (str, ),
},
'attribute_map': {
'project_key': 'projectKey',
'environment_key': 'environmentKey',
'feature_flag_key': 'featureFlagKey',
},
'location_map': {
'project_key': 'path',
'environment_key': 'path',
'feature_flag_key': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.delete_project_endpoint = _Endpoint(
settings={
'response_type': None,
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/projects/{projectKey}',
'operation_id': 'delete_project',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'project_key',
],
'required': [
'project_key',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'project_key':
(str,),
},
'attribute_map': {
'project_key': 'projectKey',
},
'location_map': {
'project_key': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client
)
self.get_project_endpoint = _Endpoint(
settings={
'response_type': (Project,),
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/projects/{projectKey}',
'operation_id': 'get_project',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'project_key',
],
'required': [
'project_key',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'project_key':
(str,),
},
'attribute_map': {
'project_key': 'projectKey',
},
'location_map': {
'project_key': 'path',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client
)
self.get_projects_endpoint = _Endpoint(
settings={
'response_type': (Projects,),
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/projects',
'operation_id': 'get_projects',
'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.patch_project_endpoint = _Endpoint(
settings={
'response_type': (Project,),
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/projects/{projectKey}',
'operation_id': 'patch_project',
'http_method': 'PATCH',
'servers': None,
},
params_map={
'all': [
'project_key',
'json_patch',
],
'required': [
'project_key',
'json_patch',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'project_key':
(str,),
'json_patch':
(JSONPatch,),
},
'attribute_map': {
'project_key': 'projectKey',
},
'location_map': {
'project_key': 'path',
'json_patch': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client
)
self.post_project_endpoint = _Endpoint(
settings={
'response_type': (Project,),
'auth': [
'ApiKey'
],
'endpoint_path': '/api/v2/projects',
'operation_id': 'post_project',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'project_post',
],
'required': [
'project_post',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'project_post':
(ProjectPost,),
},
'attribute_map': {
},
'location_map': {
'project_post': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.get_ips_endpoint = _Endpoint(settings={
'response_type': (IpList, ),
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/public-ip-list',
'operation_id': 'get_ips',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {},
'attribute_map': {},
'location_map': {},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
self.get_openapi_spec_endpoint = _Endpoint(settings={
'response_type': None,
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/openapi.json',
'operation_id': 'get_openapi_spec',
'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': [],
'content_type': [],
},
api_client=api_client)
self.get_root_endpoint = _Endpoint(settings={
'response_type': (RootResponse, ),
'auth': ['ApiKey'],
'endpoint_path': '/api/v2',
'operation_id': 'get_root',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {},
'attribute_map': {},
'location_map': {},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client)
self.get_versions_endpoint = _Endpoint(settings={
'response_type': (VersionsRep, ),
'auth': ['ApiKey'],
'endpoint_path': '/api/v2/versions',
'operation_id': 'get_versions',
'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)