Exemplo n.º 1
0
 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)
Exemplo n.º 3
0
 def __init__(self, api_client=None):
     if api_client is None:
         api_client = ApiClient()
     self.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)
Exemplo n.º 6
0
 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
     )
Exemplo n.º 7
0
 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
     )
Exemplo n.º 10
0
 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)