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_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 __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_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 __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 __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_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 __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 __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_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 __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 __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 __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
)
