def _get_api_client_from_config(client_config, server_config): try: client = ApiClient(configuration=client_config) ApiClientFactory._add_headers(client, server_config) return client except SSLError as exc: logger.exception( "SSL error when instantiating clients, please check certificates are valid" ) raise exc
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_admin_system_features_list_get(self, session_token, **kwargs): """Get the full set of Symphony features available for this pod # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_system_features_list_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: StringList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_admin_system_features_list_get = _Endpoint( settings={ 'response_type': (StringList, ), 'auth': [], 'endpoint_path': '/v1/admin/system/features/list', 'operation_id': 'v1_admin_system_features_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_system_features_list_get) def __v1_admin_system_protocols_list_get(self, session_token, **kwargs): """Get a list of all URI protocols supported by the company (pod) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_system_protocols_list_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: StringList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_admin_system_protocols_list_get = _Endpoint( settings={ 'response_type': (StringList, ), 'auth': [], 'endpoint_path': '/v1/admin/system/protocols/list', 'operation_id': 'v1_admin_system_protocols_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_system_protocols_list_get) def __v1_admin_system_protocols_post(self, session_token, protocol, **kwargs): """Add an entry to URI protocols supported by the company (pod) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_system_protocols_post(session_token, protocol, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. protocol (Protocol): the protocol to add Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Protocol If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['protocol'] = \ protocol return self.call_with_http_info(**kwargs) self.v1_admin_system_protocols_post = _Endpoint( settings={ 'response_type': (Protocol, ), 'auth': [], 'endpoint_path': '/v1/admin/system/protocols', 'operation_id': 'v1_admin_system_protocols_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'protocol', ], 'required': [ 'session_token', 'protocol', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'protocol': (Protocol, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', 'protocol': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_admin_system_protocols_post) def __v1_admin_system_protocols_scheme_delete(self, session_token, scheme, **kwargs): """Remove an entry from URI protocols supported by the company (pod) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_system_protocols_scheme_delete(session_token, scheme, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. scheme (str): the scheme to remove from the protocols list Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: None If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['scheme'] = \ scheme return self.call_with_http_info(**kwargs) self.v1_admin_system_protocols_scheme_delete = _Endpoint( settings={ 'response_type': None, 'auth': [], 'endpoint_path': '/v1/admin/system/protocols/{scheme}', 'operation_id': 'v1_admin_system_protocols_scheme_delete', 'http_method': 'DELETE', 'servers': None, }, params_map={ 'all': [ 'session_token', 'scheme', ], 'required': [ 'session_token', 'scheme', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'scheme': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'scheme': 'scheme', }, 'location_map': { 'session_token': 'header', 'scheme': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_system_protocols_scheme_delete) def __v2_system_protocols_get(self, session_token, **kwargs): """Get a list of URI protocols supported by the company (pod) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v2_system_protocols_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: skip (int): Number of items to skip. Default is 0.. [optional] limit (int): Maximum number of items to return. Default is 100 and not to exceed 1000.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: StringList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v2_system_protocols_get = _Endpoint( settings={ 'response_type': (StringList, ), 'auth': [], 'endpoint_path': '/v2/system/protocols', 'operation_id': 'v2_system_protocols_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'skip', 'limit', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'skip': (int, ), 'limit': (int, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'skip': 'skip', 'limit': 'limit', }, 'location_map': { 'session_token': 'header', 'skip': 'query', 'limit': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v2_system_protocols_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_message_id_get(self, session_token, key_manager_token, id, **kwargs): """Get a message by ID # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_message_id_get(session_token, key_manager_token, id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. id (str): Message ID as a URL-safe string Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V4Message If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token kwargs['id'] = \ id return self.call_with_http_info(**kwargs) self.v1_message_id_get = _Endpoint(settings={ 'response_type': (V4Message, ), 'auth': [], 'endpoint_path': '/v1/message/{id}', 'operation_id': 'v1_message_id_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'key_manager_token', 'id', ], 'required': [ 'session_token', 'key_manager_token', 'id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'key_manager_token': (str, ), 'id': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'id': 'id', }, 'location_map': { 'session_token': 'header', 'key_manager_token': 'header', 'id': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_message_id_get) def __v1_message_search_get(self, query, session_token, key_manager_token, **kwargs): """Search messages # noqa: E501 Search messages according to the specified criteria. The \"query\" parameter takes a search query defined as \"field:value\" pairs combined by the operator \"AND\" (e.g. \"text:foo AND autor:bar\"). Supported fields are (case-insensitive): \"text\", \"author\", \"hashtag\", \"cashtag\", \"mention\", \"signal\", \"fromDate\", \"toDate\", \"streamId\", \"streamType\". \"text\" search requires a \"streamId\" to be specified. \"streamType\" accepts one of the following values: \"chat\" (IMs and MIMs), \"im\", \"mim\", \"chatroom\", \"post\". \"signal\" queries can only be combined with \"fromDate\", \"toDate\", \"skip\" and \"limit\" parameters. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_message_search_get(query, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: query (str): The search query. See above for the query syntax. session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: skip (int): No. of results to skip. . [optional] limit (int): Max no. of results to return. If no value is provided, 50 is the default. . [optional] scope (str): Describes where content should be searched for that query. It can exclusively apply to Symphony content or to one Connector. . [optional] sort_dir (str): Messages sort direction : ASC or DESC (default to DESC) . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V4MessageList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['query'] = \ query kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v1_message_search_get = _Endpoint( settings={ 'response_type': (V4MessageList, ), 'auth': [], 'endpoint_path': '/v1/message/search', 'operation_id': 'v1_message_search_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'query', 'session_token', 'key_manager_token', 'skip', 'limit', 'scope', 'sort_dir', ], 'required': [ 'query', 'session_token', 'key_manager_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'query': (str, ), 'session_token': (str, ), 'key_manager_token': (str, ), 'skip': (int, ), 'limit': (int, ), 'scope': (str, ), 'sort_dir': (str, ), }, 'attribute_map': { 'query': 'query', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'skip': 'skip', 'limit': 'limit', 'scope': 'scope', 'sort_dir': 'sortDir', }, 'location_map': { 'query': 'query', 'session_token': 'header', 'key_manager_token': 'header', 'skip': 'query', 'limit': 'query', 'scope': 'query', 'sort_dir': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_message_search_get) def __v1_message_search_post(self, session_token, key_manager_token, query, **kwargs): """Search messages # noqa: E501 Search messages according to the specified criteria. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_message_search_post(session_token, key_manager_token, query, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. query (MessageSearchQuery): The search query. See above for the query syntax. Keyword Args: skip (int): No. of results to skip. . [optional] limit (int): Max no. of results to return. If no value is provided, 50 is the default. . [optional] scope (str): Describes where content should be searched for that query. It can exclusively apply to Symphony content or to one Connector. . [optional] sort_dir (str): Messages sort direction : ASC or DESC (default to DESC) . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V4MessageList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token kwargs['query'] = \ query return self.call_with_http_info(**kwargs) self.v1_message_search_post = _Endpoint( settings={ 'response_type': (V4MessageList, ), 'auth': [], 'endpoint_path': '/v1/message/search', 'operation_id': 'v1_message_search_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'key_manager_token', 'query', 'skip', 'limit', 'scope', 'sort_dir', ], 'required': [ 'session_token', 'key_manager_token', 'query', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'key_manager_token': (str, ), 'query': (MessageSearchQuery, ), 'skip': (int, ), 'limit': (int, ), 'scope': (str, ), 'sort_dir': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'skip': 'skip', 'limit': 'limit', 'scope': 'scope', 'sort_dir': 'sortDir', }, 'location_map': { 'session_token': 'header', 'key_manager_token': 'header', 'query': 'body', 'skip': 'query', 'limit': 'query', 'scope': 'query', 'sort_dir': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_message_search_post) def __v4_message_blast_post(self, session_token, sids, **kwargs): """Post a message to multiple existing streams. # noqa: E501 Post a new message to the given list of streams. The stream can be a chatroom, an IM or a multiparty IM. You may include an attachment on the message. The message can be provided as MessageMLV2 or PresentationML. Both formats support Freemarker templates. The optional parameter \"data\" can be used to provide a JSON payload containing entity data. If the message contains explicit references to entity data (in \"data-entity-id\" element attributes), this parameter is required. If the message is in MessageML and fails schema validation a client error results This endpoint is idempotent, it means that a 200 response will be returned even if the message has not been delivered to some streams. Check the `errors` map from the response in order to see on which stream(s) the message has not been delivered. The maximum number of streams where the message can be sent is limitted to 100. Regarding authentication, you must either use the sessionToken which was created for delegated app access or both the sessionToken and keyManagerToken together. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v4_message_blast_post(session_token, sids, async_req=True) >>> result = thread.get() Args: session_token (str): Authorization token used to make delegated calls. sids ([str]): A comma-separated list of Stream IDs Keyword Args: key_manager_token (str): Key Manager authentication token.. [optional] message (str): The message payload in MessageML.. [optional] data (str): Optional message data in EntityJSON.. [optional] version (str): Optional message version in the format \\\"major.minor\\\". If empty, defaults to the latest supported version. . [optional] attachment (file_type): Optional file attachment.. [optional] preview (file_type): Optional attachment preview.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V4MessageBlastResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['sids'] = \ sids return self.call_with_http_info(**kwargs) self.v4_message_blast_post = _Endpoint( settings={ 'response_type': (V4MessageBlastResponse, ), 'auth': [], 'endpoint_path': '/v4/message/blast', 'operation_id': 'v4_message_blast_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'sids', 'key_manager_token', 'message', 'data', 'version', 'attachment', 'preview', ], 'required': [ 'session_token', 'sids', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'sids': ([str], ), 'key_manager_token': (str, ), 'message': (str, ), 'data': (str, ), 'version': (str, ), 'attachment': (file_type, ), 'preview': (file_type, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'sids': 'sids', 'key_manager_token': 'keyManagerToken', 'message': 'message', 'data': 'data', 'version': 'version', 'attachment': 'attachment', 'preview': 'preview', }, 'location_map': { 'session_token': 'header', 'sids': 'form', 'key_manager_token': 'header', 'message': 'form', 'data': 'form', 'version': 'form', 'attachment': 'form', 'preview': 'form', }, 'collection_format_map': { 'sids': 'csv', } }, headers_map={ 'accept': ['application/json'], 'content_type': ['multipart/form-data'] }, api_client=api_client, callable=__v4_message_blast_post) def __v4_message_import_post(self, session_token, key_manager_token, message_list, **kwargs): """Import messages from other systems into Symphony. # noqa: E501 Sends a message to be imported into the system. Allows you to override the timestamp and author of the message with your desired values. The requesting user must have the Content Management role. The user that the message is intended to have come from must also be present in the conversation. The intended message timestamp must be a valid time from the past. It cannot be a future timestamp. Optionally the original message ID can be specified to identify the imported message for the purpose of repeat imports. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v4_message_import_post(session_token, key_manager_token, message_list, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. message_list (V4MessageImportList): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V4ImportResponseList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token kwargs['message_list'] = \ message_list return self.call_with_http_info(**kwargs) self.v4_message_import_post = _Endpoint( settings={ 'response_type': (V4ImportResponseList, ), 'auth': [], 'endpoint_path': '/v4/message/import', 'operation_id': 'v4_message_import_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'key_manager_token', 'message_list', ], 'required': [ 'session_token', 'key_manager_token', 'message_list', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'key_manager_token': (str, ), 'message_list': (V4MessageImportList, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'session_token': 'header', 'key_manager_token': 'header', 'message_list': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v4_message_import_post) def __v4_stream_sid_message_create_post(self, sid, session_token, **kwargs): """Post a message to one existing stream. # noqa: E501 Post a new message to the given stream. The stream can be a chatroom, an IM or a multiparty IM. You may include an attachment on the message. The message can be provided as MessageMLV2 or PresentationML. Both formats support Freemarker templates. The optional parameter \"data\" can be used to provide a JSON payload containing entity data. If the message contains explicit references to entity data (in \"data-entity-id\" element attributes), this parameter is required. If the message is in MessageML and fails schema validation a client error results If the message is sent then 200 is returned. Regarding authentication, you must either use the sessionToken which was created for delegated app access or both the sessionToken and keyManagerToken together. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v4_stream_sid_message_create_post(sid, session_token, async_req=True) >>> result = thread.get() Args: sid (str): Stream ID session_token (str): Authorization token used to make delegated calls. Keyword Args: key_manager_token (str): Key Manager authentication token.. [optional] message (str): The message payload in MessageML.. [optional] data (str): Optional message data in EntityJSON.. [optional] version (str): Optional message version in the format \\\"major.minor\\\". If empty, defaults to the latest supported version. . [optional] attachment (file_type): Optional file attachment.. [optional] preview (file_type): Optional attachment preview.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V4Message If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['sid'] = \ sid kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v4_stream_sid_message_create_post = _Endpoint( settings={ 'response_type': (V4Message, ), 'auth': [], 'endpoint_path': '/v4/stream/{sid}/message/create', 'operation_id': 'v4_stream_sid_message_create_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'sid', 'session_token', 'key_manager_token', 'message', 'data', 'version', 'attachment', 'preview', ], 'required': [ 'sid', 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'sid': (str, ), 'session_token': (str, ), 'key_manager_token': (str, ), 'message': (str, ), 'data': (str, ), 'version': (str, ), 'attachment': (file_type, ), 'preview': (file_type, ), }, 'attribute_map': { 'sid': 'sid', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'message': 'message', 'data': 'data', 'version': 'version', 'attachment': 'attachment', 'preview': 'preview', }, 'location_map': { 'sid': 'path', 'session_token': 'header', 'key_manager_token': 'header', 'message': 'form', 'data': 'form', 'version': 'form', 'attachment': 'form', 'preview': 'form', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['multipart/form-data'] }, api_client=api_client, callable=__v4_stream_sid_message_create_post) def __v4_stream_sid_message_get(self, sid, since, session_token, key_manager_token, **kwargs): """Get messages from an existing stream. # noqa: E501 A caller can fetch all unseen messages by passing the timestamp of the last message seen as the since parameter and the number of messages with the same timestamp value already seen as the skip parameter. This means that every message will be seen exactly once even in the case that an additional message is processed with the same timestamp as the last message returned by the previous call, and the case where there are more than maxMessages with the same timestamp value. This method is intended for historic queries and is generally reliable but if guaranteed delivery of every message in real time is required then the equivilent firehose method should be called. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v4_stream_sid_message_get(sid, since, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: sid (str): Stream ID since (int): Timestamp of first required message. This is a long integer value representing milliseconds since Jan 1 1970 session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: skip (int): No. of messages to skip. . [optional] limit (int): Max No. of messages to return. If no value is provided, 50 is the default. The maximum supported value is 500. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V4MessageList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['sid'] = \ sid kwargs['since'] = \ since kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v4_stream_sid_message_get = _Endpoint( settings={ 'response_type': (V4MessageList, ), 'auth': [], 'endpoint_path': '/v4/stream/{sid}/message', 'operation_id': 'v4_stream_sid_message_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'sid', 'since', 'session_token', 'key_manager_token', 'skip', 'limit', ], 'required': [ 'sid', 'since', 'session_token', 'key_manager_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'sid': (str, ), 'since': (int, ), 'session_token': (str, ), 'key_manager_token': (str, ), 'skip': (int, ), 'limit': (int, ), }, 'attribute_map': { 'sid': 'sid', 'since': 'since', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'skip': 'skip', 'limit': 'limit', }, 'location_map': { 'sid': 'path', 'since': 'query', 'session_token': 'header', 'key_manager_token': 'header', 'skip': 'query', 'limit': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v4_stream_sid_message_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_admin_group_gid_membership_add_post(self, gid, session_token, users, **kwargs): """Add members to an Information Barrier group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_group_gid_membership_add_post(gid, session_token, users, async_req=True) >>> result = thread.get() Args: gid (str): URL-Safe encoded Group ID session_token (str): Session authentication token. users (IntegerList): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: BulkActionResult If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['gid'] = \ gid kwargs['session_token'] = \ session_token kwargs['users'] = \ users return self.call_with_http_info(**kwargs) self.v1_admin_group_gid_membership_add_post = _Endpoint( settings={ 'response_type': (BulkActionResult, ), 'auth': [], 'endpoint_path': '/v1/admin/group/{gid}/membership/add', 'operation_id': 'v1_admin_group_gid_membership_add_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'gid', 'session_token', 'users', ], 'required': [ 'gid', 'session_token', 'users', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'gid': (str, ), 'session_token': (str, ), 'users': (IntegerList, ), }, 'attribute_map': { 'gid': 'gid', 'session_token': 'sessionToken', }, 'location_map': { 'gid': 'path', 'session_token': 'header', 'users': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_admin_group_gid_membership_add_post) def __v1_admin_group_gid_membership_list_get(self, gid, session_token, **kwargs): """Get the list of userids in this Information Barrier Group # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_group_gid_membership_list_get(gid, session_token, async_req=True) >>> result = thread.get() Args: gid (str): URL-Safe encoded Group ID session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: IntegerList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['gid'] = \ gid kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_admin_group_gid_membership_list_get = _Endpoint( settings={ 'response_type': (IntegerList, ), 'auth': [], 'endpoint_path': '/v1/admin/group/{gid}/membership/list', 'operation_id': 'v1_admin_group_gid_membership_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'gid', 'session_token', ], 'required': [ 'gid', 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'gid': (str, ), 'session_token': (str, ), }, 'attribute_map': { 'gid': 'gid', 'session_token': 'sessionToken', }, 'location_map': { 'gid': 'path', 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_group_gid_membership_list_get) def __v1_admin_group_gid_membership_remove_post( self, gid, session_token, users, **kwargs): """Remove members from an Information Barrier group # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_group_gid_membership_remove_post(gid, session_token, users, async_req=True) >>> result = thread.get() Args: gid (str): URL-Safe encoded Group ID session_token (str): Session authentication token. users (IntegerList): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: BulkActionResult If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['gid'] = \ gid kwargs['session_token'] = \ session_token kwargs['users'] = \ users return self.call_with_http_info(**kwargs) self.v1_admin_group_gid_membership_remove_post = _Endpoint( settings={ 'response_type': (BulkActionResult, ), 'auth': [], 'endpoint_path': '/v1/admin/group/{gid}/membership/remove', 'operation_id': 'v1_admin_group_gid_membership_remove_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'gid', 'session_token', 'users', ], 'required': [ 'gid', 'session_token', 'users', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'gid': (str, ), 'session_token': (str, ), 'users': (IntegerList, ), }, 'attribute_map': { 'gid': 'gid', 'session_token': 'sessionToken', }, 'location_map': { 'gid': 'path', 'session_token': 'header', 'users': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_admin_group_gid_membership_remove_post) def __v1_admin_group_list_get(self, session_token, **kwargs): """Get a list of all Information Barrier Groups # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_group_list_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: GroupList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_admin_group_list_get = _Endpoint( settings={ 'response_type': (GroupList, ), 'auth': [], 'endpoint_path': '/v1/admin/group/list', 'operation_id': 'v1_admin_group_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_group_list_get) def __v1_admin_policy_list_get(self, session_token, **kwargs): """Get all Information Policies # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_policy_list_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: PolicyList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_admin_policy_list_get = _Endpoint( settings={ 'response_type': (PolicyList, ), 'auth': [], 'endpoint_path': '/v1/admin/policy/list', 'operation_id': 'v1_admin_policy_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_policy_list_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v3_stream_sid_share_post(self, sid, session_token, share_content, **kwargs): """PROVISIONAL - Share a piece of content into Symphony # noqa: E501 Given a 3rd party content (eg. news article), it can share to the given stream. The stream can be a chatroom, an IM or a multiparty IM. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v3_stream_sid_share_post(sid, session_token, share_content, async_req=True) >>> result = thread.get() Args: sid (str): Stream ID session_token (str): Session authentication token. share_content (ShareContent): Keyword Args: key_manager_token (str): Key Manager authentication token.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V2Message If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['sid'] = \ sid kwargs['session_token'] = \ session_token kwargs['share_content'] = \ share_content return self.call_with_http_info(**kwargs) self.v3_stream_sid_share_post = _Endpoint( settings={ 'response_type': (V2Message, ), 'auth': [], 'endpoint_path': '/v3/stream/{sid}/share', 'operation_id': 'v3_stream_sid_share_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'sid', 'session_token', 'share_content', 'key_manager_token', ], 'required': [ 'sid', 'session_token', 'share_content', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'sid': (str, ), 'session_token': (str, ), 'share_content': (ShareContent, ), 'key_manager_token': (str, ), }, 'attribute_map': { 'sid': 'sid', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'sid': 'path', 'session_token': 'header', 'share_content': 'body', 'key_manager_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v3_stream_sid_share_post)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_stream_sid_attachment_get(self, sid, file_id, message_id, session_token, key_manager_token, **kwargs): """Download an attachment. # noqa: E501 Downloads the attachment body by the attachment ID, stream ID, and message ID. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_stream_sid_attachment_get(sid, file_id, message_id, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: sid (str): Stream ID file_id (str): The attachment ID (Base64-encoded) message_id (str): The ID of the message containing the attachment session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: str If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['sid'] = \ sid kwargs['file_id'] = \ file_id kwargs['message_id'] = \ message_id kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v1_stream_sid_attachment_get = _Endpoint( settings={ 'response_type': (str, ), 'auth': [], 'endpoint_path': '/v1/stream/{sid}/attachment', 'operation_id': 'v1_stream_sid_attachment_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'sid', 'file_id', 'message_id', 'session_token', 'key_manager_token', ], 'required': [ 'sid', 'file_id', 'message_id', 'session_token', 'key_manager_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'sid': (str, ), 'file_id': (str, ), 'message_id': (str, ), 'session_token': (str, ), 'key_manager_token': (str, ), }, 'attribute_map': { 'sid': 'sid', 'file_id': 'fileId', 'message_id': 'messageId', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'sid': 'path', 'file_id': 'query', 'message_id': 'query', 'session_token': 'header', 'key_manager_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/octet-stream'], 'content_type': [], }, api_client=api_client, callable=__v1_stream_sid_attachment_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_admin_room_id_membership_add_post(self, id, session_token, payload, **kwargs): """Add a member to an existing room. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_room_id_membership_add_post(id, session_token, payload, async_req=True) >>> result = thread.get() Args: id (str): Room streamId session_token (str): Session authentication token. payload (UserId): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token kwargs['payload'] = \ payload return self.call_with_http_info(**kwargs) self.v1_admin_room_id_membership_add_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/admin/room/{id}/membership/add', 'operation_id': 'v1_admin_room_id_membership_add_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', 'payload', ], 'required': [ 'id', 'session_token', 'payload', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), 'session_token': (str, ), 'payload': (UserId, ), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', }, 'location_map': { 'id': 'path', 'session_token': 'header', 'payload': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_admin_room_id_membership_add_post) def __v1_admin_room_id_membership_list_get(self, id, session_token, **kwargs): """Lists current and previous members of an existing room. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_room_id_membership_list_get(id, session_token, async_req=True) >>> result = thread.get() Args: id (str): Room streamId session_token (str): Session authentication token. Keyword Args: include_past_members (bool): If true, the membership list will include past members of the stream. If false, the listing will only incude current members. Default false.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: MembershipList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_admin_room_id_membership_list_get = _Endpoint( settings={ 'response_type': (MembershipList, ), 'auth': [], 'endpoint_path': '/v1/admin/room/{id}/membership/list', 'operation_id': 'v1_admin_room_id_membership_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', 'include_past_members', ], 'required': [ 'id', 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), 'session_token': (str, ), 'include_past_members': (bool, ), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', 'include_past_members': 'includePastMembers', }, 'location_map': { 'id': 'path', 'session_token': 'header', 'include_past_members': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_room_id_membership_list_get) def __v1_admin_room_id_membership_remove_post(self, id, session_token, payload, **kwargs): """Remove a member from a room. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_room_id_membership_remove_post(id, session_token, payload, async_req=True) >>> result = thread.get() Args: id (str): Room streamId session_token (str): Session authentication token. payload (UserId): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token kwargs['payload'] = \ payload return self.call_with_http_info(**kwargs) self.v1_admin_room_id_membership_remove_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/admin/room/{id}/membership/remove', 'operation_id': 'v1_admin_room_id_membership_remove_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', 'payload', ], 'required': [ 'id', 'session_token', 'payload', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), 'session_token': (str, ), 'payload': (UserId, ), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', }, 'location_map': { 'id': 'path', 'session_token': 'header', 'payload': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_admin_room_id_membership_remove_post) def __v1_room_id_membership_add_post(self, id, session_token, payload, **kwargs): """Adds new member to an existing room. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_room_id_membership_add_post(id, session_token, payload, async_req=True) >>> result = thread.get() Args: id (str): Room streamId session_token (str): Session authentication token. payload (UserId): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token kwargs['payload'] = \ payload return self.call_with_http_info(**kwargs) self.v1_room_id_membership_add_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/room/{id}/membership/add', 'operation_id': 'v1_room_id_membership_add_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', 'payload', ], 'required': [ 'id', 'session_token', 'payload', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), 'session_token': (str, ), 'payload': (UserId, ), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', }, 'location_map': { 'id': 'path', 'session_token': 'header', 'payload': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_room_id_membership_add_post) def __v1_room_id_membership_demote_owner_post(self, id, session_token, payload, **kwargs): """Demotes room owner. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_room_id_membership_demote_owner_post(id, session_token, payload, async_req=True) >>> result = thread.get() Args: id (str): Room streamId session_token (str): Session authentication token. payload (UserId): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token kwargs['payload'] = \ payload return self.call_with_http_info(**kwargs) self.v1_room_id_membership_demote_owner_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/room/{id}/membership/demoteOwner', 'operation_id': 'v1_room_id_membership_demote_owner_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', 'payload', ], 'required': [ 'id', 'session_token', 'payload', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), 'session_token': (str, ), 'payload': (UserId, ), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', }, 'location_map': { 'id': 'path', 'session_token': 'header', 'payload': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_room_id_membership_demote_owner_post) def __v1_room_id_membership_promote_owner_post(self, id, session_token, payload, **kwargs): """Promotes user to owner. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_room_id_membership_promote_owner_post(id, session_token, payload, async_req=True) >>> result = thread.get() Args: id (str): Room streamId session_token (str): Session authentication token. payload (UserId): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token kwargs['payload'] = \ payload return self.call_with_http_info(**kwargs) self.v1_room_id_membership_promote_owner_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/room/{id}/membership/promoteOwner', 'operation_id': 'v1_room_id_membership_promote_owner_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', 'payload', ], 'required': [ 'id', 'session_token', 'payload', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), 'session_token': (str, ), 'payload': (UserId, ), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', }, 'location_map': { 'id': 'path', 'session_token': 'header', 'payload': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_room_id_membership_promote_owner_post) def __v1_room_id_membership_remove_post(self, id, session_token, payload, **kwargs): """Removes member from an existing room. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_room_id_membership_remove_post(id, session_token, payload, async_req=True) >>> result = thread.get() Args: id (str): Room streamId session_token (str): Session authentication token. payload (UserId): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token kwargs['payload'] = \ payload return self.call_with_http_info(**kwargs) self.v1_room_id_membership_remove_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/room/{id}/membership/remove', 'operation_id': 'v1_room_id_membership_remove_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', 'payload', ], 'required': [ 'id', 'session_token', 'payload', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), 'session_token': (str, ), 'payload': (UserId, ), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', }, 'location_map': { 'id': 'path', 'session_token': 'header', 'payload': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_room_id_membership_remove_post) def __v2_room_id_membership_list_get(self, id, session_token, **kwargs): """Lists current members of an existing room. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v2_room_id_membership_list_get(id, session_token, async_req=True) >>> result = thread.get() Args: id (str): Room streamId session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: MembershipList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v2_room_id_membership_list_get = _Endpoint( settings={ 'response_type': (MembershipList, ), 'auth': [], 'endpoint_path': '/v2/room/{id}/membership/list', 'operation_id': 'v2_room_id_membership_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', ], 'required': [ 'id', 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), 'session_token': (str, ), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', }, 'location_map': { 'id': 'path', 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v2_room_id_membership_list_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v3_extended_health(self, **kwargs): """Checks health status of services and users # noqa: E501 _Available on Agent 2.57.0 and above._ Returns the connectivity status of the Agent services (**pod**, **key manager** and **datafeed**) as well as users connectivity (**agentservice** and **ceservice**). The global status will be set to `DOWN` if at least one of the sub-status is also `DOWN`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v3_extended_health(async_req=True) >>> result = thread.get() Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V3Health If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') return self.call_with_http_info(**kwargs) self.v3_extended_health = _Endpoint(settings={ 'response_type': (V3Health, ), 'auth': [], 'endpoint_path': '/v3/health/extended', 'operation_id': 'v3_extended_health', '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, callable=__v3_extended_health) def __v3_health(self, **kwargs): """Checks health status # noqa: E501 _Available on Agent 2.57.0 and above._ Returns the connectivity status of your Agent server. If your Agent server is started and running, the status value will be `UP` # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v3_health(async_req=True) >>> result = thread.get() Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V3Health If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') return self.call_with_http_info(**kwargs) self.v3_health = _Endpoint(settings={ 'response_type': (V3Health, ), 'auth': [], 'endpoint_path': '/v3/health', 'operation_id': 'v3_health', '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, callable=__v3_health)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_connection_accept_post(self, session_token, connection_request, **kwargs): """Accept the connection request for the requesting user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_connection_accept_post(session_token, connection_request, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. connection_request (UserConnectionRequest): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserConnection If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['connection_request'] = \ connection_request return self.call_with_http_info(**kwargs) self.v1_connection_accept_post = _Endpoint( settings={ 'response_type': (UserConnection, ), 'auth': [], 'endpoint_path': '/v1/connection/accept', 'operation_id': 'v1_connection_accept_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'connection_request', ], 'required': [ 'session_token', 'connection_request', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'connection_request': (UserConnectionRequest, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', 'connection_request': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_connection_accept_post) def __v1_connection_create_post(self, session_token, connection_request, **kwargs): """Sends an invitation to connect with another user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_connection_create_post(session_token, connection_request, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. connection_request (UserConnectionRequest): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserConnection If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['connection_request'] = \ connection_request return self.call_with_http_info(**kwargs) self.v1_connection_create_post = _Endpoint( settings={ 'response_type': (UserConnection, ), 'auth': [], 'endpoint_path': '/v1/connection/create', 'operation_id': 'v1_connection_create_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'connection_request', ], 'required': [ 'session_token', 'connection_request', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'connection_request': (UserConnectionRequest, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', 'connection_request': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_connection_create_post) def __v1_connection_list_get(self, session_token, **kwargs): """List of requesting user's connection # noqa: E501 This retrieves all connections of the requesting user. (i.e. both connections in which the requesting user is the sender and those in which the requesting user is the inivtee) By default, if you haven't specified the connection status to filter on, this call will only return results for both \"pending_incoming\" and \"pending_outgoing\". You can optionally filter by userIds to further restrict the results of a specific connection status. If the users are in the same private pod, the users have an implicit connection status of \"accepted\". Those users will not be returned in the response if you don't specify the connection status as \"accepted\" (default is \"pending\") and the explicit userIds in the request. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_connection_list_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: status (str): Filter the connection list based on the connection status. The connection status can only be pending_incoming, pending_outgoing, accepted, rejected, or all (all of the above) . [optional] user_ids (str): The userIds parameter should be specified as a comma delimited list of user ids and can be used to restrict the results of a specific connection. Note that this is particularly important if the caller intends to retrieve results for implicit connection (user within the same pod). Implicit connections will not be included in the response if userId is not provided. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserConnectionList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_connection_list_get = _Endpoint( settings={ 'response_type': (UserConnectionList, ), 'auth': [], 'endpoint_path': '/v1/connection/list', 'operation_id': 'v1_connection_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'status', 'user_ids', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [ 'status', ], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': { ('status', ): { "PENDING_INCOMING": "PENDING_INCOMING", "PENDING_OUTGOING": "PENDING_OUTGOING", "ACCEPTED": "ACCEPTED", "REJECTED": "REJECTED", "ALL": "ALL" }, }, 'openapi_types': { 'session_token': (str, ), 'status': (str, ), 'user_ids': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'status': 'status', 'user_ids': 'userIds', }, 'location_map': { 'session_token': 'header', 'status': 'query', 'user_ids': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_connection_list_get) def __v1_connection_reject_post(self, session_token, connection_request, **kwargs): """Reject the connection request for the requesting user. # noqa: E501 Reject the connection between the requesting user and request sender. If both users are in the same private pod, an error will be returned because both users have an implicit connection which cannot be rejected. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_connection_reject_post(session_token, connection_request, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. connection_request (UserConnectionRequest): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserConnection If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['connection_request'] = \ connection_request return self.call_with_http_info(**kwargs) self.v1_connection_reject_post = _Endpoint( settings={ 'response_type': (UserConnection, ), 'auth': [], 'endpoint_path': '/v1/connection/reject', 'operation_id': 'v1_connection_reject_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'connection_request', ], 'required': [ 'session_token', 'connection_request', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'connection_request': (UserConnectionRequest, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', 'connection_request': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_connection_reject_post) def __v1_connection_user_uid_remove_post(self, session_token, uid, **kwargs): """Removes a connection with a user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_connection_user_uid_remove_post(session_token, uid, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. uid (int): User ID as a decimal integer Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['uid'] = \ uid return self.call_with_http_info(**kwargs) self.v1_connection_user_uid_remove_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/connection/user/{uid}/remove', 'operation_id': 'v1_connection_user_uid_remove_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'uid', ], 'required': [ 'session_token', 'uid', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'uid': (int, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'uid': 'uid', }, 'location_map': { 'session_token': 'header', 'uid': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_connection_user_uid_remove_post) def __v1_connection_user_user_id_info_get(self, session_token, user_id, **kwargs): """The status of the connection invitation to another user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_connection_user_user_id_info_get(session_token, user_id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. user_id (str): user Id Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserConnection If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['user_id'] = \ user_id return self.call_with_http_info(**kwargs) self.v1_connection_user_user_id_info_get = _Endpoint( settings={ 'response_type': (UserConnection, ), 'auth': [], 'endpoint_path': '/v1/connection/user/{userId}/info', 'operation_id': 'v1_connection_user_user_id_info_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'user_id', ], 'required': [ 'session_token', 'user_id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'user_id': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'user_id': 'userId', }, 'location_map': { 'session_token': 'header', 'user_id': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_connection_user_user_id_info_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_app_pod_certificate_get(self, **kwargs): """Retrieve the certificate that can be use to validate the JWT token obtain through the extension application authentication flow. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = auth_api.v1_app_pod_certificate_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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: PodCertificate If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') return self.call_with_http_info(**kwargs) self.v1_app_pod_certificate_get = _Endpoint( settings={ 'response_type': (PodCertificate, ), 'auth': [], 'endpoint_path': '/v1/app/pod/certificate', 'operation_id': 'v1_app_pod_certificate_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, callable=__v1_app_pod_certificate_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_presence_feed_create_post(self, session_token, **kwargs): """Create Presence status feed. # noqa: E501 Create a new stream capturing presence status changes (\"presence feed\"). When read from, the feed will return the current presence status of company (pod) users if it has changed since the last read. Returns the ID of the presence feed to be used in subsequent read operations. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_presence_feed_create_post(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: StringId If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_presence_feed_create_post = _Endpoint( settings={ 'response_type': (StringId, ), 'auth': [], 'endpoint_path': '/v1/presence/feed/create', 'operation_id': 'v1_presence_feed_create_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_presence_feed_create_post) def __v1_presence_feed_feed_id_delete_post(self, session_token, feed_id, **kwargs): """Delete a presence status feed. # noqa: E501 Returns the ID of the deleted feed. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_presence_feed_feed_id_delete_post(session_token, feed_id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. feed_id (str): Presence feed ID. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: StringId If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['feed_id'] = \ feed_id return self.call_with_http_info(**kwargs) self.v1_presence_feed_feed_id_delete_post = _Endpoint( settings={ 'response_type': (StringId, ), 'auth': [], 'endpoint_path': '/v1/presence/feed/{feedId}/delete', 'operation_id': 'v1_presence_feed_feed_id_delete_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'feed_id', ], 'required': [ 'session_token', 'feed_id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'feed_id': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'feed_id': 'feedId', }, 'location_map': { 'session_token': 'header', 'feed_id': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_presence_feed_feed_id_delete_post) def __v1_presence_feed_feed_id_read_get(self, session_token, feed_id, **kwargs): """Read a presence status feed. # noqa: E501 Returns the current presence status of company (pod) users if it has changed since the last read. Returns up to 500 records at a time. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_presence_feed_feed_id_read_get(session_token, feed_id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. feed_id (str): Presence feed ID. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V2PresenceList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['feed_id'] = \ feed_id return self.call_with_http_info(**kwargs) self.v1_presence_feed_feed_id_read_get = _Endpoint( settings={ 'response_type': (V2PresenceList, ), 'auth': [], 'endpoint_path': '/v1/presence/feed/{feedId}/read', 'operation_id': 'v1_presence_feed_feed_id_read_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'feed_id', ], 'required': [ 'session_token', 'feed_id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'feed_id': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'feed_id': 'feedId', }, 'location_map': { 'session_token': 'header', 'feed_id': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_presence_feed_feed_id_read_get) def __v1_user_presence_register_post(self, session_token, uid_list, **kwargs): """Register interest in a user's presence status # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_user_presence_register_post(session_token, uid_list, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. uid_list (UserIdList): List of (integer) User IDs of users whose presence to query Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['uid_list'] = \ uid_list return self.call_with_http_info(**kwargs) self.v1_user_presence_register_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/user/presence/register', 'operation_id': 'v1_user_presence_register_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'uid_list', ], 'required': [ 'session_token', 'uid_list', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'uid_list': (UserIdList, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', 'uid_list': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_user_presence_register_post) def __v2_user_presence_get(self, session_token, **kwargs): """Get presence information about the requesting user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v2_user_presence_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V2Presence If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v2_user_presence_get = _Endpoint(settings={ 'response_type': (V2Presence, ), 'auth': [], 'endpoint_path': '/v2/user/presence', 'operation_id': 'v2_user_presence_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v2_user_presence_get) def __v2_user_presence_post(self, session_token, presence, **kwargs): """Set the presence of the requesting user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v2_user_presence_post(session_token, presence, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. presence (V2PresenceStatus): Keyword Args: soft (bool): If true, the user's current status is taken into consideration. If the user is currently OFFLINE, the user's presence will still be OFFLINE, but the new presence will take effect when the user comes online. If the user is currently online, the user's activity state will be applied to the presence if applicable. (e.g. if you are setting their presence to AVAILABLE, but the user is currently idle, their status will be represented as AWAY) . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V2Presence If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['presence'] = \ presence return self.call_with_http_info(**kwargs) self.v2_user_presence_post = _Endpoint( settings={ 'response_type': (V2Presence, ), 'auth': [], 'endpoint_path': '/v2/user/presence', 'operation_id': 'v2_user_presence_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'presence', 'soft', ], 'required': [ 'session_token', 'presence', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'presence': (V2PresenceStatus, ), 'soft': (bool, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'soft': 'soft', }, 'location_map': { 'session_token': 'header', 'presence': 'body', 'soft': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v2_user_presence_post) def __v2_users_presence_get(self, session_token, **kwargs): """Get presence information about all company (pod) users. # noqa: E501 The returned data is taken from the in-memory cache for performance reasons which means inactive users may be omitted from the response. All non-inactive users WILL be returned and some inactive users MAY be included. Any omitted user IS inactive. Returned records are sorted by user ID, ascending. This method is expensive. It pulls ALL records from the cache, sorts them and then only uses a subset. For large numbers of users, this can be very inefficient both due to sorting and due to the cache being distributed across many nodes. Addiionally, there is the potential to miss users if they become active after the page in which their user ID falls has already been read by the client. To avoid this situation, a presence feed should be created (and optionally read from) first to capture presence changes of users who get reactivated during a paged call to this endpoint. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v2_users_presence_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: last_user_id (int): Last user ID retrieved. Used for paging; if provided, results will skip users with IDs less than this parameter.. [optional] limit (int): Max number of records to return. If no value is provided, 1000 is the default. The maximum supported value is 5000.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V2PresenceList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v2_users_presence_get = _Endpoint( settings={ 'response_type': (V2PresenceList, ), 'auth': [], 'endpoint_path': '/v2/users/presence', 'operation_id': 'v2_users_presence_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'last_user_id', 'limit', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'last_user_id': (int, ), 'limit': (int, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'last_user_id': 'lastUserId', 'limit': 'limit', }, 'location_map': { 'session_token': 'header', 'last_user_id': 'query', 'limit': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v2_users_presence_get) def __v3_user_presence_post(self, session_token, presence, **kwargs): """Set presence information for a particular user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v3_user_presence_post(session_token, presence, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. presence (V2UserPresence): Keyword Args: soft (bool): If true, the user's current status is taken into consideration. If the user is currently OFFLINE, the user's presence will still be OFFLINE, but the new presence will take effect when the user comes online. If the user is currently online, the user's activity state will be applied to the presence if applicable. (e.g. if you are setting their presence to AVAILABLE, but the user is currently idle, their status will be represented as AWAY) . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V2Presence If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['presence'] = \ presence return self.call_with_http_info(**kwargs) self.v3_user_presence_post = _Endpoint( settings={ 'response_type': (V2Presence, ), 'auth': [], 'endpoint_path': '/v3/user/presence', 'operation_id': 'v3_user_presence_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'presence', 'soft', ], 'required': [ 'session_token', 'presence', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'presence': (V2UserPresence, ), 'soft': (bool, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'soft': 'soft', }, 'location_map': { 'session_token': 'header', 'presence': 'body', 'soft': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v3_user_presence_post) def __v3_user_uid_presence_get(self, uid, session_token, **kwargs): """Get presence information about a particular user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v3_user_uid_presence_get(uid, session_token, async_req=True) >>> result = thread.get() Args: uid (int): User ID as a decimal integer session_token (str): Session authentication token. Keyword Args: local (bool): If true, a local query will be performed and the presence will be set to OFFLINE for users who are not local to the calling user's pod. If false or absent, then the presence of all local users and the presence of all external users to whom the calling user is connected will be queried. For external users, a \"presence interest\" should be registered through /v1/user/presence/register before querying for presence. . [optional] if omitted the server will use the default value of False _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V2Presence If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['uid'] = \ uid kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v3_user_uid_presence_get = _Endpoint( settings={ 'response_type': (V2Presence, ), 'auth': [], 'endpoint_path': '/v3/user/{uid}/presence', 'operation_id': 'v3_user_uid_presence_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'uid', 'session_token', 'local', ], 'required': [ 'uid', 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'uid': (int, ), 'session_token': (str, ), 'local': (bool, ), }, 'attribute_map': { 'uid': 'uid', 'session_token': 'sessionToken', 'local': 'local', }, 'location_map': { 'uid': 'path', 'session_token': 'header', 'local': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v3_user_uid_presence_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __create_datafeed(self, session_token, key_manager_token, **kwargs): """Create a new real time messages / events stream (\"datafeed\"). # noqa: E501 _Available on Agent 2.57.0 and above._ The datafeed provides messages and events from all conversations that the user is in. The types of events surfaced in the datafeed can be found in the Real Time Events list. (see definition on top of the file) Returns the ID of the datafeed that has just been created. This ID should then be used as input to the Read Messages/Events Stream v4 endpoint. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.create_datafeed(session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: body (V5DatafeedCreateBody): [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V5Datafeed If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.create_datafeed = _Endpoint(settings={ 'response_type': (V5Datafeed, ), 'auth': [], 'endpoint_path': '/v5/datafeeds', 'operation_id': 'create_datafeed', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'key_manager_token', 'body', ], 'required': [ 'session_token', 'key_manager_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'key_manager_token': (str, ), 'body': (V5DatafeedCreateBody, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'session_token': 'header', 'key_manager_token': 'header', 'body': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__create_datafeed) def __delete_datafeed(self, datafeed_id, session_token, key_manager_token, **kwargs): """Delete the specified real time message / event stream (\"datafeed\"). # noqa: E501 _Available on Agent 2.57.0 and above._ The datafeed provides messages and events from all conversations that the user is in. The types of events surfaced in the datafeed can be found in the Real Time Events list. (see definition on top of the file) Delete the specified datafeed. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.delete_datafeed(datafeed_id, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: datafeed_id (str): ID of the datafeed session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V2Error If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['datafeed_id'] = \ datafeed_id kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.delete_datafeed = _Endpoint(settings={ 'response_type': (V2Error, ), 'auth': [], 'endpoint_path': '/v5/datafeeds/{datafeedId}', 'operation_id': 'delete_datafeed', 'http_method': 'DELETE', 'servers': None, }, params_map={ 'all': [ 'datafeed_id', 'session_token', 'key_manager_token', ], 'required': [ 'datafeed_id', 'session_token', 'key_manager_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'datafeed_id': (str, ), 'session_token': (str, ), 'key_manager_token': (str, ), }, 'attribute_map': { 'datafeed_id': 'datafeedId', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'datafeed_id': 'path', 'session_token': 'header', 'key_manager_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['*/*'], 'content_type': [], }, api_client=api_client, callable=__delete_datafeed) def __list_datafeed(self, session_token, key_manager_token, **kwargs): """Read list of real time messages / events stream (\"datafeed\"). # noqa: E501 _Available on Agent 2.57.0 and above._ The datafeed provides messages and events from all conversations that the user is in. The types of events surfaced in the datafeed can be found in the [Real Time Events](./docs/real-time-events.md) list. Returns the list of the datafeeds for the user. Any datafeed ID of the list can then be used as input to the Read Messages/Events Stream v4 endpoint. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.list_datafeed(session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: tag (str): A unique identifier to ensure uniqueness of the datafeed. Used to restrict search.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: [V5Datafeed] If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.list_datafeed = _Endpoint(settings={ 'response_type': ([V5Datafeed], ), 'auth': [], 'endpoint_path': '/v5/datafeeds', 'operation_id': 'list_datafeed', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'key_manager_token', 'tag', ], 'required': [ 'session_token', 'key_manager_token', ], 'nullable': [], 'enum': [], 'validation': [ 'tag', ] }, root_map={ 'validations': { ('tag', ): { 'max_length': 100, }, }, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'key_manager_token': (str, ), 'tag': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'tag': 'tag', }, 'location_map': { 'session_token': 'header', 'key_manager_token': 'header', 'tag': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json', '200 OK'], 'content_type': [], }, api_client=api_client, callable=__list_datafeed) def __read_datafeed(self, datafeed_id, session_token, key_manager_token, **kwargs): """Read the specified real time message / event stream (\"datafeed\"). # noqa: E501 _Available on Agent 2.57.0 and above._ The datafeed provides messages and events from all conversations that the user is in. The types of events surfaced in the datafeed can be found in the Real Time Events list. (see definition on top of the file) Read the specified datafeed. The ackId sent as parameter can be empty for the first call. In the response an ackId will be sent back and it can be used for the next call: in this way you acknowledge that you have received the events that came with that ackId; datafeed will remove the events associated with that ackId from your queue # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.read_datafeed(datafeed_id, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: datafeed_id (str): ID of the datafeed session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: ack_id (AckId): ackId received from last POST Base64 encoded.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V5EventList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['datafeed_id'] = \ datafeed_id kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.read_datafeed = _Endpoint(settings={ 'response_type': (V5EventList, ), 'auth': [], 'endpoint_path': '/v5/datafeeds/{datafeedId}/read', 'operation_id': 'read_datafeed', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'datafeed_id', 'session_token', 'key_manager_token', 'ack_id', ], 'required': [ 'datafeed_id', 'session_token', 'key_manager_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'datafeed_id': (str, ), 'session_token': (str, ), 'key_manager_token': (str, ), 'ack_id': (AckId, ), }, 'attribute_map': { 'datafeed_id': 'datafeedId', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'datafeed_id': 'path', 'session_token': 'header', 'key_manager_token': 'header', 'ack_id': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__read_datafeed) def __v4_datafeed_create_post(self, session_token, key_manager_token, **kwargs): """Create a new real time message event stream. # noqa: E501 A datafeed provides the messages in all conversations that a user is in. This also includes system messages like new users joining a chatroom. A datafeed will expire if it isn't read before its capacity is reached. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v4_datafeed_create_post(session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Datafeed If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v4_datafeed_create_post = _Endpoint( settings={ 'response_type': (Datafeed, ), 'auth': [], 'endpoint_path': '/v4/datafeed/create', 'operation_id': 'v4_datafeed_create_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'key_manager_token', ], 'required': [ 'session_token', 'key_manager_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'key_manager_token': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'session_token': 'header', 'key_manager_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v4_datafeed_create_post) def __v4_datafeed_id_read_get(self, id, session_token, key_manager_token, **kwargs): """Read a given datafeed. # noqa: E501 Read messages from the given datafeed. If no more messages are available then this method will block. It is intended that the client should re-call this method as soon as it has processed the messages received in the previous call. If the client is able to consume messages more quickly than they become available then each call will initially block, there is no need to delay before re-calling this method. A datafeed will expire if its unread capacity is reached. A datafeed can only be consumed by one client thread at a time. E.g. polling the datafeed by two threads may lead to messages being delivered out of order. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v4_datafeed_id_read_get(id, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: id (str): Datafeed ID session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: limit (int): Max No. of messages to return. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V4EventList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v4_datafeed_id_read_get = _Endpoint( settings={ 'response_type': (V4EventList, ), 'auth': [], 'endpoint_path': '/v4/datafeed/{id}/read', 'operation_id': 'v4_datafeed_id_read_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', 'key_manager_token', 'limit', ], 'required': [ 'id', 'session_token', 'key_manager_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'id': (str, ), 'session_token': (str, ), 'key_manager_token': (str, ), 'limit': (int, ), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'limit': 'limit', }, 'location_map': { 'id': 'path', 'session_token': 'header', 'key_manager_token': 'header', 'limit': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v4_datafeed_id_read_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_app_authenticate_post(self, **kwargs): """PROVISIONAL - Authenticate an application in a delegated context. # noqa: E501 Based on the SSL client certificate presented by the TLS layer, authenticate the API caller and return an application session. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = auth_api.v1_app_authenticate_post(async_req=True) >>> result = thread.get() Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Token If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') return self.call_with_http_info(**kwargs) self.v1_app_authenticate_post = _Endpoint( settings={ 'response_type': (Token, ), 'auth': [], 'endpoint_path': '/v1/app/authenticate', 'operation_id': 'v1_app_authenticate_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': {}, 'attribute_map': {}, 'location_map': {}, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_app_authenticate_post) def __v1_app_user_uid_authenticate_post(self, uid, session_token, **kwargs): """PROVISIONAL - Authenicate an application in a delegated context to act on behalf of a user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = auth_api.v1_app_user_uid_authenticate_post(uid, session_token, async_req=True) >>> result = thread.get() Args: uid (int): user id session_token (str): Authorization token obtains from app/authenicate API Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: OboAuthResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['uid'] = \ uid kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_app_user_uid_authenticate_post = _Endpoint( settings={ 'response_type': (OboAuthResponse, ), 'auth': [], 'endpoint_path': '/v1/app/user/{uid}/authenticate', 'operation_id': 'v1_app_user_uid_authenticate_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'uid', 'session_token', ], 'required': [ 'uid', 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'uid': (int, ), 'session_token': (str, ), }, 'attribute_map': { 'uid': 'uid', 'session_token': 'sessionToken', }, 'location_map': { 'uid': 'path', 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_app_user_uid_authenticate_post) def __v1_app_username_username_authenticate_post( self, username, session_token, **kwargs): """PROVISIONAL - Authenicate an application in a delegated context to act on behalf of a user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = auth_api.v1_app_username_username_authenticate_post(username, session_token, async_req=True) >>> result = thread.get() Args: username (str): username session_token (str): Authorization token obtains from app/authenicate API Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: OboAuthResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['username'] = \ username kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_app_username_username_authenticate_post = _Endpoint( settings={ 'response_type': (OboAuthResponse, ), 'auth': [], 'endpoint_path': '/v1/app/username/{username}/authenticate', 'operation_id': 'v1_app_username_username_authenticate_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'username', 'session_token', ], 'required': [ 'username', 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'username': (str, ), 'session_token': (str, ), }, 'attribute_map': { 'username': '******', 'session_token': 'sessionToken', }, 'location_map': { 'username': '******', 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_app_username_username_authenticate_post) def __v1_authenticate_extension_app_post(self, auth_request, **kwargs): """Authenticate a client-extension application # noqa: E501 Based on the application's SSL client certificate presented by the TLS layer, it authenticates the client-extension application and return a symphony verification token. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = auth_api.v1_authenticate_extension_app_post(auth_request, async_req=True) >>> result = thread.get() Args: auth_request (ExtensionAppAuthenticateRequest): application generated token Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: ExtensionAppTokens If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['auth_request'] = \ auth_request return self.call_with_http_info(**kwargs) self.v1_authenticate_extension_app_post = _Endpoint( settings={ 'response_type': (ExtensionAppTokens, ), 'auth': [], 'endpoint_path': '/v1/authenticate/extensionApp', 'operation_id': 'v1_authenticate_extension_app_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'auth_request', ], 'required': [ 'auth_request', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'auth_request': (ExtensionAppAuthenticateRequest, ), }, 'attribute_map': {}, 'location_map': { 'auth_request': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_authenticate_extension_app_post) def __v1_authenticate_post(self, **kwargs): """Authenticate. # noqa: E501 Based on the SSL client certificate presented by the TLS layer, authenticate the API caller and return a session token. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = auth_api.v1_authenticate_post(async_req=True) >>> result = thread.get() Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Token If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') return self.call_with_http_info(**kwargs) self.v1_authenticate_post = _Endpoint(settings={ 'response_type': (Token, ), 'auth': [], 'endpoint_path': '/v1/authenticate', 'operation_id': 'v1_authenticate_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': {}, 'attribute_map': {}, 'location_map': {}, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_authenticate_post) def __v1_logout_post(self, session_token, **kwargs): """Logout. # noqa: E501 Logout a users session. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = auth_api.v1_logout_post(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): the session token to logout. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Token If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_logout_post = _Endpoint(settings={ 'response_type': (Token, ), 'auth': [], 'endpoint_path': '/v1/logout', 'operation_id': 'v1_logout_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_logout_post)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_audittrail_privilegeduser_get( self, session_token, key_manager_token, start_timestamp, **kwargs ): """Get a list of actions performed by a privileged account acting as privileged user given a period of time. # noqa: E501 Get a list of actions performed by a privileged account acting as privileged user given a period of time. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_audittrail_privilegeduser_get(session_token, key_manager_token, start_timestamp, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. start_timestamp (int): Start timestamp in unix timestamp in millseconds. Keyword Args: end_timestamp (int): End timestamp in unix timestamp in millseconds. If not specified, it assumes to be current time. . [optional] before (str): Return results from an opaque “before” cursor value as presented via a response cursor. . [optional] after (str): Return results from an opaque “after” cursor value as presented via a response cursor. . [optional] limit (int): Max No. of violations to return. If no value is provided, 50 is the default. Some maximums for limit may be enforced for performance reasons. The maximum supported value is 500. . [optional] initiator_id (int): If present, only the initiator with this initiator <user id> will be returned. . [optional] role (str): If present, only the audit trail initiated by s user with privileged role acting as privileged user will be returned. Privileged eliglible roles: User Provisioning (USER_PROVISIONING), Content Management (CONTENT_MANAGEMENT), Expression Filter Policy Management (EF_POLICY_MANAGEMENT), SCO (SUPER_COMPLIANCE_OFFICER), CO (COMPLIANCE_OFFICER), Super admin (SUPER_ADMINISTRATOR), Admin (ADMINISTRATOR), L1 (L1_SUPPORT), L2 (L2_SUPPORT), Scope Manager (SCOPE_MANAGEMENT) . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V1AuditTrailInitiatorList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token kwargs['start_timestamp'] = \ start_timestamp return self.call_with_http_info(**kwargs) self.v1_audittrail_privilegeduser_get = _Endpoint( settings={ 'response_type': (V1AuditTrailInitiatorList,), 'auth': [], 'endpoint_path': '/v1/audittrail/privilegeduser', 'operation_id': 'v1_audittrail_privilegeduser_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'key_manager_token', 'start_timestamp', 'end_timestamp', 'before', 'after', 'limit', 'initiator_id', 'role', ], 'required': [ 'session_token', 'key_manager_token', 'start_timestamp', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'session_token': (str,), 'key_manager_token': (str,), 'start_timestamp': (int,), 'end_timestamp': (int,), 'before': (str,), 'after': (str,), 'limit': (int,), 'initiator_id': (int,), 'role': (str,), }, 'attribute_map': { 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'start_timestamp': 'startTimestamp', 'end_timestamp': 'endTimestamp', 'before': 'before', 'after': 'after', 'limit': 'limit', 'initiator_id': 'initiatorId', 'role': 'role', }, 'location_map': { 'session_token': 'header', 'key_manager_token': 'header', 'start_timestamp': 'query', 'end_timestamp': 'query', 'before': 'query', 'after': 'query', 'limit': 'query', 'initiator_id': 'query', 'role': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_audittrail_privilegeduser_get )
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_admin_app_entitlement_list_get(self, session_token, **kwargs): """Get the list of application entitlements for the company # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_app_entitlement_list_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: PodAppEntitlementList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_admin_app_entitlement_list_get = _Endpoint( settings={ 'response_type': (PodAppEntitlementList, ), 'auth': [], 'endpoint_path': '/v1/admin/app/entitlement/list', 'operation_id': 'v1_admin_app_entitlement_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_app_entitlement_list_get) def __v1_admin_app_entitlement_list_post(self, session_token, payload, **kwargs): """Update the application entitlements for the company # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_app_entitlement_list_post(session_token, payload, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. payload (PodAppEntitlementList): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: PodAppEntitlementList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['payload'] = \ payload return self.call_with_http_info(**kwargs) self.v1_admin_app_entitlement_list_post = _Endpoint( settings={ 'response_type': (PodAppEntitlementList, ), 'auth': [], 'endpoint_path': '/v1/admin/app/entitlement/list', 'operation_id': 'v1_admin_app_entitlement_list_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'payload', ], 'required': [ 'session_token', 'payload', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'payload': (PodAppEntitlementList, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', 'payload': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_admin_app_entitlement_list_post) def __v1_admin_user_uid_app_entitlement_list_get( self, session_token, uid, **kwargs): """Get the list of application entitlements for this user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_user_uid_app_entitlement_list_get(session_token, uid, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. uid (int): User ID as a decimal integer Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserAppEntitlementList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['uid'] = \ uid return self.call_with_http_info(**kwargs) self.v1_admin_user_uid_app_entitlement_list_get = _Endpoint( settings={ 'response_type': (UserAppEntitlementList, ), 'auth': [], 'endpoint_path': '/v1/admin/user/{uid}/app/entitlement/list', 'operation_id': 'v1_admin_user_uid_app_entitlement_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'uid', ], 'required': [ 'session_token', 'uid', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'uid': (int, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'uid': 'uid', }, 'location_map': { 'session_token': 'header', 'uid': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_user_uid_app_entitlement_list_get) def __v1_admin_user_uid_app_entitlement_list_patch( self, session_token, uid, payload, **kwargs): """Update unique entitlement of an app for this user. Entitlement can be installation, visibility or product # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_user_uid_app_entitlement_list_patch(session_token, uid, payload, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. uid (int): User ID as a decimal integer payload (UserAppEntitlementsPatchList): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserAppEntitlementList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['uid'] = \ uid kwargs['payload'] = \ payload return self.call_with_http_info(**kwargs) self.v1_admin_user_uid_app_entitlement_list_patch = _Endpoint( settings={ 'response_type': (UserAppEntitlementList, ), 'auth': [], 'endpoint_path': '/v1/admin/user/{uid}/app/entitlement/list', 'operation_id': 'v1_admin_user_uid_app_entitlement_list_patch', 'http_method': 'PATCH', 'servers': None, }, params_map={ 'all': [ 'session_token', 'uid', 'payload', ], 'required': [ 'session_token', 'uid', 'payload', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'uid': (int, ), 'payload': (UserAppEntitlementsPatchList, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'uid': 'uid', }, 'location_map': { 'session_token': 'header', 'uid': 'path', 'payload': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_admin_user_uid_app_entitlement_list_patch) def __v1_admin_user_uid_app_entitlement_list_post( self, session_token, uid, payload, **kwargs): """Update the application entitlements for this user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_user_uid_app_entitlement_list_post(session_token, uid, payload, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. uid (int): User ID as a decimal integer payload (UserAppEntitlementList): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserAppEntitlementList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['uid'] = \ uid kwargs['payload'] = \ payload return self.call_with_http_info(**kwargs) self.v1_admin_user_uid_app_entitlement_list_post = _Endpoint( settings={ 'response_type': (UserAppEntitlementList, ), 'auth': [], 'endpoint_path': '/v1/admin/user/{uid}/app/entitlement/list', 'operation_id': 'v1_admin_user_uid_app_entitlement_list_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'uid', 'payload', ], 'required': [ 'session_token', 'uid', 'payload', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'uid': (int, ), 'payload': (UserAppEntitlementList, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'uid': 'uid', }, 'location_map': { 'session_token': 'header', 'uid': 'path', 'payload': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_admin_user_uid_app_entitlement_list_post)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_info_get( self, **kwargs ): """Get information about the Agent # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_info_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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: AgentInfo If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') return self.call_with_http_info(**kwargs) self.v1_info_get = _Endpoint( settings={ 'response_type': (AgentInfo,), 'auth': [], 'endpoint_path': '/v1/info', 'operation_id': 'v1_info_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, callable=__v1_info_get ) def __v1_signals_create_post( self, session_token, signal, **kwargs ): """Create a signal. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_signals_create_post(session_token, signal, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. signal (BaseSignal): Signal definition. Keyword Args: key_manager_token (str): Key Manager authentication token.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Signal If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['signal'] = \ signal return self.call_with_http_info(**kwargs) self.v1_signals_create_post = _Endpoint( settings={ 'response_type': (Signal,), 'auth': [], 'endpoint_path': '/v1/signals/create', 'operation_id': 'v1_signals_create_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'signal', 'key_manager_token', ], 'required': [ 'session_token', 'signal', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'session_token': (str,), 'signal': (BaseSignal,), 'key_manager_token': (str,), }, 'attribute_map': { 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'session_token': 'header', 'signal': 'body', 'key_manager_token': 'header', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__v1_signals_create_post ) def __v1_signals_id_delete_post( self, session_token, id, **kwargs ): """Delete a signal. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_signals_id_delete_post(session_token, id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. id (str): The id of the signal. Keyword Args: key_manager_token (str): Key Manager authentication token.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['id'] = \ id return self.call_with_http_info(**kwargs) self.v1_signals_id_delete_post = _Endpoint( settings={ 'response_type': (SuccessResponse,), 'auth': [], 'endpoint_path': '/v1/signals/{id}/delete', 'operation_id': 'v1_signals_id_delete_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'id', 'key_manager_token', ], 'required': [ 'session_token', 'id', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'session_token': (str,), 'id': (str,), 'key_manager_token': (str,), }, 'attribute_map': { 'session_token': 'sessionToken', 'id': 'id', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'session_token': 'header', 'id': 'path', 'key_manager_token': 'header', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_signals_id_delete_post ) def __v1_signals_id_get_get( self, session_token, id, **kwargs ): """Get details of the requested signal. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_signals_id_get_get(session_token, id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. id (str): The ID of the signal to display. Keyword Args: key_manager_token (str): Key Manager authentication token.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Signal If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['id'] = \ id return self.call_with_http_info(**kwargs) self.v1_signals_id_get_get = _Endpoint( settings={ 'response_type': (Signal,), 'auth': [], 'endpoint_path': '/v1/signals/{id}/get', 'operation_id': 'v1_signals_id_get_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'id', 'key_manager_token', ], 'required': [ 'session_token', 'id', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'session_token': (str,), 'id': (str,), 'key_manager_token': (str,), }, 'attribute_map': { 'session_token': 'sessionToken', 'id': 'id', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'session_token': 'header', 'id': 'path', 'key_manager_token': 'header', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_signals_id_get_get ) def __v1_signals_id_subscribe_post( self, session_token, id, **kwargs ): """Subscribe to a Signal. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_signals_id_subscribe_post(session_token, id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. id (str): The id of the signal. Keyword Args: key_manager_token (str): Key Manager authentication token.. [optional] pushed (bool): Prevent the user to unsubscribe (only for bulk subscription). [optional] users ([int]): UserIds to subscribe (only for bulk subscription). [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: ChannelSubscriptionResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['id'] = \ id return self.call_with_http_info(**kwargs) self.v1_signals_id_subscribe_post = _Endpoint( settings={ 'response_type': (ChannelSubscriptionResponse,), 'auth': [], 'endpoint_path': '/v1/signals/{id}/subscribe', 'operation_id': 'v1_signals_id_subscribe_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'id', 'key_manager_token', 'pushed', 'users', ], 'required': [ 'session_token', 'id', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'session_token': (str,), 'id': (str,), 'key_manager_token': (str,), 'pushed': (bool,), 'users': ([int],), }, 'attribute_map': { 'session_token': 'sessionToken', 'id': 'id', 'key_manager_token': 'keyManagerToken', 'pushed': 'pushed', }, 'location_map': { 'session_token': 'header', 'id': 'path', 'key_manager_token': 'header', 'pushed': 'query', 'users': 'body', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__v1_signals_id_subscribe_post ) def __v1_signals_id_subscribers_get( self, session_token, id, **kwargs ): """Get the subscribers of a signal # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_signals_id_subscribers_get(session_token, id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. id (str): The id of the signal. Keyword Args: key_manager_token (str): Key Manager authentication token.. [optional] skip (int): No. of results to skip.. [optional] if omitted the server will use the default value of 0 limit (int): Max No. of subscribers to return. If no value is provided, 100 is the default.. [optional] if omitted the server will use the default value of 100 _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: ChannelSubscriberResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['id'] = \ id return self.call_with_http_info(**kwargs) self.v1_signals_id_subscribers_get = _Endpoint( settings={ 'response_type': (ChannelSubscriberResponse,), 'auth': [], 'endpoint_path': '/v1/signals/{id}/subscribers', 'operation_id': 'v1_signals_id_subscribers_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'id', 'key_manager_token', 'skip', 'limit', ], 'required': [ 'session_token', 'id', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'session_token': (str,), 'id': (str,), 'key_manager_token': (str,), 'skip': (int,), 'limit': (int,), }, 'attribute_map': { 'session_token': 'sessionToken', 'id': 'id', 'key_manager_token': 'keyManagerToken', 'skip': 'skip', 'limit': 'limit', }, 'location_map': { 'session_token': 'header', 'id': 'path', 'key_manager_token': 'header', 'skip': 'query', 'limit': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_signals_id_subscribers_get ) def __v1_signals_id_unsubscribe_post( self, session_token, id, **kwargs ): """Unsubscribe to a Signal. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_signals_id_unsubscribe_post(session_token, id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. id (str): The id of the signal. Keyword Args: key_manager_token (str): Key Manager authentication token.. [optional] users ([int]): UserIds to unsubscribe (only for bulk unsubscription). [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: ChannelSubscriptionResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['id'] = \ id return self.call_with_http_info(**kwargs) self.v1_signals_id_unsubscribe_post = _Endpoint( settings={ 'response_type': (ChannelSubscriptionResponse,), 'auth': [], 'endpoint_path': '/v1/signals/{id}/unsubscribe', 'operation_id': 'v1_signals_id_unsubscribe_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'id', 'key_manager_token', 'users', ], 'required': [ 'session_token', 'id', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'session_token': (str,), 'id': (str,), 'key_manager_token': (str,), 'users': ([int],), }, 'attribute_map': { 'session_token': 'sessionToken', 'id': 'id', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'session_token': 'header', 'id': 'path', 'key_manager_token': 'header', 'users': 'body', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__v1_signals_id_unsubscribe_post ) def __v1_signals_id_update_post( self, session_token, id, signal, **kwargs ): """Update a signal. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_signals_id_update_post(session_token, id, signal, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. id (str): The id of the signal. signal (BaseSignal): Signal definition. Keyword Args: key_manager_token (str): Key Manager authentication token.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Signal If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['id'] = \ id kwargs['signal'] = \ signal return self.call_with_http_info(**kwargs) self.v1_signals_id_update_post = _Endpoint( settings={ 'response_type': (Signal,), 'auth': [], 'endpoint_path': '/v1/signals/{id}/update', 'operation_id': 'v1_signals_id_update_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'id', 'signal', 'key_manager_token', ], 'required': [ 'session_token', 'id', 'signal', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'session_token': (str,), 'id': (str,), 'signal': (BaseSignal,), 'key_manager_token': (str,), }, 'attribute_map': { 'session_token': 'sessionToken', 'id': 'id', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'session_token': 'header', 'id': 'path', 'signal': 'body', 'key_manager_token': 'header', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [ 'application/json' ] }, api_client=api_client, callable=__v1_signals_id_update_post ) def __v1_signals_list_get( self, session_token, **kwargs ): """List signals for the requesting user. This includes signals that the user has created and public signals to which they subscribed. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_signals_list_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: key_manager_token (str): Key Manager authentication token.. [optional] skip (int): No. of signals to skip. . [optional] limit (int): Max no. of signals to return. If no value is provided, 50 is the default. The maximum supported value is 500. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SignalList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_signals_list_get = _Endpoint( settings={ 'response_type': (SignalList,), 'auth': [], 'endpoint_path': '/v1/signals/list', 'operation_id': 'v1_signals_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'key_manager_token', 'skip', 'limit', ], 'required': [ 'session_token', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'session_token': (str,), 'key_manager_token': (str,), 'skip': (int,), 'limit': (int,), }, 'attribute_map': { 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'skip': 'skip', 'limit': 'limit', }, 'location_map': { 'session_token': 'header', 'key_manager_token': 'header', 'skip': 'query', 'limit': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_signals_list_get )
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __pubkey_app_authenticate_post(self, authenticate_request, **kwargs): """Authenticate an App with public key # noqa: E501 Based on an authentication request token signed by the application's RSA private key, authenticate the API caller and return a session token. A HTTP 401 Unauthorized error is returned on errors during authentication (e.g. invalid app, malformed authentication token, app's public key not imported in the pod, invalid token signature etc.). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = login_api.pubkey_app_authenticate_post(authenticate_request, async_req=True) >>> result = thread.get() Args: authenticate_request (AuthenticateRequest): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Token If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['authenticate_request'] = \ authenticate_request return self.call_with_http_info(**kwargs) self.pubkey_app_authenticate_post = _Endpoint( settings={ 'response_type': (Token, ), 'auth': [], 'endpoint_path': '/pubkey/app/authenticate', 'operation_id': 'pubkey_app_authenticate_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'authenticate_request', ], 'required': [ 'authenticate_request', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'authenticate_request': (AuthenticateRequest, ), }, 'attribute_map': {}, 'location_map': { 'authenticate_request': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__pubkey_app_authenticate_post) def __pubkey_app_user_user_id_authenticate_post( self, session_token, user_id, **kwargs): """Authenticate an application in a delegated context to act on behalf of a user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = login_api.pubkey_app_user_user_id_authenticate_post(session_token, user_id, async_req=True) >>> result = thread.get() Args: session_token (str): App Session authentication token. user_id (int): the user ID Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Token If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['user_id'] = \ user_id return self.call_with_http_info(**kwargs) self.pubkey_app_user_user_id_authenticate_post = _Endpoint( settings={ 'response_type': (Token, ), 'auth': [], 'endpoint_path': '/pubkey/app/user/{userId}/authenticate', 'operation_id': 'pubkey_app_user_user_id_authenticate_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'user_id', ], 'required': [ 'session_token', 'user_id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'user_id': (int, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'user_id': 'userId', }, 'location_map': { 'session_token': 'header', 'user_id': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__pubkey_app_user_user_id_authenticate_post) def __pubkey_app_username_username_authenticate_post( self, session_token, username, **kwargs): """Authenticate an application in a delegated context to act on behalf of a user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = login_api.pubkey_app_username_username_authenticate_post(session_token, username, async_req=True) >>> result = thread.get() Args: session_token (str): App Session authentication token. username (str): the username Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Token If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['username'] = \ username return self.call_with_http_info(**kwargs) self.pubkey_app_username_username_authenticate_post = _Endpoint( settings={ 'response_type': (Token, ), 'auth': [], 'endpoint_path': '/pubkey/app/username/{username}/authenticate', 'operation_id': 'pubkey_app_username_username_authenticate_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'username', ], 'required': [ 'session_token', 'username', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'username': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'username': '******', }, 'location_map': { 'session_token': 'header', 'username': '******', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__pubkey_app_username_username_authenticate_post) def __pubkey_authenticate_post(self, authenticate_request, **kwargs): """Authenticate with public key # noqa: E501 Based on an authentication request token signed by the caller's RSA private key, authenticate the API caller and return a session token. A HTTP 401 Unauthorized error is returned on errors during authentication (e.g. invalid user, malformed authentication token, user's public key not imported in the pod, invalid token signature etc.). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = login_api.pubkey_authenticate_post(authenticate_request, async_req=True) >>> result = thread.get() Args: authenticate_request (AuthenticateRequest): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: Token If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['authenticate_request'] = \ authenticate_request return self.call_with_http_info(**kwargs) self.pubkey_authenticate_post = _Endpoint( settings={ 'response_type': (Token, ), 'auth': [], 'endpoint_path': '/pubkey/authenticate', 'operation_id': 'pubkey_authenticate_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'authenticate_request', ], 'required': [ 'authenticate_request', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'authenticate_request': (AuthenticateRequest, ), }, 'attribute_map': {}, 'location_map': { 'authenticate_request': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__pubkey_authenticate_post) def __v1_pubkey_app_authenticate_extension_app_post( self, authenticate_request, **kwargs): """Authenticate extension app with public key # noqa: E501 Based on an authentication request token signed by the caller's RSA private key, authenticate the API caller and return a session token. A HTTP 401 Unauthorized error is returned on errors during authentication (e.g. invalid user, malformed authentication token, user's public key not imported in the pod, invalid token signature etc.). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = login_api.v1_pubkey_app_authenticate_extension_app_post(authenticate_request, async_req=True) >>> result = thread.get() Args: authenticate_request (AuthenticateExtensionAppRequest): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: ExtensionAppTokens If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['authenticate_request'] = \ authenticate_request return self.call_with_http_info(**kwargs) self.v1_pubkey_app_authenticate_extension_app_post = _Endpoint( settings={ 'response_type': (ExtensionAppTokens, ), 'auth': [], 'endpoint_path': '/v1/pubkey/app/authenticate/extensionApp', 'operation_id': 'v1_pubkey_app_authenticate_extension_app_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'authenticate_request', ], 'required': [ 'authenticate_request', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'authenticate_request': (AuthenticateExtensionAppRequest, ), }, 'attribute_map': {}, 'location_map': { 'authenticate_request': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_pubkey_app_authenticate_extension_app_post)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __delete_allowed_file_extension(self, session_token, extension, **kwargs): """Allows deletion of a specific file extension supported for upload # noqa: E501 Provides a method to delete a specific file extension configured for upload support via an admin. The file extension identifying the resource is treated case-insensitively by the API. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.delete_allowed_file_extension(session_token, extension, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. extension (str): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: None If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['extension'] = \ extension return self.call_with_http_info(**kwargs) self.delete_allowed_file_extension = _Endpoint( settings={ 'response_type': None, 'auth': [], 'endpoint_path': '/file_ext/v1/allowed_extensions/{extension}', 'operation_id': 'delete_allowed_file_extension', 'http_method': 'DELETE', 'servers': None, }, params_map={ 'all': [ 'session_token', 'extension', ], 'required': [ 'session_token', 'extension', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'extension': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'extension': 'extension', }, 'location_map': { 'session_token': 'header', 'extension': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__delete_allowed_file_extension) def __list_allowed_file_extensions(self, **kwargs): """Allows iteration of all file extensions supported for upload # noqa: E501 Provides a RESTful API to iterate all file extensions configured by the tenant admin that are allowed for the upload. Pagination of this list is managed through a combination of the optional request parameters and service-side managed maximums. Pagination of the results is provided through the before or after input paramters and presented through the opaque cursor values provided as output from a previous response. Only one of before or after or neither may be provided. DO NOT store cursors. Cursors can quickly become invalid if items are added or deleted. Use them only during a short-period of time that you are traversing the list. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.list_allowed_file_extensions(async_req=True) >>> result = thread.get() Keyword Args: limit (int): This is the maximum number of objects that may be returned. A query may return fewer than the value of limit due to filtering or service-side maximums. Do not depend on the number of results being fewer than the limit value to indicate your query reached the end of the list of data, use the absence of next instead as described below. For example, if you set limit to 10 and 9 results are returned, there may be more data available, but one item was removed due to privacy filtering. Some maximums for limit may be enforced for performance reasons. In all cases, the API returns the correct pagination links. . [optional] before (str): Returns results from an opaque \"before\" cursor value as presented via a response cursor . [optional] after (str): Returns results from an opaque \"after\" cursor value as presented via a response cursor . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: FileExtensionsResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') return self.call_with_http_info(**kwargs) self.list_allowed_file_extensions = _Endpoint( settings={ 'response_type': (FileExtensionsResponse, ), 'auth': [], 'endpoint_path': '/file_ext/v1/allowed_extensions', 'operation_id': 'list_allowed_file_extensions', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'limit', 'before', 'after', ], 'required': [], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'limit': (int, ), 'before': (str, ), 'after': (str, ), }, 'attribute_map': { 'limit': 'limit', 'before': 'before', 'after': 'after', }, 'location_map': { 'limit': 'query', 'before': 'query', 'after': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__list_allowed_file_extensions) def __put_allowed_file_extension(self, session_token, extension, v3_file_extension, **kwargs): """Allows replacement or creation of a specific file extension supported for upload # noqa: E501 Provides a method to create or replace a specific file extension configured for upload support via an admin. The API treats the file extension in the path case-insensitively by converting it to lowecase. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.put_allowed_file_extension(session_token, extension, v3_file_extension, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. extension (str): v3_file_extension (FileExtension): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: FileExtension If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['extension'] = \ extension kwargs['v3_file_extension'] = \ v3_file_extension return self.call_with_http_info(**kwargs) self.put_allowed_file_extension = _Endpoint( settings={ 'response_type': (FileExtension, ), 'auth': [], 'endpoint_path': '/file_ext/v1/allowed_extensions/{extension}', 'operation_id': 'put_allowed_file_extension', 'http_method': 'PUT', 'servers': None, }, params_map={ 'all': [ 'session_token', 'extension', 'v3_file_extension', ], 'required': [ 'session_token', 'extension', 'v3_file_extension', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'extension': (str, ), 'v3_file_extension': (FileExtension, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'extension': 'extension', }, 'location_map': { 'session_token': 'header', 'extension': 'path', 'v3_file_extension': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__put_allowed_file_extension) def __v1_admin_messages_message_id_metadata_relationships_get( self, session_token, user_agent, message_id, **kwargs): """Get the message metadata relationship # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_messages_message_id_metadata_relationships_get(session_token, user_agent, message_id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. user_agent (str): Request user agent. message_id (str): Valid id of a SOCIALMESSAGE Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: MessageMetadataResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['user_agent'] = \ user_agent kwargs['message_id'] = \ message_id return self.call_with_http_info(**kwargs) self.v1_admin_messages_message_id_metadata_relationships_get = _Endpoint( settings={ 'response_type': (MessageMetadataResponse, ), 'auth': [], 'endpoint_path': '/v1/admin/messages/{messageId}/metadata/relationships', 'operation_id': 'v1_admin_messages_message_id_metadata_relationships_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'user_agent', 'message_id', ], 'required': [ 'session_token', 'user_agent', 'message_id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'user_agent': (str, ), 'message_id': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'user_agent': 'User-Agent', 'message_id': 'messageId', }, 'location_map': { 'session_token': 'header', 'user_agent': 'header', 'message_id': 'path', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_messages_message_id_metadata_relationships_get) def __v1_admin_messages_message_id_receipts_get( self, session_token, message_id, **kwargs): """Fetch receipts details from a specific message. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_messages_message_id_receipts_get(session_token, message_id, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. message_id (str): The message ID Keyword Args: before (str): Returns results from an opaque “before” cursor value as presented via a response cursor.. [optional] after (str): Returns results from an opaque “after” cursor value as presented via a response cursor.. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: MessageReceiptDetailResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['message_id'] = \ message_id return self.call_with_http_info(**kwargs) self.v1_admin_messages_message_id_receipts_get = _Endpoint( settings={ 'response_type': (MessageReceiptDetailResponse, ), 'auth': [], 'endpoint_path': '/v1/admin/messages/{messageId}/receipts', 'operation_id': 'v1_admin_messages_message_id_receipts_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'message_id', 'before', 'after', ], 'required': [ 'session_token', 'message_id', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'message_id': (str, ), 'before': (str, ), 'after': (str, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'message_id': 'messageId', 'before': 'before', 'after': 'after', }, 'location_map': { 'session_token': 'header', 'message_id': 'path', 'before': 'query', 'after': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_admin_messages_message_id_receipts_get) def __v1_admin_messages_post(self, session_token, message_ids, **kwargs): """Fetch message details # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_messages_post(session_token, message_ids, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token message_ids (MessageIds): the ids of the messages to be fetched Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: MessageDetails If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['message_ids'] = \ message_ids return self.call_with_http_info(**kwargs) self.v1_admin_messages_post = _Endpoint( settings={ 'response_type': (MessageDetails, ), 'auth': [], 'endpoint_path': '/v1/admin/messages', 'operation_id': 'v1_admin_messages_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'message_ids', ], 'required': [ 'session_token', 'message_ids', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'message_ids': (MessageIds, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', 'message_ids': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_admin_messages_post)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_companycert_delete_post(self, session_token, finger_print, **kwargs): """Delete a company certificate # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_companycert_delete_post(session_token, finger_print, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. finger_print (StringId): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['finger_print'] = \ finger_print return self.call_with_http_info(**kwargs) self.v1_companycert_delete_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/companycert/delete', 'operation_id': 'v1_companycert_delete_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'finger_print', ], 'required': [ 'session_token', 'finger_print', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'finger_print': (StringId, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', 'finger_print': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_companycert_delete_post) def __v1_companycert_finger_print_get_get(self, finger_print, session_token, **kwargs): """Get the details of a company certificate # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_companycert_finger_print_get_get(finger_print, session_token, async_req=True) >>> result = thread.get() Args: finger_print (str): Certificate fingerPrint (ID) session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: CompanyCertDetail If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['finger_print'] = \ finger_print kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_companycert_finger_print_get_get = _Endpoint( settings={ 'response_type': (CompanyCertDetail, ), 'auth': [], 'endpoint_path': '/v1/companycert/{fingerPrint}/get', 'operation_id': 'v1_companycert_finger_print_get_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'finger_print', 'session_token', ], 'required': [ 'finger_print', 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'finger_print': (str, ), 'session_token': (str, ), }, 'attribute_map': { 'finger_print': 'fingerPrint', 'session_token': 'sessionToken', }, 'location_map': { 'finger_print': 'path', 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_companycert_finger_print_get_get) def __v1_companycert_finger_print_issued_by_get( self, finger_print, session_token, **kwargs): """Return a list of all certificates which were verified to the cert whose fingerprint is passed. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_companycert_finger_print_issued_by_get(finger_print, session_token, async_req=True) >>> result = thread.get() Args: finger_print (str): Certificate fingerPrint (ID) session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: CompanyCertInfoList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['finger_print'] = \ finger_print kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_companycert_finger_print_issued_by_get = _Endpoint( settings={ 'response_type': (CompanyCertInfoList, ), 'auth': [], 'endpoint_path': '/v1/companycert/{fingerPrint}/issuedBy', 'operation_id': 'v1_companycert_finger_print_issued_by_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'finger_print', 'session_token', ], 'required': [ 'finger_print', 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'finger_print': (str, ), 'session_token': (str, ), }, 'attribute_map': { 'finger_print': 'fingerPrint', 'session_token': 'sessionToken', }, 'location_map': { 'finger_print': 'path', 'session_token': 'header', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_companycert_finger_print_issued_by_get) def __v1_companycert_finger_print_update_post(self, finger_print, session_token, cert_attributes, **kwargs): """Update a company certificate # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_companycert_finger_print_update_post(finger_print, session_token, cert_attributes, async_req=True) >>> result = thread.get() Args: finger_print (str): Certificate fingerPrint (ID) session_token (str): Session authentication token. cert_attributes (CompanyCertAttributes): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: SuccessResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['finger_print'] = \ finger_print kwargs['session_token'] = \ session_token kwargs['cert_attributes'] = \ cert_attributes return self.call_with_http_info(**kwargs) self.v1_companycert_finger_print_update_post = _Endpoint( settings={ 'response_type': (SuccessResponse, ), 'auth': [], 'endpoint_path': '/v1/companycert/{fingerPrint}/update', 'operation_id': 'v1_companycert_finger_print_update_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'finger_print', 'session_token', 'cert_attributes', ], 'required': [ 'finger_print', 'session_token', 'cert_attributes', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'finger_print': (str, ), 'session_token': (str, ), 'cert_attributes': (CompanyCertAttributes, ), }, 'attribute_map': { 'finger_print': 'fingerPrint', 'session_token': 'sessionToken', }, 'location_map': { 'finger_print': 'path', 'session_token': 'header', 'cert_attributes': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_companycert_finger_print_update_post) def __v1_companycert_list_get(self, session_token, **kwargs): """List all trusted certs # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_companycert_list_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: skip (int): Pagination start. [optional] limit (int): Row limit. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: CompanyCertInfoList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_companycert_list_get = _Endpoint( settings={ 'response_type': (CompanyCertInfoList, ), 'auth': [], 'endpoint_path': '/v1/companycert/list', 'operation_id': 'v1_companycert_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'skip', 'limit', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'skip': (int, ), 'limit': (int, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'skip': 'skip', 'limit': 'limit', }, 'location_map': { 'session_token': 'header', 'skip': 'query', 'limit': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_companycert_list_get) def __v1_companycert_podmanaged_list_get(self, session_token, **kwargs): """List all trusted certs # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_companycert_podmanaged_list_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: skip (int): Pagination start. [optional] limit (int): Row limit. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: CompanyCertInfoList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_companycert_podmanaged_list_get = _Endpoint( settings={ 'response_type': (CompanyCertInfoList, ), 'auth': [], 'endpoint_path': '/v1/companycert/podmanaged/list', 'operation_id': 'v1_companycert_podmanaged_list_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'skip', 'limit', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'skip': (int, ), 'limit': (int, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'skip': 'skip', 'limit': 'limit', }, 'location_map': { 'session_token': 'header', 'skip': 'query', 'limit': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v1_companycert_podmanaged_list_get) def __v1_companycert_type_list_post(self, session_token, type_id_list, **kwargs): """List all certs of the given types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_companycert_type_list_post(session_token, type_id_list, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. type_id_list (CompanyCertTypeList): Certificate type list Keyword Args: skip (int): Pagination start. [optional] limit (int): Row limit. [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: CompanyCertInfoList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['type_id_list'] = \ type_id_list return self.call_with_http_info(**kwargs) self.v1_companycert_type_list_post = _Endpoint( settings={ 'response_type': (CompanyCertInfoList, ), 'auth': [], 'endpoint_path': '/v1/companycert/type/list', 'operation_id': 'v1_companycert_type_list_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'type_id_list', 'skip', 'limit', ], 'required': [ 'session_token', 'type_id_list', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'type_id_list': (CompanyCertTypeList, ), 'skip': (int, ), 'limit': (int, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'skip': 'skip', 'limit': 'limit', }, 'location_map': { 'session_token': 'header', 'type_id_list': 'body', 'skip': 'query', 'limit': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_companycert_type_list_post) def __v2_companycert_create_post(self, session_token, cert, **kwargs): """Create a company trusted or untrusted certificate. Different from V1 in that we reject expired certificates. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v2_companycert_create_post(session_token, cert, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. cert (CompanyCert): Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: CompanyCertDetail If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['cert'] = \ cert return self.call_with_http_info(**kwargs) self.v2_companycert_create_post = _Endpoint( settings={ 'response_type': (CompanyCertDetail, ), 'auth': [], 'endpoint_path': '/v2/companycert/create', 'operation_id': 'v2_companycert_create_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'cert', ], 'required': [ 'session_token', 'cert', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'cert': (CompanyCert, ), }, 'attribute_map': { 'session_token': 'sessionToken', }, 'location_map': { 'session_token': 'header', 'cert': 'body', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v2_companycert_create_post)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_admin_messagesuppression_id_suppress_post( self, id, session_token, **kwargs ): """Suppress a message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_admin_messagesuppression_id_suppress_post(id, session_token, async_req=True) >>> result = thread.get() Args: id (str): URL-Safe encoded Message ID session_token (str): Session authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: MessageSuppressionResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['id'] = \ id kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v1_admin_messagesuppression_id_suppress_post = _Endpoint( settings={ 'response_type': (MessageSuppressionResponse,), 'auth': [], 'endpoint_path': '/v1/admin/messagesuppression/{id}/suppress', 'operation_id': 'v1_admin_messagesuppression_id_suppress_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'id', 'session_token', ], 'required': [ 'id', 'session_token', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'id': (str,), 'session_token': (str,), }, 'attribute_map': { 'id': 'id', 'session_token': 'sessionToken', }, 'location_map': { 'id': 'path', 'session_token': 'header', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_admin_messagesuppression_id_suppress_post )
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_user_search_post(self, session_token, search_request, **kwargs): """Search for users by name or email address # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v1_user_search_post(session_token, search_request, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. search_request (UserSearchQuery): search criteria Keyword Args: skip (int): number of records to skip. [optional] limit (int): Max number of records to return. If no value is provided, 50 is the default.. [optional] local (bool): If true then a local DB search will be performed and only local pod users will be returned. If absent or false then a directory search will be performed and users from other pods who are visible to the calling user will also be returned. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserSearchResults If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token kwargs['search_request'] = \ search_request return self.call_with_http_info(**kwargs) self.v1_user_search_post = _Endpoint(settings={ 'response_type': (UserSearchResults, ), 'auth': [], 'endpoint_path': '/v1/user/search', 'operation_id': 'v1_user_search_post', 'http_method': 'POST', 'servers': None, }, params_map={ 'all': [ 'session_token', 'search_request', 'skip', 'limit', 'local', ], 'required': [ 'session_token', 'search_request', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'search_request': (UserSearchQuery, ), 'skip': (int, ), 'limit': (int, ), 'local': (bool, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'skip': 'skip', 'limit': 'limit', 'local': 'local', }, 'location_map': { 'session_token': 'header', 'search_request': 'body', 'skip': 'query', 'limit': 'query', 'local': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': ['application/json'] }, api_client=api_client, callable=__v1_user_search_post) def __v2_user_get(self, session_token, **kwargs): """Get user information # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v2_user_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: uid (int): User ID as a decimal integer. [optional] email (str): Email address. [optional] username (str): login user name. [optional] local (bool): If true then a local DB search will be performed and only local pod users will be returned. If absent or false then a directory search will be performed and users from other pods who are visible to the calling user will also be returned. Note: for username search, the local flag must be true . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: UserV2 If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v2_user_get = _Endpoint(settings={ 'response_type': (UserV2, ), 'auth': [], 'endpoint_path': '/v2/user', 'operation_id': 'v2_user_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'uid', 'email', 'username', 'local', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'uid': (int, ), 'email': (str, ), 'username': (str, ), 'local': (bool, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'uid': 'uid', 'email': 'email', 'username': '******', 'local': 'local', }, 'location_map': { 'session_token': 'header', 'uid': 'query', 'email': 'query', 'username': '******', 'local': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v2_user_get) def __v3_users_get(self, session_token, **kwargs): """Search users by emails or ids. Only one of the search lists should be informed at a time. Search lists may containt up to 100 elements. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = pod_api.v3_users_get(session_token, async_req=True) >>> result = thread.get() Args: session_token (str): Session authentication token. Keyword Args: uid (str): User IDs as a list of decimal integers separated by comma. [optional] email (str): List of email addresses separated by comma. [optional] username (str): List of username separated by comma. [optional] local (bool): If true then a local DB search will be performed and only local pod users will be returned. If absent or false then a directory search will be performed and users from other pods who are visible to the calling user will also be returned. . [optional] active (bool): If not set all user status will be returned, if true all active users will be returned, if false all inactive users will be returned . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V2UserList If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get('async_req', False) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True) kwargs['_preload_content'] = kwargs.get('_preload_content', True) kwargs['_request_timeout'] = kwargs.get('_request_timeout', None) kwargs['_check_input_type'] = kwargs.get('_check_input_type', True) kwargs['_check_return_type'] = kwargs.get('_check_return_type', True) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['session_token'] = \ session_token return self.call_with_http_info(**kwargs) self.v3_users_get = _Endpoint(settings={ 'response_type': (V2UserList, ), 'auth': [], 'endpoint_path': '/v3/users', 'operation_id': 'v3_users_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'session_token', 'uid', 'email', 'username', 'local', 'active', ], 'required': [ 'session_token', ], 'nullable': [], 'enum': [], 'validation': [] }, root_map={ 'validations': {}, 'allowed_values': {}, 'openapi_types': { 'session_token': (str, ), 'uid': (str, ), 'email': (str, ), 'username': (str, ), 'local': (bool, ), 'active': (bool, ), }, 'attribute_map': { 'session_token': 'sessionToken', 'uid': 'uid', 'email': 'email', 'username': '******', 'local': 'local', 'active': 'active', }, 'location_map': { 'session_token': 'header', 'uid': 'query', 'email': 'query', 'username': '******', 'local': 'query', 'active': 'query', }, 'collection_format_map': {} }, headers_map={ 'accept': ['application/json'], 'content_type': [], }, api_client=api_client, callable=__v3_users_get)
def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def __v1_dlp_violations_message_get( self, start_time, session_token, key_manager_token, **kwargs ): """Get violations as a result of policy enforcement on messages. # noqa: E501 TBD # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_dlp_violations_message_get(start_time, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: start_time (int): Timestamp of the first required violation. This is a long integer value representing milliseconds since Jan 1 1970 session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: end_time (int): Timestamp of the last required violation. This is a long integer value representing milliseconds since Jan 1 1970 If unspecified, it will default to current time of the request. . [optional] next (str): Offset of the next chunk of violations. Value is null for the first request. . [optional] limit (int): Max No. of violations to return. If no value is provided, 50 is the default. The maximum supported value is 500. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V1DLPViolationMessageResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['start_time'] = \ start_time kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v1_dlp_violations_message_get = _Endpoint( settings={ 'response_type': (V1DLPViolationMessageResponse,), 'auth': [], 'endpoint_path': '/v1/dlp/violations/message', 'operation_id': 'v1_dlp_violations_message_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'start_time', 'session_token', 'key_manager_token', 'end_time', 'next', 'limit', ], 'required': [ 'start_time', 'session_token', 'key_manager_token', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'start_time': (int,), 'session_token': (str,), 'key_manager_token': (str,), 'end_time': (int,), 'next': (str,), 'limit': (int,), }, 'attribute_map': { 'start_time': 'startTime', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'end_time': 'endTime', 'next': 'next', 'limit': 'limit', }, 'location_map': { 'start_time': 'query', 'session_token': 'header', 'key_manager_token': 'header', 'end_time': 'query', 'next': 'query', 'limit': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_dlp_violations_message_get ) def __v1_dlp_violations_signal_get( self, start_time, session_token, key_manager_token, **kwargs ): """Get violations as a result of policy enforcement on signals. # noqa: E501 TBD # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_dlp_violations_signal_get(start_time, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: start_time (int): Timestamp of the first required violation. This is a long integer value representing milliseconds since Jan 1 1970 session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: end_time (int): Timestamp of the last required violation. This is a long integer value representing milliseconds since Jan 1 1970 If unspecified, it will default to current time of the request. . [optional] next (str): Offset of the next chunk of violations. Value is null for the first request. . [optional] limit (int): Max No. of violations to return. If no value is provided, 50 is the default. The maximum supported value is 500. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V1DLPViolationSignalResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['start_time'] = \ start_time kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v1_dlp_violations_signal_get = _Endpoint( settings={ 'response_type': (V1DLPViolationSignalResponse,), 'auth': [], 'endpoint_path': '/v1/dlp/violations/signal', 'operation_id': 'v1_dlp_violations_signal_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'start_time', 'session_token', 'key_manager_token', 'end_time', 'next', 'limit', ], 'required': [ 'start_time', 'session_token', 'key_manager_token', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'start_time': (int,), 'session_token': (str,), 'key_manager_token': (str,), 'end_time': (int,), 'next': (str,), 'limit': (int,), }, 'attribute_map': { 'start_time': 'startTime', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'end_time': 'endTime', 'next': 'next', 'limit': 'limit', }, 'location_map': { 'start_time': 'query', 'session_token': 'header', 'key_manager_token': 'header', 'end_time': 'query', 'next': 'query', 'limit': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_dlp_violations_signal_get ) def __v1_dlp_violations_stream_get( self, start_time, session_token, key_manager_token, **kwargs ): """Get violations as a result of policy enforcement on streams. # noqa: E501 TBD # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v1_dlp_violations_stream_get(start_time, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: start_time (int): Timestamp of the first required violation. This is a long integer value representing milliseconds since Jan 1 1970 session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: end_time (int): Timestamp of the last required violation. This is a long integer value representing milliseconds since Jan 1 1970 If unspecified, it will default to current time of the request. . [optional] next (str): Offset of the next chunk of violations. Value is null for the first request. . [optional] limit (int): Max No. of violations to return. If no value is provided, 50 is the default. The maximum supported value is 500. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V1DLPViolationStreamResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['start_time'] = \ start_time kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v1_dlp_violations_stream_get = _Endpoint( settings={ 'response_type': (V1DLPViolationStreamResponse,), 'auth': [], 'endpoint_path': '/v1/dlp/violations/stream', 'operation_id': 'v1_dlp_violations_stream_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'start_time', 'session_token', 'key_manager_token', 'end_time', 'next', 'limit', ], 'required': [ 'start_time', 'session_token', 'key_manager_token', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'start_time': (int,), 'session_token': (str,), 'key_manager_token': (str,), 'end_time': (int,), 'next': (str,), 'limit': (int,), }, 'attribute_map': { 'start_time': 'startTime', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'end_time': 'endTime', 'next': 'next', 'limit': 'limit', }, 'location_map': { 'start_time': 'query', 'session_token': 'header', 'key_manager_token': 'header', 'end_time': 'query', 'next': 'query', 'limit': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v1_dlp_violations_stream_get ) def __v3_dlp_violation_attachment_get( self, file_id, violation_id, session_token, key_manager_token, **kwargs ): """Get attachments that were sent as part of messages that were flagged by the DLP System. # noqa: E501 Retrieves attachments from related message violations as a base64 encoded String. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v3_dlp_violation_attachment_get(file_id, violation_id, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: file_id (str): ID of attachment that will be downloaded. violation_id (str): ID of violation that corresponds to the flagged message that contains the attachment session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: _return_http_data_only (bool): response data without head status code and headers. Default is True. _preload_content (bool): if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. _request_timeout (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: str If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['file_id'] = \ file_id kwargs['violation_id'] = \ violation_id kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v3_dlp_violation_attachment_get = _Endpoint( settings={ 'response_type': (str,), 'auth': [], 'endpoint_path': '/v3/dlp/violation/attachment', 'operation_id': 'v3_dlp_violation_attachment_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'file_id', 'violation_id', 'session_token', 'key_manager_token', ], 'required': [ 'file_id', 'violation_id', 'session_token', 'key_manager_token', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'file_id': (str,), 'violation_id': (str,), 'session_token': (str,), 'key_manager_token': (str,), }, 'attribute_map': { 'file_id': 'fileId', 'violation_id': 'violationId', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', }, 'location_map': { 'file_id': 'query', 'violation_id': 'query', 'session_token': 'header', 'key_manager_token': 'header', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/octet-stream' ], 'content_type': [], }, api_client=api_client, callable=__v3_dlp_violation_attachment_get ) def __v3_dlp_violations_message_get( self, start_time, session_token, key_manager_token, **kwargs ): """Get violations as a result of policy enforcement on messages. # noqa: E501 Retrieves DLP v3 message related violations for a given time range # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v3_dlp_violations_message_get(start_time, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: start_time (int): Timestamp of the first required violation. This is a long integer value representing milliseconds since Jan 1 1970 session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: end_time (int): Timestamp of the last required violation. This is a long integer value representing milliseconds since Jan 1 1970 If unspecified, it will default to current time of the request. . [optional] next (str): Offset of the next chunk of violations. Value is null for the first request. . [optional] limit (int): Max No. of violations to return. If no value is provided, 50 is the default. The maximum supported value is 500. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V3DLPViolationMessageResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['start_time'] = \ start_time kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v3_dlp_violations_message_get = _Endpoint( settings={ 'response_type': (V3DLPViolationMessageResponse,), 'auth': [], 'endpoint_path': '/v3/dlp/violations/message', 'operation_id': 'v3_dlp_violations_message_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'start_time', 'session_token', 'key_manager_token', 'end_time', 'next', 'limit', ], 'required': [ 'start_time', 'session_token', 'key_manager_token', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'start_time': (int,), 'session_token': (str,), 'key_manager_token': (str,), 'end_time': (int,), 'next': (str,), 'limit': (int,), }, 'attribute_map': { 'start_time': 'startTime', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'end_time': 'endTime', 'next': 'next', 'limit': 'limit', }, 'location_map': { 'start_time': 'query', 'session_token': 'header', 'key_manager_token': 'header', 'end_time': 'query', 'next': 'query', 'limit': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v3_dlp_violations_message_get ) def __v3_dlp_violations_signal_get( self, start_time, session_token, key_manager_token, **kwargs ): """Get violations as a result of policy enforcement on signals. # noqa: E501 Retrieves DLP v3 signal related violations for a given time range # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v3_dlp_violations_signal_get(start_time, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: start_time (int): Timestamp of the first required violation. This is a long integer value representing milliseconds since Jan 1 1970 session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: end_time (int): Timestamp of the last required violation. This is a long integer value representing milliseconds since Jan 1 1970 If unspecified, it will default to current time of the request. . [optional] next (str): Offset of the next chunk of violations. Value is null for the first request. . [optional] limit (int): Max No. of violations to return. If no value is provided, 50 is the default. The maximum supported value is 500. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V3DLPViolationSignalResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['start_time'] = \ start_time kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v3_dlp_violations_signal_get = _Endpoint( settings={ 'response_type': (V3DLPViolationSignalResponse,), 'auth': [], 'endpoint_path': '/v3/dlp/violations/signal', 'operation_id': 'v3_dlp_violations_signal_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'start_time', 'session_token', 'key_manager_token', 'end_time', 'next', 'limit', ], 'required': [ 'start_time', 'session_token', 'key_manager_token', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'start_time': (int,), 'session_token': (str,), 'key_manager_token': (str,), 'end_time': (int,), 'next': (str,), 'limit': (int,), }, 'attribute_map': { 'start_time': 'startTime', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'end_time': 'endTime', 'next': 'next', 'limit': 'limit', }, 'location_map': { 'start_time': 'query', 'session_token': 'header', 'key_manager_token': 'header', 'end_time': 'query', 'next': 'query', 'limit': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v3_dlp_violations_signal_get ) def __v3_dlp_violations_stream_get( self, start_time, session_token, key_manager_token, **kwargs ): """Get violations as a result of policy enforcement on streams. # noqa: E501 Retrieves DLP v3 signal related violations for a given time range # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = agent_api.v3_dlp_violations_stream_get(start_time, session_token, key_manager_token, async_req=True) >>> result = thread.get() Args: start_time (int): Timestamp of the first required violation. This is a long integer value representing milliseconds since Jan 1 1970 session_token (str): Session authentication token. key_manager_token (str): Key Manager authentication token. Keyword Args: end_time (int): Timestamp of the last required violation. This is a long integer value representing milliseconds since Jan 1 1970 If unspecified, it will default to current time of the request. . [optional] next (str): Offset of the next chunk of violations. Value is null for the first request. . [optional] limit (int): Max No. of violations to return. If no value is provided, 50 is the default. The maximum supported value is 500. . [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 (float/tuple): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. Default is None. _check_input_type (bool): specifies if type checking should be done one the data sent to the server. Default is True. _check_return_type (bool): specifies if type checking should be done one the data received from the server. Default is True. _host_index (int/None): specifies the index of the server that we want to use. Default is read from the configuration. async_req (bool): execute request asynchronously Returns: V3DLPViolationStreamResponse If the method is called asynchronously, returns the request thread. """ kwargs['async_req'] = kwargs.get( 'async_req', False ) kwargs['_return_http_data_only'] = kwargs.get( '_return_http_data_only', True ) kwargs['_preload_content'] = kwargs.get( '_preload_content', True ) kwargs['_request_timeout'] = kwargs.get( '_request_timeout', None ) kwargs['_check_input_type'] = kwargs.get( '_check_input_type', True ) kwargs['_check_return_type'] = kwargs.get( '_check_return_type', True ) kwargs['_host_index'] = kwargs.get('_host_index') kwargs['start_time'] = \ start_time kwargs['session_token'] = \ session_token kwargs['key_manager_token'] = \ key_manager_token return self.call_with_http_info(**kwargs) self.v3_dlp_violations_stream_get = _Endpoint( settings={ 'response_type': (V3DLPViolationStreamResponse,), 'auth': [], 'endpoint_path': '/v3/dlp/violations/stream', 'operation_id': 'v3_dlp_violations_stream_get', 'http_method': 'GET', 'servers': None, }, params_map={ 'all': [ 'start_time', 'session_token', 'key_manager_token', 'end_time', 'next', 'limit', ], 'required': [ 'start_time', 'session_token', 'key_manager_token', ], 'nullable': [ ], 'enum': [ ], 'validation': [ ] }, root_map={ 'validations': { }, 'allowed_values': { }, 'openapi_types': { 'start_time': (int,), 'session_token': (str,), 'key_manager_token': (str,), 'end_time': (int,), 'next': (str,), 'limit': (int,), }, 'attribute_map': { 'start_time': 'startTime', 'session_token': 'sessionToken', 'key_manager_token': 'keyManagerToken', 'end_time': 'endTime', 'next': 'next', 'limit': 'limit', }, 'location_map': { 'start_time': 'query', 'session_token': 'header', 'key_manager_token': 'header', 'end_time': 'query', 'next': 'query', 'limit': 'query', }, 'collection_format_map': { } }, headers_map={ 'accept': [ 'application/json' ], 'content_type': [], }, api_client=api_client, callable=__v3_dlp_violations_stream_get )