# coding: utf-8 """ LINE Messaging API This document describes LINE Messaging API. # noqa: E501 The version of the OpenAPI document: 0.0.1 Generated by OpenAPI Generator (https://openapi-generator.tech) Do not edit the class manually. """ import re # noqa: F401 import io from pydantic.v1 import validate_arguments, ValidationError from typing_extensions import Annotated from pydantic.v1 import Field, StrictStr, conint, constr, validator from typing import Any, Dict, Optional from linebot.v3.messaging.models.audience_match_messages_request import AudienceMatchMessagesRequest from linebot.v3.messaging.models.bot_info_response import BotInfoResponse from linebot.v3.messaging.models.broadcast_request import BroadcastRequest from linebot.v3.messaging.models.create_rich_menu_alias_request import CreateRichMenuAliasRequest from linebot.v3.messaging.models.get_aggregation_unit_name_list_response import GetAggregationUnitNameListResponse from linebot.v3.messaging.models.get_aggregation_unit_usage_response import GetAggregationUnitUsageResponse from linebot.v3.messaging.models.get_followers_response import GetFollowersResponse from linebot.v3.messaging.models.get_membership_subscription_response import GetMembershipSubscriptionResponse from linebot.v3.messaging.models.get_webhook_endpoint_response import GetWebhookEndpointResponse from linebot.v3.messaging.models.group_member_count_response import GroupMemberCountResponse from linebot.v3.messaging.models.group_summary_response import GroupSummaryResponse from linebot.v3.messaging.models.group_user_profile_response import GroupUserProfileResponse from linebot.v3.messaging.models.issue_link_token_response import IssueLinkTokenResponse from linebot.v3.messaging.models.mark_messages_as_read_request import MarkMessagesAsReadRequest from linebot.v3.messaging.models.members_ids_response import MembersIdsResponse from linebot.v3.messaging.models.membership_list_response import MembershipListResponse from linebot.v3.messaging.models.message_quota_response import MessageQuotaResponse from linebot.v3.messaging.models.multicast_request import MulticastRequest from linebot.v3.messaging.models.narrowcast_progress_response import NarrowcastProgressResponse from linebot.v3.messaging.models.narrowcast_request import NarrowcastRequest from linebot.v3.messaging.models.number_of_messages_response import NumberOfMessagesResponse from linebot.v3.messaging.models.pnp_messages_request import PnpMessagesRequest from linebot.v3.messaging.models.push_message_request import PushMessageRequest from linebot.v3.messaging.models.push_message_response import PushMessageResponse from linebot.v3.messaging.models.quota_consumption_response import QuotaConsumptionResponse from linebot.v3.messaging.models.reply_message_request import ReplyMessageRequest from linebot.v3.messaging.models.reply_message_response import ReplyMessageResponse from linebot.v3.messaging.models.rich_menu_alias_list_response import RichMenuAliasListResponse from linebot.v3.messaging.models.rich_menu_alias_response import RichMenuAliasResponse from linebot.v3.messaging.models.rich_menu_batch_progress_response import RichMenuBatchProgressResponse from linebot.v3.messaging.models.rich_menu_batch_request import RichMenuBatchRequest from linebot.v3.messaging.models.rich_menu_bulk_link_request import RichMenuBulkLinkRequest from linebot.v3.messaging.models.rich_menu_bulk_unlink_request import RichMenuBulkUnlinkRequest from linebot.v3.messaging.models.rich_menu_id_response import RichMenuIdResponse from linebot.v3.messaging.models.rich_menu_list_response import RichMenuListResponse from linebot.v3.messaging.models.rich_menu_request import RichMenuRequest from linebot.v3.messaging.models.rich_menu_response import RichMenuResponse from linebot.v3.messaging.models.room_member_count_response import RoomMemberCountResponse from linebot.v3.messaging.models.room_user_profile_response import RoomUserProfileResponse from linebot.v3.messaging.models.set_webhook_endpoint_request import SetWebhookEndpointRequest from linebot.v3.messaging.models.show_loading_animation_request import ShowLoadingAnimationRequest from linebot.v3.messaging.models.test_webhook_endpoint_request import TestWebhookEndpointRequest from linebot.v3.messaging.models.test_webhook_endpoint_response import TestWebhookEndpointResponse from linebot.v3.messaging.models.update_rich_menu_alias_request import UpdateRichMenuAliasRequest from linebot.v3.messaging.models.user_profile_response import UserProfileResponse from linebot.v3.messaging.models.validate_message_request import ValidateMessageRequest from linebot.v3.messaging.api_client import ApiClient from linebot.v3.messaging.api_response import ApiResponse from linebot.v3.messaging.exceptions import ( # noqa: F401 ApiTypeError, ApiValueError ) class MessagingApi(object): """NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech Do not edit the class manually. """ def __init__(self, api_client=None): if api_client is None: api_client = ApiClient.get_default() self.api_client = api_client self.line_base_path = "https://api.line.me" @validate_arguments def audience_match(self, audience_match_messages_request : AudienceMatchMessagesRequest, **kwargs) -> None: # noqa: E501 """audience_match # noqa: E501 Send a message using phone number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.audience_match(audience_match_messages_request, async_req=True) >>> result = thread.get() :param audience_match_messages_request: (required) :type audience_match_messages_request: AudienceMatchMessagesRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the audience_match_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.audience_match_with_http_info(audience_match_messages_request, **kwargs) # noqa: E501 @validate_arguments def audience_match_with_http_info(self, audience_match_messages_request : AudienceMatchMessagesRequest, **kwargs) -> ApiResponse: # noqa: E501 """audience_match # noqa: E501 Send a message using phone number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.audience_match_with_http_info(audience_match_messages_request, async_req=True) >>> result = thread.get() :param audience_match_messages_request: (required) :type audience_match_messages_request: AudienceMatchMessagesRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'audience_match_messages_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method audience_match" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['audience_match_messages_request'] is not None: _body_params = _params['audience_match_messages_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/bot/ad/multicast/phone', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def broadcast(self, broadcast_request : BroadcastRequest, x_line_retry_key : Annotated[Optional[StrictStr], Field(description="Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. ")] = None, **kwargs) -> object: # noqa: E501 """broadcast # noqa: E501 Sends a message to multiple users at any time. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.broadcast(broadcast_request, x_line_retry_key, async_req=True) >>> result = thread.get() :param broadcast_request: (required) :type broadcast_request: BroadcastRequest :param x_line_retry_key: Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. :type x_line_retry_key: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: object """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the broadcast_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.broadcast_with_http_info(broadcast_request, x_line_retry_key, **kwargs) # noqa: E501 @validate_arguments def broadcast_with_http_info(self, broadcast_request : BroadcastRequest, x_line_retry_key : Annotated[Optional[StrictStr], Field(description="Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. ")] = None, **kwargs) -> ApiResponse: # noqa: E501 """broadcast # noqa: E501 Sends a message to multiple users at any time. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.broadcast_with_http_info(broadcast_request, x_line_retry_key, async_req=True) >>> result = thread.get() :param broadcast_request: (required) :type broadcast_request: BroadcastRequest :param x_line_retry_key: Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. :type x_line_retry_key: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'broadcast_request', 'x_line_retry_key' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method broadcast" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) if _params['x_line_retry_key']: _header_params['X-Line-Retry-Key'] = _params['x_line_retry_key'] # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['broadcast_request'] is not None: _body_params = _params['broadcast_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "object", '400': "ErrorResponse", '403': "ErrorResponse", '409': "ErrorResponse", '429': "ErrorResponse", } return self.api_client.call_api( '/v2/bot/message/broadcast', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def cancel_default_rich_menu(self, **kwargs) -> None: # noqa: E501 """cancel_default_rich_menu # noqa: E501 Cancel default rich menu # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.cancel_default_rich_menu(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the cancel_default_rich_menu_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.cancel_default_rich_menu_with_http_info(**kwargs) # noqa: E501 @validate_arguments def cancel_default_rich_menu_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """cancel_default_rich_menu # noqa: E501 Cancel default rich menu # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.cancel_default_rich_menu_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method cancel_default_rich_menu" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/user/all/richmenu', 'DELETE', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def create_rich_menu(self, rich_menu_request : RichMenuRequest, **kwargs) -> RichMenuIdResponse: # noqa: E501 """create_rich_menu # noqa: E501 Create rich menu # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_rich_menu(rich_menu_request, async_req=True) >>> result = thread.get() :param rich_menu_request: (required) :type rich_menu_request: RichMenuRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RichMenuIdResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the create_rich_menu_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.create_rich_menu_with_http_info(rich_menu_request, **kwargs) # noqa: E501 @validate_arguments def create_rich_menu_with_http_info(self, rich_menu_request : RichMenuRequest, **kwargs) -> ApiResponse: # noqa: E501 """create_rich_menu # noqa: E501 Create rich menu # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_rich_menu_with_http_info(rich_menu_request, async_req=True) >>> result = thread.get() :param rich_menu_request: (required) :type rich_menu_request: RichMenuRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RichMenuIdResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method create_rich_menu" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['rich_menu_request'] is not None: _body_params = _params['rich_menu_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RichMenuIdResponse", } return self.api_client.call_api( '/v2/bot/richmenu', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def create_rich_menu_alias(self, create_rich_menu_alias_request : CreateRichMenuAliasRequest, **kwargs) -> None: # noqa: E501 """create_rich_menu_alias # noqa: E501 Create rich menu alias # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_rich_menu_alias(create_rich_menu_alias_request, async_req=True) >>> result = thread.get() :param create_rich_menu_alias_request: (required) :type create_rich_menu_alias_request: CreateRichMenuAliasRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the create_rich_menu_alias_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.create_rich_menu_alias_with_http_info(create_rich_menu_alias_request, **kwargs) # noqa: E501 @validate_arguments def create_rich_menu_alias_with_http_info(self, create_rich_menu_alias_request : CreateRichMenuAliasRequest, **kwargs) -> ApiResponse: # noqa: E501 """create_rich_menu_alias # noqa: E501 Create rich menu alias # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_rich_menu_alias_with_http_info(create_rich_menu_alias_request, async_req=True) >>> result = thread.get() :param create_rich_menu_alias_request: (required) :type create_rich_menu_alias_request: CreateRichMenuAliasRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'create_rich_menu_alias_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method create_rich_menu_alias" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['create_rich_menu_alias_request'] is not None: _body_params = _params['create_rich_menu_alias_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/richmenu/alias', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def delete_rich_menu(self, rich_menu_id : Annotated[StrictStr, Field(..., description="ID of a rich menu")], **kwargs) -> None: # noqa: E501 """delete_rich_menu # noqa: E501 Deletes a rich menu. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_rich_menu(rich_menu_id, async_req=True) >>> result = thread.get() :param rich_menu_id: ID of a rich menu (required) :type rich_menu_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the delete_rich_menu_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.delete_rich_menu_with_http_info(rich_menu_id, **kwargs) # noqa: E501 @validate_arguments def delete_rich_menu_with_http_info(self, rich_menu_id : Annotated[StrictStr, Field(..., description="ID of a rich menu")], **kwargs) -> ApiResponse: # noqa: E501 """delete_rich_menu # noqa: E501 Deletes a rich menu. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_rich_menu_with_http_info(rich_menu_id, async_req=True) >>> result = thread.get() :param rich_menu_id: ID of a rich menu (required) :type rich_menu_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method delete_rich_menu" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['rich_menu_id']: _path_params['richMenuId'] = _params['rich_menu_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/richmenu/{richMenuId}', 'DELETE', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def delete_rich_menu_alias(self, rich_menu_alias_id : Annotated[StrictStr, Field(..., description="Rich menu alias ID that you want to delete.")], **kwargs) -> None: # noqa: E501 """delete_rich_menu_alias # noqa: E501 Delete rich menu alias # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_rich_menu_alias(rich_menu_alias_id, async_req=True) >>> result = thread.get() :param rich_menu_alias_id: Rich menu alias ID that you want to delete. (required) :type rich_menu_alias_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the delete_rich_menu_alias_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.delete_rich_menu_alias_with_http_info(rich_menu_alias_id, **kwargs) # noqa: E501 @validate_arguments def delete_rich_menu_alias_with_http_info(self, rich_menu_alias_id : Annotated[StrictStr, Field(..., description="Rich menu alias ID that you want to delete.")], **kwargs) -> ApiResponse: # noqa: E501 """delete_rich_menu_alias # noqa: E501 Delete rich menu alias # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_rich_menu_alias_with_http_info(rich_menu_alias_id, async_req=True) >>> result = thread.get() :param rich_menu_alias_id: Rich menu alias ID that you want to delete. (required) :type rich_menu_alias_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_alias_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method delete_rich_menu_alias" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['rich_menu_alias_id']: _path_params['richMenuAliasId'] = _params['rich_menu_alias_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/richmenu/alias/{richMenuAliasId}', 'DELETE', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_ad_phone_message_statistics(self, var_date : Annotated[StrictStr, Field(..., description="Date the message was sent Format: `yyyyMMdd` (e.g. `20190831`) Time Zone: UTC+9 ")], **kwargs) -> NumberOfMessagesResponse: # noqa: E501 """get_ad_phone_message_statistics # noqa: E501 Get result of message delivery using phone number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_ad_phone_message_statistics(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the message was sent Format: `yyyyMMdd` (e.g. `20190831`) Time Zone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: NumberOfMessagesResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_ad_phone_message_statistics_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_ad_phone_message_statistics_with_http_info(var_date, **kwargs) # noqa: E501 @validate_arguments def get_ad_phone_message_statistics_with_http_info(self, var_date : Annotated[StrictStr, Field(..., description="Date the message was sent Format: `yyyyMMdd` (e.g. `20190831`) Time Zone: UTC+9 ")], **kwargs) -> ApiResponse: # noqa: E501 """get_ad_phone_message_statistics # noqa: E501 Get result of message delivery using phone number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_ad_phone_message_statistics_with_http_info(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the message was sent Format: `yyyyMMdd` (e.g. `20190831`) Time Zone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(NumberOfMessagesResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'var_date' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_ad_phone_message_statistics" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('var_date') is not None: # noqa: E501 _query_params.append(('date', _params['var_date'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "NumberOfMessagesResponse", } return self.api_client.call_api( '/v2/bot/message/delivery/ad_phone', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_aggregation_unit_name_list(self, limit : Annotated[Optional[StrictStr], Field(description="The maximum number of aggregation units you can get per request. ")] = None, start : Annotated[Optional[StrictStr], Field(description="Value of the continuation token found in the next property of the JSON object returned in the response. If you can't get all the aggregation units in one request, include this parameter to get the remaining array. ")] = None, **kwargs) -> GetAggregationUnitNameListResponse: # noqa: E501 """get_aggregation_unit_name_list # noqa: E501 Get name list of units used this month # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_aggregation_unit_name_list(limit, start, async_req=True) >>> result = thread.get() :param limit: The maximum number of aggregation units you can get per request. :type limit: str :param start: Value of the continuation token found in the next property of the JSON object returned in the response. If you can't get all the aggregation units in one request, include this parameter to get the remaining array. :type start: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: GetAggregationUnitNameListResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_aggregation_unit_name_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_aggregation_unit_name_list_with_http_info(limit, start, **kwargs) # noqa: E501 @validate_arguments def get_aggregation_unit_name_list_with_http_info(self, limit : Annotated[Optional[StrictStr], Field(description="The maximum number of aggregation units you can get per request. ")] = None, start : Annotated[Optional[StrictStr], Field(description="Value of the continuation token found in the next property of the JSON object returned in the response. If you can't get all the aggregation units in one request, include this parameter to get the remaining array. ")] = None, **kwargs) -> ApiResponse: # noqa: E501 """get_aggregation_unit_name_list # noqa: E501 Get name list of units used this month # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_aggregation_unit_name_list_with_http_info(limit, start, async_req=True) >>> result = thread.get() :param limit: The maximum number of aggregation units you can get per request. :type limit: str :param start: Value of the continuation token found in the next property of the JSON object returned in the response. If you can't get all the aggregation units in one request, include this parameter to get the remaining array. :type start: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(GetAggregationUnitNameListResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'limit', 'start' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_aggregation_unit_name_list" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('limit') is not None: # noqa: E501 _query_params.append(('limit', _params['limit'])) if _params.get('start') is not None: # noqa: E501 _query_params.append(('start', _params['start'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "GetAggregationUnitNameListResponse", } return self.api_client.call_api( '/v2/bot/message/aggregation/list', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_aggregation_unit_usage(self, **kwargs) -> GetAggregationUnitUsageResponse: # noqa: E501 """get_aggregation_unit_usage # noqa: E501 Get number of units used this month # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_aggregation_unit_usage(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: GetAggregationUnitUsageResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_aggregation_unit_usage_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_aggregation_unit_usage_with_http_info(**kwargs) # noqa: E501 @validate_arguments def get_aggregation_unit_usage_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """get_aggregation_unit_usage # noqa: E501 Get number of units used this month # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_aggregation_unit_usage_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(GetAggregationUnitUsageResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_aggregation_unit_usage" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "GetAggregationUnitUsageResponse", } return self.api_client.call_api( '/v2/bot/message/aggregation/info', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_bot_info(self, **kwargs) -> BotInfoResponse: # noqa: E501 """get_bot_info # noqa: E501 Get bot info # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_bot_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: BotInfoResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_bot_info_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_bot_info_with_http_info(**kwargs) # noqa: E501 @validate_arguments def get_bot_info_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """get_bot_info # noqa: E501 Get bot info # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_bot_info_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(BotInfoResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_bot_info" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "BotInfoResponse", } return self.api_client.call_api( '/v2/bot/info', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_default_rich_menu_id(self, **kwargs) -> RichMenuIdResponse: # noqa: E501 """get_default_rich_menu_id # noqa: E501 Gets the ID of the default rich menu set with the Messaging API. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_default_rich_menu_id(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RichMenuIdResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_default_rich_menu_id_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_default_rich_menu_id_with_http_info(**kwargs) # noqa: E501 @validate_arguments def get_default_rich_menu_id_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """get_default_rich_menu_id # noqa: E501 Gets the ID of the default rich menu set with the Messaging API. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_default_rich_menu_id_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RichMenuIdResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_default_rich_menu_id" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RichMenuIdResponse", } return self.api_client.call_api( '/v2/bot/user/all/richmenu', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_followers(self, start : Annotated[Optional[StrictStr], Field(description="Value of the continuation token found in the next property of the JSON object returned in the response. Include this parameter to get the next array of user IDs. ")] = None, limit : Annotated[Optional[conint(strict=True, le=1000)], Field(description="The maximum number of user IDs to retrieve in a single request.")] = None, **kwargs) -> GetFollowersResponse: # noqa: E501 """get_followers # noqa: E501 Get a list of users who added your LINE Official Account as a friend # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_followers(start, limit, async_req=True) >>> result = thread.get() :param start: Value of the continuation token found in the next property of the JSON object returned in the response. Include this parameter to get the next array of user IDs. :type start: str :param limit: The maximum number of user IDs to retrieve in a single request. :type limit: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: GetFollowersResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_followers_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_followers_with_http_info(start, limit, **kwargs) # noqa: E501 @validate_arguments def get_followers_with_http_info(self, start : Annotated[Optional[StrictStr], Field(description="Value of the continuation token found in the next property of the JSON object returned in the response. Include this parameter to get the next array of user IDs. ")] = None, limit : Annotated[Optional[conint(strict=True, le=1000)], Field(description="The maximum number of user IDs to retrieve in a single request.")] = None, **kwargs) -> ApiResponse: # noqa: E501 """get_followers # noqa: E501 Get a list of users who added your LINE Official Account as a friend # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_followers_with_http_info(start, limit, async_req=True) >>> result = thread.get() :param start: Value of the continuation token found in the next property of the JSON object returned in the response. Include this parameter to get the next array of user IDs. :type start: str :param limit: The maximum number of user IDs to retrieve in a single request. :type limit: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(GetFollowersResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'start', 'limit' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_followers" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('start') is not None: # noqa: E501 _query_params.append(('start', _params['start'])) if _params.get('limit') is not None: # noqa: E501 _query_params.append(('limit', _params['limit'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "GetFollowersResponse", } return self.api_client.call_api( '/v2/bot/followers/ids', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_group_member_count(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], **kwargs) -> GroupMemberCountResponse: # noqa: E501 """get_group_member_count # noqa: E501 Get number of users in a group chat # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_member_count(group_id, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: GroupMemberCountResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_group_member_count_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_group_member_count_with_http_info(group_id, **kwargs) # noqa: E501 @validate_arguments def get_group_member_count_with_http_info(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], **kwargs) -> ApiResponse: # noqa: E501 """get_group_member_count # noqa: E501 Get number of users in a group chat # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_member_count_with_http_info(group_id, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(GroupMemberCountResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'group_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_group_member_count" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['group_id']: _path_params['groupId'] = _params['group_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "GroupMemberCountResponse", } return self.api_client.call_api( '/v2/bot/group/{groupId}/members/count', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_group_member_profile(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], user_id : Annotated[StrictStr, Field(..., description="User ID")], **kwargs) -> GroupUserProfileResponse: # noqa: E501 """get_group_member_profile # noqa: E501 Get group chat member profile # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_member_profile(group_id, user_id, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param user_id: User ID (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: GroupUserProfileResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_group_member_profile_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_group_member_profile_with_http_info(group_id, user_id, **kwargs) # noqa: E501 @validate_arguments def get_group_member_profile_with_http_info(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], user_id : Annotated[StrictStr, Field(..., description="User ID")], **kwargs) -> ApiResponse: # noqa: E501 """get_group_member_profile # noqa: E501 Get group chat member profile # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_member_profile_with_http_info(group_id, user_id, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param user_id: User ID (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(GroupUserProfileResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'group_id', 'user_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_group_member_profile" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['group_id']: _path_params['groupId'] = _params['group_id'] if _params['user_id']: _path_params['userId'] = _params['user_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "GroupUserProfileResponse", } return self.api_client.call_api( '/v2/bot/group/{groupId}/member/{userId}', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_group_members_ids(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], start : Annotated[Optional[StrictStr], Field(description="Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group. ")] = None, **kwargs) -> MembersIdsResponse: # noqa: E501 """get_group_members_ids # noqa: E501 Get group chat member user IDs # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_members_ids(group_id, start, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param start: Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group. :type start: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: MembersIdsResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_group_members_ids_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_group_members_ids_with_http_info(group_id, start, **kwargs) # noqa: E501 @validate_arguments def get_group_members_ids_with_http_info(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], start : Annotated[Optional[StrictStr], Field(description="Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group. ")] = None, **kwargs) -> ApiResponse: # noqa: E501 """get_group_members_ids # noqa: E501 Get group chat member user IDs # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_members_ids_with_http_info(group_id, start, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param start: Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group. :type start: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(MembersIdsResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'group_id', 'start' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_group_members_ids" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['group_id']: _path_params['groupId'] = _params['group_id'] # process the query parameters _query_params = [] if _params.get('start') is not None: # noqa: E501 _query_params.append(('start', _params['start'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "MembersIdsResponse", } return self.api_client.call_api( '/v2/bot/group/{groupId}/members/ids', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_group_summary(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], **kwargs) -> GroupSummaryResponse: # noqa: E501 """get_group_summary # noqa: E501 Get group chat summary # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_summary(group_id, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: GroupSummaryResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_group_summary_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_group_summary_with_http_info(group_id, **kwargs) # noqa: E501 @validate_arguments def get_group_summary_with_http_info(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], **kwargs) -> ApiResponse: # noqa: E501 """get_group_summary # noqa: E501 Get group chat summary # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_summary_with_http_info(group_id, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(GroupSummaryResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'group_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_group_summary" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['group_id']: _path_params['groupId'] = _params['group_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "GroupSummaryResponse", } return self.api_client.call_api( '/v2/bot/group/{groupId}/summary', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_membership_list(self, **kwargs) -> MembershipListResponse: # noqa: E501 """get_membership_list # noqa: E501 Get a list of memberships. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_membership_list(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: MembershipListResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_membership_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_membership_list_with_http_info(**kwargs) # noqa: E501 @validate_arguments def get_membership_list_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """get_membership_list # noqa: E501 Get a list of memberships. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_membership_list_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(MembershipListResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_membership_list" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "MembershipListResponse", '404': "ErrorResponse", } return self.api_client.call_api( '/v2/bot/membership/list', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_membership_subscription(self, user_id : Annotated[StrictStr, Field(..., description="User ID")], **kwargs) -> GetMembershipSubscriptionResponse: # noqa: E501 """get_membership_subscription # noqa: E501 Get a user's membership subscription. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_membership_subscription(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: GetMembershipSubscriptionResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_membership_subscription_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_membership_subscription_with_http_info(user_id, **kwargs) # noqa: E501 @validate_arguments def get_membership_subscription_with_http_info(self, user_id : Annotated[StrictStr, Field(..., description="User ID")], **kwargs) -> ApiResponse: # noqa: E501 """get_membership_subscription # noqa: E501 Get a user's membership subscription. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_membership_subscription_with_http_info(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(GetMembershipSubscriptionResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'user_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_membership_subscription" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['user_id']: _path_params['userId'] = _params['user_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "GetMembershipSubscriptionResponse", '400': "ErrorResponse", '404': "ErrorResponse", } return self.api_client.call_api( '/v2/bot/membership/subscription/{userId}', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_message_quota(self, **kwargs) -> MessageQuotaResponse: # noqa: E501 """get_message_quota # noqa: E501 Gets the target limit for sending messages in the current month. The total number of the free messages and the additional messages is returned. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_message_quota(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: MessageQuotaResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_message_quota_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_message_quota_with_http_info(**kwargs) # noqa: E501 @validate_arguments def get_message_quota_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """get_message_quota # noqa: E501 Gets the target limit for sending messages in the current month. The total number of the free messages and the additional messages is returned. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_message_quota_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(MessageQuotaResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_message_quota" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "MessageQuotaResponse", } return self.api_client.call_api( '/v2/bot/message/quota', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_message_quota_consumption(self, **kwargs) -> QuotaConsumptionResponse: # noqa: E501 """get_message_quota_consumption # noqa: E501 Gets the number of messages sent in the current month. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_message_quota_consumption(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: QuotaConsumptionResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_message_quota_consumption_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_message_quota_consumption_with_http_info(**kwargs) # noqa: E501 @validate_arguments def get_message_quota_consumption_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """get_message_quota_consumption # noqa: E501 Gets the number of messages sent in the current month. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_message_quota_consumption_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(QuotaConsumptionResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_message_quota_consumption" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "QuotaConsumptionResponse", } return self.api_client.call_api( '/v2/bot/message/quota/consumption', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_narrowcast_progress(self, request_id : Annotated[StrictStr, Field(..., description="The narrowcast message's request ID. Each Messaging API request has a request ID.")], **kwargs) -> NarrowcastProgressResponse: # noqa: E501 """get_narrowcast_progress # noqa: E501 Gets the status of a narrowcast message. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_narrowcast_progress(request_id, async_req=True) >>> result = thread.get() :param request_id: The narrowcast message's request ID. Each Messaging API request has a request ID. (required) :type request_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: NarrowcastProgressResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_narrowcast_progress_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_narrowcast_progress_with_http_info(request_id, **kwargs) # noqa: E501 @validate_arguments def get_narrowcast_progress_with_http_info(self, request_id : Annotated[StrictStr, Field(..., description="The narrowcast message's request ID. Each Messaging API request has a request ID.")], **kwargs) -> ApiResponse: # noqa: E501 """get_narrowcast_progress # noqa: E501 Gets the status of a narrowcast message. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_narrowcast_progress_with_http_info(request_id, async_req=True) >>> result = thread.get() :param request_id: The narrowcast message's request ID. Each Messaging API request has a request ID. (required) :type request_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(NarrowcastProgressResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'request_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_narrowcast_progress" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('request_id') is not None: # noqa: E501 _query_params.append(('requestId', _params['request_id'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "NarrowcastProgressResponse", } return self.api_client.call_api( '/v2/bot/message/progress/narrowcast', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_number_of_sent_broadcast_messages(self, var_date : Annotated[StrictStr, Field(..., description="Date the messages were sent Format: yyyyMMdd (e.g. 20191231) Timezone: UTC+9 ")], **kwargs) -> NumberOfMessagesResponse: # noqa: E501 """get_number_of_sent_broadcast_messages # noqa: E501 Get number of sent broadcast messages # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_number_of_sent_broadcast_messages(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the messages were sent Format: yyyyMMdd (e.g. 20191231) Timezone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: NumberOfMessagesResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_number_of_sent_broadcast_messages_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_number_of_sent_broadcast_messages_with_http_info(var_date, **kwargs) # noqa: E501 @validate_arguments def get_number_of_sent_broadcast_messages_with_http_info(self, var_date : Annotated[StrictStr, Field(..., description="Date the messages were sent Format: yyyyMMdd (e.g. 20191231) Timezone: UTC+9 ")], **kwargs) -> ApiResponse: # noqa: E501 """get_number_of_sent_broadcast_messages # noqa: E501 Get number of sent broadcast messages # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_number_of_sent_broadcast_messages_with_http_info(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the messages were sent Format: yyyyMMdd (e.g. 20191231) Timezone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(NumberOfMessagesResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'var_date' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_number_of_sent_broadcast_messages" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('var_date') is not None: # noqa: E501 _query_params.append(('date', _params['var_date'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "NumberOfMessagesResponse", } return self.api_client.call_api( '/v2/bot/message/delivery/broadcast', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_number_of_sent_multicast_messages(self, var_date : Annotated[StrictStr, Field(..., description="Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 ")], **kwargs) -> NumberOfMessagesResponse: # noqa: E501 """get_number_of_sent_multicast_messages # noqa: E501 Get number of sent multicast messages # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_number_of_sent_multicast_messages(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: NumberOfMessagesResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_number_of_sent_multicast_messages_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_number_of_sent_multicast_messages_with_http_info(var_date, **kwargs) # noqa: E501 @validate_arguments def get_number_of_sent_multicast_messages_with_http_info(self, var_date : Annotated[StrictStr, Field(..., description="Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 ")], **kwargs) -> ApiResponse: # noqa: E501 """get_number_of_sent_multicast_messages # noqa: E501 Get number of sent multicast messages # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_number_of_sent_multicast_messages_with_http_info(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(NumberOfMessagesResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'var_date' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_number_of_sent_multicast_messages" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('var_date') is not None: # noqa: E501 _query_params.append(('date', _params['var_date'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "NumberOfMessagesResponse", } return self.api_client.call_api( '/v2/bot/message/delivery/multicast', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_number_of_sent_push_messages(self, var_date : Annotated[StrictStr, Field(..., description="Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 ")], **kwargs) -> NumberOfMessagesResponse: # noqa: E501 """get_number_of_sent_push_messages # noqa: E501 Get number of sent push messages # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_number_of_sent_push_messages(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: NumberOfMessagesResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_number_of_sent_push_messages_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_number_of_sent_push_messages_with_http_info(var_date, **kwargs) # noqa: E501 @validate_arguments def get_number_of_sent_push_messages_with_http_info(self, var_date : Annotated[StrictStr, Field(..., description="Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 ")], **kwargs) -> ApiResponse: # noqa: E501 """get_number_of_sent_push_messages # noqa: E501 Get number of sent push messages # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_number_of_sent_push_messages_with_http_info(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(NumberOfMessagesResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'var_date' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_number_of_sent_push_messages" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('var_date') is not None: # noqa: E501 _query_params.append(('date', _params['var_date'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "NumberOfMessagesResponse", } return self.api_client.call_api( '/v2/bot/message/delivery/push', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_number_of_sent_reply_messages(self, var_date : Annotated[StrictStr, Field(..., description="Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 ")], **kwargs) -> NumberOfMessagesResponse: # noqa: E501 """get_number_of_sent_reply_messages # noqa: E501 Get number of sent reply messages # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_number_of_sent_reply_messages(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: NumberOfMessagesResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_number_of_sent_reply_messages_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_number_of_sent_reply_messages_with_http_info(var_date, **kwargs) # noqa: E501 @validate_arguments def get_number_of_sent_reply_messages_with_http_info(self, var_date : Annotated[StrictStr, Field(..., description="Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 ")], **kwargs) -> ApiResponse: # noqa: E501 """get_number_of_sent_reply_messages # noqa: E501 Get number of sent reply messages # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_number_of_sent_reply_messages_with_http_info(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the messages were sent Format: `yyyyMMdd` (e.g. `20191231`) Timezone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(NumberOfMessagesResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'var_date' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_number_of_sent_reply_messages" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('var_date') is not None: # noqa: E501 _query_params.append(('date', _params['var_date'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "NumberOfMessagesResponse", } return self.api_client.call_api( '/v2/bot/message/delivery/reply', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_pnp_message_statistics(self, var_date : Annotated[constr(strict=True), Field(..., description="Date the message was sent Format: `yyyyMMdd` (Example:`20211231`) Time zone: UTC+9 ")], **kwargs) -> NumberOfMessagesResponse: # noqa: E501 """get_pnp_message_statistics # noqa: E501 Get number of sent LINE notification messages　 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_pnp_message_statistics(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the message was sent Format: `yyyyMMdd` (Example:`20211231`) Time zone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: NumberOfMessagesResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_pnp_message_statistics_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_pnp_message_statistics_with_http_info(var_date, **kwargs) # noqa: E501 @validate_arguments def get_pnp_message_statistics_with_http_info(self, var_date : Annotated[constr(strict=True), Field(..., description="Date the message was sent Format: `yyyyMMdd` (Example:`20211231`) Time zone: UTC+9 ")], **kwargs) -> ApiResponse: # noqa: E501 """get_pnp_message_statistics # noqa: E501 Get number of sent LINE notification messages　 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_pnp_message_statistics_with_http_info(var_date, async_req=True) >>> result = thread.get() :param var_date: Date the message was sent Format: `yyyyMMdd` (Example:`20211231`) Time zone: UTC+9 (required) :type var_date: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(NumberOfMessagesResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'var_date' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_pnp_message_statistics" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('var_date') is not None: # noqa: E501 _query_params.append(('date', _params['var_date'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "NumberOfMessagesResponse", } return self.api_client.call_api( '/v2/bot/message/delivery/pnp', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_profile(self, user_id : Annotated[StrictStr, Field(..., description="User ID")], **kwargs) -> UserProfileResponse: # noqa: E501 """get_profile # noqa: E501 Get profile # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_profile(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: UserProfileResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_profile_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_profile_with_http_info(user_id, **kwargs) # noqa: E501 @validate_arguments def get_profile_with_http_info(self, user_id : Annotated[StrictStr, Field(..., description="User ID")], **kwargs) -> ApiResponse: # noqa: E501 """get_profile # noqa: E501 Get profile # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_profile_with_http_info(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(UserProfileResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'user_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_profile" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['user_id']: _path_params['userId'] = _params['user_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "UserProfileResponse", } return self.api_client.call_api( '/v2/bot/profile/{userId}', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_rich_menu(self, rich_menu_id : Annotated[StrictStr, Field(..., description="ID of a rich menu")], **kwargs) -> RichMenuResponse: # noqa: E501 """get_rich_menu # noqa: E501 Gets a rich menu via a rich menu ID. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu(rich_menu_id, async_req=True) >>> result = thread.get() :param rich_menu_id: ID of a rich menu (required) :type rich_menu_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RichMenuResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_rich_menu_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_rich_menu_with_http_info(rich_menu_id, **kwargs) # noqa: E501 @validate_arguments def get_rich_menu_with_http_info(self, rich_menu_id : Annotated[StrictStr, Field(..., description="ID of a rich menu")], **kwargs) -> ApiResponse: # noqa: E501 """get_rich_menu # noqa: E501 Gets a rich menu via a rich menu ID. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_with_http_info(rich_menu_id, async_req=True) >>> result = thread.get() :param rich_menu_id: ID of a rich menu (required) :type rich_menu_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RichMenuResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_rich_menu" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['rich_menu_id']: _path_params['richMenuId'] = _params['rich_menu_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RichMenuResponse", } return self.api_client.call_api( '/v2/bot/richmenu/{richMenuId}', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_rich_menu_alias(self, rich_menu_alias_id : Annotated[StrictStr, Field(..., description="The rich menu alias ID whose information you want to obtain.")], **kwargs) -> RichMenuAliasResponse: # noqa: E501 """get_rich_menu_alias # noqa: E501 Get rich menu alias information # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_alias(rich_menu_alias_id, async_req=True) >>> result = thread.get() :param rich_menu_alias_id: The rich menu alias ID whose information you want to obtain. (required) :type rich_menu_alias_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RichMenuAliasResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_rich_menu_alias_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_rich_menu_alias_with_http_info(rich_menu_alias_id, **kwargs) # noqa: E501 @validate_arguments def get_rich_menu_alias_with_http_info(self, rich_menu_alias_id : Annotated[StrictStr, Field(..., description="The rich menu alias ID whose information you want to obtain.")], **kwargs) -> ApiResponse: # noqa: E501 """get_rich_menu_alias # noqa: E501 Get rich menu alias information # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_alias_with_http_info(rich_menu_alias_id, async_req=True) >>> result = thread.get() :param rich_menu_alias_id: The rich menu alias ID whose information you want to obtain. (required) :type rich_menu_alias_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RichMenuAliasResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_alias_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_rich_menu_alias" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['rich_menu_alias_id']: _path_params['richMenuAliasId'] = _params['rich_menu_alias_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RichMenuAliasResponse", } return self.api_client.call_api( '/v2/bot/richmenu/alias/{richMenuAliasId}', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_rich_menu_alias_list(self, **kwargs) -> RichMenuAliasListResponse: # noqa: E501 """get_rich_menu_alias_list # noqa: E501 Get list of rich menu alias # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_alias_list(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RichMenuAliasListResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_rich_menu_alias_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_rich_menu_alias_list_with_http_info(**kwargs) # noqa: E501 @validate_arguments def get_rich_menu_alias_list_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """get_rich_menu_alias_list # noqa: E501 Get list of rich menu alias # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_alias_list_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RichMenuAliasListResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_rich_menu_alias_list" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RichMenuAliasListResponse", } return self.api_client.call_api( '/v2/bot/richmenu/alias/list', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_rich_menu_batch_progress(self, request_id : Annotated[StrictStr, Field(..., description="A request ID used to batch control the rich menu linked to the user. Each Messaging API request has a request ID.")], **kwargs) -> RichMenuBatchProgressResponse: # noqa: E501 """get_rich_menu_batch_progress # noqa: E501 Get the status of Replace or unlink a linked rich menus in batches. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_batch_progress(request_id, async_req=True) >>> result = thread.get() :param request_id: A request ID used to batch control the rich menu linked to the user. Each Messaging API request has a request ID. (required) :type request_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RichMenuBatchProgressResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_rich_menu_batch_progress_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_rich_menu_batch_progress_with_http_info(request_id, **kwargs) # noqa: E501 @validate_arguments def get_rich_menu_batch_progress_with_http_info(self, request_id : Annotated[StrictStr, Field(..., description="A request ID used to batch control the rich menu linked to the user. Each Messaging API request has a request ID.")], **kwargs) -> ApiResponse: # noqa: E501 """get_rich_menu_batch_progress # noqa: E501 Get the status of Replace or unlink a linked rich menus in batches. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_batch_progress_with_http_info(request_id, async_req=True) >>> result = thread.get() :param request_id: A request ID used to batch control the rich menu linked to the user. Each Messaging API request has a request ID. (required) :type request_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RichMenuBatchProgressResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'request_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_rich_menu_batch_progress" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] if _params.get('request_id') is not None: # noqa: E501 _query_params.append(('requestId', _params['request_id'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RichMenuBatchProgressResponse", } return self.api_client.call_api( '/v2/bot/richmenu/progress/batch', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_rich_menu_id_of_user(self, user_id : Annotated[StrictStr, Field(..., description="User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE.")], **kwargs) -> RichMenuIdResponse: # noqa: E501 """get_rich_menu_id_of_user # noqa: E501 Get rich menu ID of user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_id_of_user(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE. (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RichMenuIdResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_rich_menu_id_of_user_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_rich_menu_id_of_user_with_http_info(user_id, **kwargs) # noqa: E501 @validate_arguments def get_rich_menu_id_of_user_with_http_info(self, user_id : Annotated[StrictStr, Field(..., description="User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE.")], **kwargs) -> ApiResponse: # noqa: E501 """get_rich_menu_id_of_user # noqa: E501 Get rich menu ID of user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_id_of_user_with_http_info(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE. (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RichMenuIdResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'user_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_rich_menu_id_of_user" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['user_id']: _path_params['userId'] = _params['user_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RichMenuIdResponse", } return self.api_client.call_api( '/v2/bot/user/{userId}/richmenu', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_rich_menu_list(self, **kwargs) -> RichMenuListResponse: # noqa: E501 """get_rich_menu_list # noqa: E501 Get rich menu list # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_list(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RichMenuListResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_rich_menu_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_rich_menu_list_with_http_info(**kwargs) # noqa: E501 @validate_arguments def get_rich_menu_list_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """get_rich_menu_list # noqa: E501 Get rich menu list # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rich_menu_list_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RichMenuListResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_rich_menu_list" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RichMenuListResponse", } return self.api_client.call_api( '/v2/bot/richmenu/list', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_room_member_count(self, room_id : Annotated[StrictStr, Field(..., description="Room ID")], **kwargs) -> RoomMemberCountResponse: # noqa: E501 """get_room_member_count # noqa: E501 Get number of users in a multi-person chat # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_room_member_count(room_id, async_req=True) >>> result = thread.get() :param room_id: Room ID (required) :type room_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RoomMemberCountResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_room_member_count_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_room_member_count_with_http_info(room_id, **kwargs) # noqa: E501 @validate_arguments def get_room_member_count_with_http_info(self, room_id : Annotated[StrictStr, Field(..., description="Room ID")], **kwargs) -> ApiResponse: # noqa: E501 """get_room_member_count # noqa: E501 Get number of users in a multi-person chat # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_room_member_count_with_http_info(room_id, async_req=True) >>> result = thread.get() :param room_id: Room ID (required) :type room_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RoomMemberCountResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'room_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_room_member_count" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['room_id']: _path_params['roomId'] = _params['room_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RoomMemberCountResponse", } return self.api_client.call_api( '/v2/bot/room/{roomId}/members/count', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_room_member_profile(self, room_id : Annotated[StrictStr, Field(..., description="Room ID")], user_id : Annotated[StrictStr, Field(..., description="User ID")], **kwargs) -> RoomUserProfileResponse: # noqa: E501 """get_room_member_profile # noqa: E501 Get multi-person chat member profile # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_room_member_profile(room_id, user_id, async_req=True) >>> result = thread.get() :param room_id: Room ID (required) :type room_id: str :param user_id: User ID (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: RoomUserProfileResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_room_member_profile_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_room_member_profile_with_http_info(room_id, user_id, **kwargs) # noqa: E501 @validate_arguments def get_room_member_profile_with_http_info(self, room_id : Annotated[StrictStr, Field(..., description="Room ID")], user_id : Annotated[StrictStr, Field(..., description="User ID")], **kwargs) -> ApiResponse: # noqa: E501 """get_room_member_profile # noqa: E501 Get multi-person chat member profile # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_room_member_profile_with_http_info(room_id, user_id, async_req=True) >>> result = thread.get() :param room_id: Room ID (required) :type room_id: str :param user_id: User ID (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(RoomUserProfileResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'room_id', 'user_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_room_member_profile" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['room_id']: _path_params['roomId'] = _params['room_id'] if _params['user_id']: _path_params['userId'] = _params['user_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "RoomUserProfileResponse", } return self.api_client.call_api( '/v2/bot/room/{roomId}/member/{userId}', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_room_members_ids(self, room_id : Annotated[StrictStr, Field(..., description="Room ID")], start : Annotated[Optional[StrictStr], Field(description="Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group. ")] = None, **kwargs) -> MembersIdsResponse: # noqa: E501 """get_room_members_ids # noqa: E501 Get multi-person chat member user IDs # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_room_members_ids(room_id, start, async_req=True) >>> result = thread.get() :param room_id: Room ID (required) :type room_id: str :param start: Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group. :type start: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: MembersIdsResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_room_members_ids_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_room_members_ids_with_http_info(room_id, start, **kwargs) # noqa: E501 @validate_arguments def get_room_members_ids_with_http_info(self, room_id : Annotated[StrictStr, Field(..., description="Room ID")], start : Annotated[Optional[StrictStr], Field(description="Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group. ")] = None, **kwargs) -> ApiResponse: # noqa: E501 """get_room_members_ids # noqa: E501 Get multi-person chat member user IDs # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_room_members_ids_with_http_info(room_id, start, async_req=True) >>> result = thread.get() :param room_id: Room ID (required) :type room_id: str :param start: Value of the continuation token found in the `next` property of the JSON object returned in the response. Include this parameter to get the next array of user IDs for the members of the group. :type start: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(MembersIdsResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'room_id', 'start' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_room_members_ids" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['room_id']: _path_params['roomId'] = _params['room_id'] # process the query parameters _query_params = [] if _params.get('start') is not None: # noqa: E501 _query_params.append(('start', _params['start'])) # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "MembersIdsResponse", } return self.api_client.call_api( '/v2/bot/room/{roomId}/members/ids', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def get_webhook_endpoint(self, **kwargs) -> GetWebhookEndpointResponse: # noqa: E501 """get_webhook_endpoint # noqa: E501 Get webhook endpoint information # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_webhook_endpoint(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: GetWebhookEndpointResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the get_webhook_endpoint_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.get_webhook_endpoint_with_http_info(**kwargs) # noqa: E501 @validate_arguments def get_webhook_endpoint_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501 """get_webhook_endpoint # noqa: E501 Get webhook endpoint information # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_webhook_endpoint_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(GetWebhookEndpointResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method get_webhook_endpoint" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "GetWebhookEndpointResponse", } return self.api_client.call_api( '/v2/bot/channel/webhook/endpoint', 'GET', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def issue_link_token(self, user_id : Annotated[StrictStr, Field(..., description="User ID for the LINE account to be linked. Found in the `source` object of account link event objects. Do not use the LINE ID used in LINE. ")], **kwargs) -> IssueLinkTokenResponse: # noqa: E501 """issue_link_token # noqa: E501 Issue link token # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.issue_link_token(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID for the LINE account to be linked. Found in the `source` object of account link event objects. Do not use the LINE ID used in LINE. (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: IssueLinkTokenResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the issue_link_token_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.issue_link_token_with_http_info(user_id, **kwargs) # noqa: E501 @validate_arguments def issue_link_token_with_http_info(self, user_id : Annotated[StrictStr, Field(..., description="User ID for the LINE account to be linked. Found in the `source` object of account link event objects. Do not use the LINE ID used in LINE. ")], **kwargs) -> ApiResponse: # noqa: E501 """issue_link_token # noqa: E501 Issue link token # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.issue_link_token_with_http_info(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID for the LINE account to be linked. Found in the `source` object of account link event objects. Do not use the LINE ID used in LINE. (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(IssueLinkTokenResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'user_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method issue_link_token" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['user_id']: _path_params['userId'] = _params['user_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "IssueLinkTokenResponse", } return self.api_client.call_api( '/v2/bot/user/{userId}/linkToken', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def leave_group(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], **kwargs) -> None: # noqa: E501 """leave_group # noqa: E501 Leave group chat # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.leave_group(group_id, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the leave_group_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.leave_group_with_http_info(group_id, **kwargs) # noqa: E501 @validate_arguments def leave_group_with_http_info(self, group_id : Annotated[StrictStr, Field(..., description="Group ID")], **kwargs) -> ApiResponse: # noqa: E501 """leave_group # noqa: E501 Leave group chat # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.leave_group_with_http_info(group_id, async_req=True) >>> result = thread.get() :param group_id: Group ID (required) :type group_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'group_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method leave_group" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['group_id']: _path_params['groupId'] = _params['group_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/group/{groupId}/leave', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def leave_room(self, room_id : Annotated[StrictStr, Field(..., description="Room ID")], **kwargs) -> None: # noqa: E501 """leave_room # noqa: E501 Leave multi-person chat # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.leave_room(room_id, async_req=True) >>> result = thread.get() :param room_id: Room ID (required) :type room_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the leave_room_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.leave_room_with_http_info(room_id, **kwargs) # noqa: E501 @validate_arguments def leave_room_with_http_info(self, room_id : Annotated[StrictStr, Field(..., description="Room ID")], **kwargs) -> ApiResponse: # noqa: E501 """leave_room # noqa: E501 Leave multi-person chat # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.leave_room_with_http_info(room_id, async_req=True) >>> result = thread.get() :param room_id: Room ID (required) :type room_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'room_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method leave_room" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['room_id']: _path_params['roomId'] = _params['room_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/room/{roomId}/leave', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def link_rich_menu_id_to_user(self, user_id : Annotated[StrictStr, Field(..., description="User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE.")], rich_menu_id : Annotated[StrictStr, Field(..., description="ID of a rich menu")], **kwargs) -> None: # noqa: E501 """link_rich_menu_id_to_user # noqa: E501 Link rich menu to user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.link_rich_menu_id_to_user(user_id, rich_menu_id, async_req=True) >>> result = thread.get() :param user_id: User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE. (required) :type user_id: str :param rich_menu_id: ID of a rich menu (required) :type rich_menu_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the link_rich_menu_id_to_user_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.link_rich_menu_id_to_user_with_http_info(user_id, rich_menu_id, **kwargs) # noqa: E501 @validate_arguments def link_rich_menu_id_to_user_with_http_info(self, user_id : Annotated[StrictStr, Field(..., description="User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE.")], rich_menu_id : Annotated[StrictStr, Field(..., description="ID of a rich menu")], **kwargs) -> ApiResponse: # noqa: E501 """link_rich_menu_id_to_user # noqa: E501 Link rich menu to user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.link_rich_menu_id_to_user_with_http_info(user_id, rich_menu_id, async_req=True) >>> result = thread.get() :param user_id: User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE. (required) :type user_id: str :param rich_menu_id: ID of a rich menu (required) :type rich_menu_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'user_id', 'rich_menu_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method link_rich_menu_id_to_user" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['user_id']: _path_params['userId'] = _params['user_id'] if _params['rich_menu_id']: _path_params['richMenuId'] = _params['rich_menu_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/user/{userId}/richmenu/{richMenuId}', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def link_rich_menu_id_to_users(self, rich_menu_bulk_link_request : RichMenuBulkLinkRequest, **kwargs) -> None: # noqa: E501 """link_rich_menu_id_to_users # noqa: E501 Link rich menu to multiple users # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.link_rich_menu_id_to_users(rich_menu_bulk_link_request, async_req=True) >>> result = thread.get() :param rich_menu_bulk_link_request: (required) :type rich_menu_bulk_link_request: RichMenuBulkLinkRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the link_rich_menu_id_to_users_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.link_rich_menu_id_to_users_with_http_info(rich_menu_bulk_link_request, **kwargs) # noqa: E501 @validate_arguments def link_rich_menu_id_to_users_with_http_info(self, rich_menu_bulk_link_request : RichMenuBulkLinkRequest, **kwargs) -> ApiResponse: # noqa: E501 """link_rich_menu_id_to_users # noqa: E501 Link rich menu to multiple users # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.link_rich_menu_id_to_users_with_http_info(rich_menu_bulk_link_request, async_req=True) >>> result = thread.get() :param rich_menu_bulk_link_request: (required) :type rich_menu_bulk_link_request: RichMenuBulkLinkRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_bulk_link_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method link_rich_menu_id_to_users" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['rich_menu_bulk_link_request'] is not None: _body_params = _params['rich_menu_bulk_link_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/richmenu/bulk/link', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def mark_messages_as_read(self, mark_messages_as_read_request : MarkMessagesAsReadRequest, **kwargs) -> None: # noqa: E501 """mark_messages_as_read # noqa: E501 Mark messages from users as read # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.mark_messages_as_read(mark_messages_as_read_request, async_req=True) >>> result = thread.get() :param mark_messages_as_read_request: (required) :type mark_messages_as_read_request: MarkMessagesAsReadRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the mark_messages_as_read_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.mark_messages_as_read_with_http_info(mark_messages_as_read_request, **kwargs) # noqa: E501 @validate_arguments def mark_messages_as_read_with_http_info(self, mark_messages_as_read_request : MarkMessagesAsReadRequest, **kwargs) -> ApiResponse: # noqa: E501 """mark_messages_as_read # noqa: E501 Mark messages from users as read # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.mark_messages_as_read_with_http_info(mark_messages_as_read_request, async_req=True) >>> result = thread.get() :param mark_messages_as_read_request: (required) :type mark_messages_as_read_request: MarkMessagesAsReadRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'mark_messages_as_read_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method mark_messages_as_read" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['mark_messages_as_read_request'] is not None: _body_params = _params['mark_messages_as_read_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/message/markAsRead', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def multicast(self, multicast_request : MulticastRequest, x_line_retry_key : Annotated[Optional[StrictStr], Field(description="Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. ")] = None, **kwargs) -> object: # noqa: E501 """multicast # noqa: E501 An API that efficiently sends the same message to multiple user IDs. You can't send messages to group chats or multi-person chats. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.multicast(multicast_request, x_line_retry_key, async_req=True) >>> result = thread.get() :param multicast_request: (required) :type multicast_request: MulticastRequest :param x_line_retry_key: Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. :type x_line_retry_key: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: object """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the multicast_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.multicast_with_http_info(multicast_request, x_line_retry_key, **kwargs) # noqa: E501 @validate_arguments def multicast_with_http_info(self, multicast_request : MulticastRequest, x_line_retry_key : Annotated[Optional[StrictStr], Field(description="Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. ")] = None, **kwargs) -> ApiResponse: # noqa: E501 """multicast # noqa: E501 An API that efficiently sends the same message to multiple user IDs. You can't send messages to group chats or multi-person chats. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.multicast_with_http_info(multicast_request, x_line_retry_key, async_req=True) >>> result = thread.get() :param multicast_request: (required) :type multicast_request: MulticastRequest :param x_line_retry_key: Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. :type x_line_retry_key: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'multicast_request', 'x_line_retry_key' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method multicast" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) if _params['x_line_retry_key']: _header_params['X-Line-Retry-Key'] = _params['x_line_retry_key'] # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['multicast_request'] is not None: _body_params = _params['multicast_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "object", '400': "ErrorResponse", '403': "ErrorResponse", '409': "ErrorResponse", '429': "ErrorResponse", } return self.api_client.call_api( '/v2/bot/message/multicast', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def narrowcast(self, narrowcast_request : NarrowcastRequest, x_line_retry_key : Annotated[Optional[StrictStr], Field(description="Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. ")] = None, **kwargs) -> object: # noqa: E501 """narrowcast # noqa: E501 Send narrowcast message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.narrowcast(narrowcast_request, x_line_retry_key, async_req=True) >>> result = thread.get() :param narrowcast_request: (required) :type narrowcast_request: NarrowcastRequest :param x_line_retry_key: Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. :type x_line_retry_key: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: object """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the narrowcast_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.narrowcast_with_http_info(narrowcast_request, x_line_retry_key, **kwargs) # noqa: E501 @validate_arguments def narrowcast_with_http_info(self, narrowcast_request : NarrowcastRequest, x_line_retry_key : Annotated[Optional[StrictStr], Field(description="Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. ")] = None, **kwargs) -> ApiResponse: # noqa: E501 """narrowcast # noqa: E501 Send narrowcast message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.narrowcast_with_http_info(narrowcast_request, x_line_retry_key, async_req=True) >>> result = thread.get() :param narrowcast_request: (required) :type narrowcast_request: NarrowcastRequest :param x_line_retry_key: Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. :type x_line_retry_key: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'narrowcast_request', 'x_line_retry_key' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method narrowcast" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) if _params['x_line_retry_key']: _header_params['X-Line-Retry-Key'] = _params['x_line_retry_key'] # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['narrowcast_request'] is not None: _body_params = _params['narrowcast_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '202': "object", '400': "ErrorResponse", '403': "ErrorResponse", '409': "ErrorResponse", '429': "ErrorResponse", } return self.api_client.call_api( '/v2/bot/message/narrowcast', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def push_message(self, push_message_request : PushMessageRequest, x_line_retry_key : Annotated[Optional[StrictStr], Field(description="Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. ")] = None, **kwargs) -> PushMessageResponse: # noqa: E501 """push_message # noqa: E501 Sends a message to a user, group chat, or multi-person chat at any time. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.push_message(push_message_request, x_line_retry_key, async_req=True) >>> result = thread.get() :param push_message_request: (required) :type push_message_request: PushMessageRequest :param x_line_retry_key: Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. :type x_line_retry_key: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: PushMessageResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the push_message_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.push_message_with_http_info(push_message_request, x_line_retry_key, **kwargs) # noqa: E501 @validate_arguments def push_message_with_http_info(self, push_message_request : PushMessageRequest, x_line_retry_key : Annotated[Optional[StrictStr], Field(description="Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. ")] = None, **kwargs) -> ApiResponse: # noqa: E501 """push_message # noqa: E501 Sends a message to a user, group chat, or multi-person chat at any time. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.push_message_with_http_info(push_message_request, x_line_retry_key, async_req=True) >>> result = thread.get() :param push_message_request: (required) :type push_message_request: PushMessageRequest :param x_line_retry_key: Retry key. Specifies the UUID in hexadecimal format (e.g., `123e4567-e89b-12d3-a456-426614174000`) generated by any method. The retry key isn't generated by LINE. Each developer must generate their own retry key. :type x_line_retry_key: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(PushMessageResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'push_message_request', 'x_line_retry_key' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method push_message" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) if _params['x_line_retry_key']: _header_params['X-Line-Retry-Key'] = _params['x_line_retry_key'] # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['push_message_request'] is not None: _body_params = _params['push_message_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "PushMessageResponse", '400': "ErrorResponse", '403': "ErrorResponse", '409': "ErrorResponse", '429': "ErrorResponse", } return self.api_client.call_api( '/v2/bot/message/push', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def push_messages_by_phone(self, pnp_messages_request : PnpMessagesRequest, x_line_delivery_tag : Annotated[Optional[constr(strict=True, max_length=100, min_length=16)], Field(description="String returned in the delivery.data property of the delivery completion event via Webhook.")] = None, **kwargs) -> None: # noqa: E501 """push_messages_by_phone # noqa: E501 Send LINE notification message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.push_messages_by_phone(pnp_messages_request, x_line_delivery_tag, async_req=True) >>> result = thread.get() :param pnp_messages_request: (required) :type pnp_messages_request: PnpMessagesRequest :param x_line_delivery_tag: String returned in the delivery.data property of the delivery completion event via Webhook. :type x_line_delivery_tag: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the push_messages_by_phone_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.push_messages_by_phone_with_http_info(pnp_messages_request, x_line_delivery_tag, **kwargs) # noqa: E501 @validate_arguments def push_messages_by_phone_with_http_info(self, pnp_messages_request : PnpMessagesRequest, x_line_delivery_tag : Annotated[Optional[constr(strict=True, max_length=100, min_length=16)], Field(description="String returned in the delivery.data property of the delivery completion event via Webhook.")] = None, **kwargs) -> ApiResponse: # noqa: E501 """push_messages_by_phone # noqa: E501 Send LINE notification message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.push_messages_by_phone_with_http_info(pnp_messages_request, x_line_delivery_tag, async_req=True) >>> result = thread.get() :param pnp_messages_request: (required) :type pnp_messages_request: PnpMessagesRequest :param x_line_delivery_tag: String returned in the delivery.data property of the delivery completion event via Webhook. :type x_line_delivery_tag: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'pnp_messages_request', 'x_line_delivery_tag' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method push_messages_by_phone" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) if _params['x_line_delivery_tag']: _header_params['X-Line-Delivery-Tag'] = _params['x_line_delivery_tag'] # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['pnp_messages_request'] is not None: _body_params = _params['pnp_messages_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/bot/pnp/push', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def reply_message(self, reply_message_request : ReplyMessageRequest, **kwargs) -> ReplyMessageResponse: # noqa: E501 """reply_message # noqa: E501 Send reply message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.reply_message(reply_message_request, async_req=True) >>> result = thread.get() :param reply_message_request: (required) :type reply_message_request: ReplyMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: ReplyMessageResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the reply_message_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.reply_message_with_http_info(reply_message_request, **kwargs) # noqa: E501 @validate_arguments def reply_message_with_http_info(self, reply_message_request : ReplyMessageRequest, **kwargs) -> ApiResponse: # noqa: E501 """reply_message # noqa: E501 Send reply message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.reply_message_with_http_info(reply_message_request, async_req=True) >>> result = thread.get() :param reply_message_request: (required) :type reply_message_request: ReplyMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(ReplyMessageResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'reply_message_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method reply_message" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['reply_message_request'] is not None: _body_params = _params['reply_message_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "ReplyMessageResponse", '400': "ErrorResponse", '429': "ErrorResponse", } return self.api_client.call_api( '/v2/bot/message/reply', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def rich_menu_batch(self, rich_menu_batch_request : RichMenuBatchRequest, **kwargs) -> None: # noqa: E501 """rich_menu_batch # noqa: E501 You can use this endpoint to batch control the rich menu linked to the users using the endpoint such as Link rich menu to user. The following operations are available: 1. Replace a rich menu with another rich menu for all users linked to a specific rich menu 2. Unlink a rich menu for all users linked to a specific rich menu 3. Unlink a rich menu for all users linked the rich menu # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.rich_menu_batch(rich_menu_batch_request, async_req=True) >>> result = thread.get() :param rich_menu_batch_request: (required) :type rich_menu_batch_request: RichMenuBatchRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the rich_menu_batch_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.rich_menu_batch_with_http_info(rich_menu_batch_request, **kwargs) # noqa: E501 @validate_arguments def rich_menu_batch_with_http_info(self, rich_menu_batch_request : RichMenuBatchRequest, **kwargs) -> ApiResponse: # noqa: E501 """rich_menu_batch # noqa: E501 You can use this endpoint to batch control the rich menu linked to the users using the endpoint such as Link rich menu to user. The following operations are available: 1. Replace a rich menu with another rich menu for all users linked to a specific rich menu 2. Unlink a rich menu for all users linked to a specific rich menu 3. Unlink a rich menu for all users linked the rich menu # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.rich_menu_batch_with_http_info(rich_menu_batch_request, async_req=True) >>> result = thread.get() :param rich_menu_batch_request: (required) :type rich_menu_batch_request: RichMenuBatchRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_batch_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method rich_menu_batch" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['rich_menu_batch_request'] is not None: _body_params = _params['rich_menu_batch_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/richmenu/batch', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def set_default_rich_menu(self, rich_menu_id : Annotated[StrictStr, Field(..., description="ID of a rich menu")], **kwargs) -> None: # noqa: E501 """set_default_rich_menu # noqa: E501 Set default rich menu # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_default_rich_menu(rich_menu_id, async_req=True) >>> result = thread.get() :param rich_menu_id: ID of a rich menu (required) :type rich_menu_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the set_default_rich_menu_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.set_default_rich_menu_with_http_info(rich_menu_id, **kwargs) # noqa: E501 @validate_arguments def set_default_rich_menu_with_http_info(self, rich_menu_id : Annotated[StrictStr, Field(..., description="ID of a rich menu")], **kwargs) -> ApiResponse: # noqa: E501 """set_default_rich_menu # noqa: E501 Set default rich menu # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_default_rich_menu_with_http_info(rich_menu_id, async_req=True) >>> result = thread.get() :param rich_menu_id: ID of a rich menu (required) :type rich_menu_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method set_default_rich_menu" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['rich_menu_id']: _path_params['richMenuId'] = _params['rich_menu_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/user/all/richmenu/{richMenuId}', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def set_webhook_endpoint(self, set_webhook_endpoint_request : SetWebhookEndpointRequest, **kwargs) -> None: # noqa: E501 """set_webhook_endpoint # noqa: E501 Set webhook endpoint URL # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_webhook_endpoint(set_webhook_endpoint_request, async_req=True) >>> result = thread.get() :param set_webhook_endpoint_request: (required) :type set_webhook_endpoint_request: SetWebhookEndpointRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the set_webhook_endpoint_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.set_webhook_endpoint_with_http_info(set_webhook_endpoint_request, **kwargs) # noqa: E501 @validate_arguments def set_webhook_endpoint_with_http_info(self, set_webhook_endpoint_request : SetWebhookEndpointRequest, **kwargs) -> ApiResponse: # noqa: E501 """set_webhook_endpoint # noqa: E501 Set webhook endpoint URL # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_webhook_endpoint_with_http_info(set_webhook_endpoint_request, async_req=True) >>> result = thread.get() :param set_webhook_endpoint_request: (required) :type set_webhook_endpoint_request: SetWebhookEndpointRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'set_webhook_endpoint_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method set_webhook_endpoint" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['set_webhook_endpoint_request'] is not None: _body_params = _params['set_webhook_endpoint_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/channel/webhook/endpoint', 'PUT', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def show_loading_animation(self, show_loading_animation_request : ShowLoadingAnimationRequest, **kwargs) -> object: # noqa: E501 """show_loading_animation # noqa: E501 Display a loading animation in one-on-one chats between users and LINE Official Accounts. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.show_loading_animation(show_loading_animation_request, async_req=True) >>> result = thread.get() :param show_loading_animation_request: (required) :type show_loading_animation_request: ShowLoadingAnimationRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: object """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the show_loading_animation_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.show_loading_animation_with_http_info(show_loading_animation_request, **kwargs) # noqa: E501 @validate_arguments def show_loading_animation_with_http_info(self, show_loading_animation_request : ShowLoadingAnimationRequest, **kwargs) -> ApiResponse: # noqa: E501 """show_loading_animation # noqa: E501 Display a loading animation in one-on-one chats between users and LINE Official Accounts. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.show_loading_animation_with_http_info(show_loading_animation_request, async_req=True) >>> result = thread.get() :param show_loading_animation_request: (required) :type show_loading_animation_request: ShowLoadingAnimationRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'show_loading_animation_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method show_loading_animation" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['show_loading_animation_request'] is not None: _body_params = _params['show_loading_animation_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '202': "object", '400': "ErrorResponse", } return self.api_client.call_api( '/v2/bot/chat/loading/start', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def test_webhook_endpoint(self, test_webhook_endpoint_request : Optional[TestWebhookEndpointRequest] = None, **kwargs) -> TestWebhookEndpointResponse: # noqa: E501 """test_webhook_endpoint # noqa: E501 Test webhook endpoint # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.test_webhook_endpoint(test_webhook_endpoint_request, async_req=True) >>> result = thread.get() :param test_webhook_endpoint_request: :type test_webhook_endpoint_request: TestWebhookEndpointRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: TestWebhookEndpointResponse """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the test_webhook_endpoint_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.test_webhook_endpoint_with_http_info(test_webhook_endpoint_request, **kwargs) # noqa: E501 @validate_arguments def test_webhook_endpoint_with_http_info(self, test_webhook_endpoint_request : Optional[TestWebhookEndpointRequest] = None, **kwargs) -> ApiResponse: # noqa: E501 """test_webhook_endpoint # noqa: E501 Test webhook endpoint # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.test_webhook_endpoint_with_http_info(test_webhook_endpoint_request, async_req=True) >>> result = thread.get() :param test_webhook_endpoint_request: :type test_webhook_endpoint_request: TestWebhookEndpointRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(TestWebhookEndpointResponse, status_code(int), headers(HTTPHeaderDict)) """ _host = self.line_base_path _params = locals() _all_params = [ 'test_webhook_endpoint_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method test_webhook_endpoint" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['test_webhook_endpoint_request'] is not None: _body_params = _params['test_webhook_endpoint_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = { '200': "TestWebhookEndpointResponse", } return self.api_client.call_api( '/v2/bot/channel/webhook/test', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def unlink_rich_menu_id_from_user(self, user_id : Annotated[StrictStr, Field(..., description="User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE.")], **kwargs) -> None: # noqa: E501 """unlink_rich_menu_id_from_user # noqa: E501 Unlink rich menu from user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.unlink_rich_menu_id_from_user(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE. (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the unlink_rich_menu_id_from_user_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.unlink_rich_menu_id_from_user_with_http_info(user_id, **kwargs) # noqa: E501 @validate_arguments def unlink_rich_menu_id_from_user_with_http_info(self, user_id : Annotated[StrictStr, Field(..., description="User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE.")], **kwargs) -> ApiResponse: # noqa: E501 """unlink_rich_menu_id_from_user # noqa: E501 Unlink rich menu from user # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.unlink_rich_menu_id_from_user_with_http_info(user_id, async_req=True) >>> result = thread.get() :param user_id: User ID. Found in the `source` object of webhook event objects. Do not use the LINE ID used in LINE. (required) :type user_id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'user_id' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method unlink_rich_menu_id_from_user" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['user_id']: _path_params['userId'] = _params['user_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/user/{userId}/richmenu', 'DELETE', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def unlink_rich_menu_id_from_users(self, rich_menu_bulk_unlink_request : RichMenuBulkUnlinkRequest, **kwargs) -> None: # noqa: E501 """unlink_rich_menu_id_from_users # noqa: E501 Unlink rich menus from multiple users # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.unlink_rich_menu_id_from_users(rich_menu_bulk_unlink_request, async_req=True) >>> result = thread.get() :param rich_menu_bulk_unlink_request: (required) :type rich_menu_bulk_unlink_request: RichMenuBulkUnlinkRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the unlink_rich_menu_id_from_users_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.unlink_rich_menu_id_from_users_with_http_info(rich_menu_bulk_unlink_request, **kwargs) # noqa: E501 @validate_arguments def unlink_rich_menu_id_from_users_with_http_info(self, rich_menu_bulk_unlink_request : RichMenuBulkUnlinkRequest, **kwargs) -> ApiResponse: # noqa: E501 """unlink_rich_menu_id_from_users # noqa: E501 Unlink rich menus from multiple users # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.unlink_rich_menu_id_from_users_with_http_info(rich_menu_bulk_unlink_request, async_req=True) >>> result = thread.get() :param rich_menu_bulk_unlink_request: (required) :type rich_menu_bulk_unlink_request: RichMenuBulkUnlinkRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_bulk_unlink_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method unlink_rich_menu_id_from_users" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['rich_menu_bulk_unlink_request'] is not None: _body_params = _params['rich_menu_bulk_unlink_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/richmenu/bulk/unlink', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def update_rich_menu_alias(self, rich_menu_alias_id : Annotated[StrictStr, Field(..., description="The rich menu alias ID you want to update.")], update_rich_menu_alias_request : UpdateRichMenuAliasRequest, **kwargs) -> None: # noqa: E501 """update_rich_menu_alias # noqa: E501 Update rich menu alias # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_rich_menu_alias(rich_menu_alias_id, update_rich_menu_alias_request, async_req=True) >>> result = thread.get() :param rich_menu_alias_id: The rich menu alias ID you want to update. (required) :type rich_menu_alias_id: str :param update_rich_menu_alias_request: (required) :type update_rich_menu_alias_request: UpdateRichMenuAliasRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the update_rich_menu_alias_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.update_rich_menu_alias_with_http_info(rich_menu_alias_id, update_rich_menu_alias_request, **kwargs) # noqa: E501 @validate_arguments def update_rich_menu_alias_with_http_info(self, rich_menu_alias_id : Annotated[StrictStr, Field(..., description="The rich menu alias ID you want to update.")], update_rich_menu_alias_request : UpdateRichMenuAliasRequest, **kwargs) -> ApiResponse: # noqa: E501 """update_rich_menu_alias # noqa: E501 Update rich menu alias # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_rich_menu_alias_with_http_info(rich_menu_alias_id, update_rich_menu_alias_request, async_req=True) >>> result = thread.get() :param rich_menu_alias_id: The rich menu alias ID you want to update. (required) :type rich_menu_alias_id: str :param update_rich_menu_alias_request: (required) :type update_rich_menu_alias_request: UpdateRichMenuAliasRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_alias_id', 'update_rich_menu_alias_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method update_rich_menu_alias" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} if _params['rich_menu_alias_id']: _path_params['richMenuAliasId'] = _params['rich_menu_alias_id'] # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['update_rich_menu_alias_request'] is not None: _body_params = _params['update_rich_menu_alias_request'] # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/richmenu/alias/{richMenuAliasId}', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def validate_broadcast(self, validate_message_request : ValidateMessageRequest, **kwargs) -> None: # noqa: E501 """validate_broadcast # noqa: E501 Validate message objects of a broadcast message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_broadcast(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the validate_broadcast_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.validate_broadcast_with_http_info(validate_message_request, **kwargs) # noqa: E501 @validate_arguments def validate_broadcast_with_http_info(self, validate_message_request : ValidateMessageRequest, **kwargs) -> ApiResponse: # noqa: E501 """validate_broadcast # noqa: E501 Validate message objects of a broadcast message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_broadcast_with_http_info(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'validate_message_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method validate_broadcast" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['validate_message_request'] is not None: _body_params = _params['validate_message_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/message/validate/broadcast', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def validate_multicast(self, validate_message_request : ValidateMessageRequest, **kwargs) -> None: # noqa: E501 """validate_multicast # noqa: E501 Validate message objects of a multicast message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_multicast(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the validate_multicast_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.validate_multicast_with_http_info(validate_message_request, **kwargs) # noqa: E501 @validate_arguments def validate_multicast_with_http_info(self, validate_message_request : ValidateMessageRequest, **kwargs) -> ApiResponse: # noqa: E501 """validate_multicast # noqa: E501 Validate message objects of a multicast message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_multicast_with_http_info(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'validate_message_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method validate_multicast" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['validate_message_request'] is not None: _body_params = _params['validate_message_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/message/validate/multicast', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def validate_narrowcast(self, validate_message_request : ValidateMessageRequest, **kwargs) -> None: # noqa: E501 """validate_narrowcast # noqa: E501 Validate message objects of a narrowcast message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_narrowcast(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the validate_narrowcast_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.validate_narrowcast_with_http_info(validate_message_request, **kwargs) # noqa: E501 @validate_arguments def validate_narrowcast_with_http_info(self, validate_message_request : ValidateMessageRequest, **kwargs) -> ApiResponse: # noqa: E501 """validate_narrowcast # noqa: E501 Validate message objects of a narrowcast message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_narrowcast_with_http_info(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'validate_message_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method validate_narrowcast" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['validate_message_request'] is not None: _body_params = _params['validate_message_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/message/validate/narrowcast', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def validate_push(self, validate_message_request : ValidateMessageRequest, **kwargs) -> None: # noqa: E501 """validate_push # noqa: E501 Validate message objects of a push message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_push(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the validate_push_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.validate_push_with_http_info(validate_message_request, **kwargs) # noqa: E501 @validate_arguments def validate_push_with_http_info(self, validate_message_request : ValidateMessageRequest, **kwargs) -> ApiResponse: # noqa: E501 """validate_push # noqa: E501 Validate message objects of a push message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_push_with_http_info(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'validate_message_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method validate_push" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['validate_message_request'] is not None: _body_params = _params['validate_message_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/message/validate/push', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def validate_reply(self, validate_message_request : ValidateMessageRequest, **kwargs) -> None: # noqa: E501 """validate_reply # noqa: E501 Validate message objects of a reply message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_reply(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the validate_reply_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.validate_reply_with_http_info(validate_message_request, **kwargs) # noqa: E501 @validate_arguments def validate_reply_with_http_info(self, validate_message_request : ValidateMessageRequest, **kwargs) -> ApiResponse: # noqa: E501 """validate_reply # noqa: E501 Validate message objects of a reply message # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_reply_with_http_info(validate_message_request, async_req=True) >>> result = thread.get() :param validate_message_request: (required) :type validate_message_request: ValidateMessageRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'validate_message_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method validate_reply" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['validate_message_request'] is not None: _body_params = _params['validate_message_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/message/validate/reply', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def validate_rich_menu_batch_request(self, rich_menu_batch_request : RichMenuBatchRequest, **kwargs) -> None: # noqa: E501 """validate_rich_menu_batch_request # noqa: E501 Validate a request body of the Replace or unlink the linked rich menus in batches endpoint. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_rich_menu_batch_request(rich_menu_batch_request, async_req=True) >>> result = thread.get() :param rich_menu_batch_request: (required) :type rich_menu_batch_request: RichMenuBatchRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the validate_rich_menu_batch_request_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.validate_rich_menu_batch_request_with_http_info(rich_menu_batch_request, **kwargs) # noqa: E501 @validate_arguments def validate_rich_menu_batch_request_with_http_info(self, rich_menu_batch_request : RichMenuBatchRequest, **kwargs) -> ApiResponse: # noqa: E501 """validate_rich_menu_batch_request # noqa: E501 Validate a request body of the Replace or unlink the linked rich menus in batches endpoint. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_rich_menu_batch_request_with_http_info(rich_menu_batch_request, async_req=True) >>> result = thread.get() :param rich_menu_batch_request: (required) :type rich_menu_batch_request: RichMenuBatchRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_batch_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method validate_rich_menu_batch_request" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['rich_menu_batch_request'] is not None: _body_params = _params['rich_menu_batch_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/richmenu/validate/batch', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth')) @validate_arguments def validate_rich_menu_object(self, rich_menu_request : RichMenuRequest, **kwargs) -> None: # noqa: E501 """validate_rich_menu_object # noqa: E501 Validate rich menu object # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_rich_menu_object(rich_menu_request, async_req=True) >>> result = thread.get() :param rich_menu_request: (required) :type rich_menu_request: RichMenuRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _request_timeout: 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. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ kwargs['_return_http_data_only'] = True if '_preload_content' in kwargs: raise ValueError("Error! Please call the validate_rich_menu_object_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data") return self.validate_rich_menu_object_with_http_info(rich_menu_request, **kwargs) # noqa: E501 @validate_arguments def validate_rich_menu_object_with_http_info(self, rich_menu_request : RichMenuRequest, **kwargs) -> ApiResponse: # noqa: E501 """validate_rich_menu_object # noqa: E501 Validate rich menu object # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.validate_rich_menu_object_with_http_info(rich_menu_request, async_req=True) >>> result = thread.get() :param rich_menu_request: (required) :type rich_menu_request: RichMenuRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the ApiResponse.data will be set to none and raw_data will store the HTTP response body without reading/decoding. Default is True. :type _preload_content: bool, optional :param _return_http_data_only: response data instead of ApiResponse object with status code, headers, etc :type _return_http_data_only: bool, optional :param _request_timeout: 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. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None """ _host = self.line_base_path _params = locals() _all_params = [ 'rich_menu_request' ] _all_params.extend( [ 'async_req', '_return_http_data_only', '_preload_content', '_request_timeout', '_request_auth', '_content_type', '_headers' ] ) # validate the arguments for _key, _val in _params['kwargs'].items(): if _key not in _all_params: raise ApiTypeError( "Got an unexpected keyword argument '%s'" " to method validate_rich_menu_object" % _key ) _params[_key] = _val del _params['kwargs'] _collection_formats = {} # process the path parameters _path_params = {} # process the query parameters _query_params = [] # process the header parameters _header_params = dict(_params.get('_headers', {})) # process the form parameters _form_params = [] _files = {} # process the body parameter _body_params = None if _params['rich_menu_request'] is not None: _body_params = _params['rich_menu_request'] # set the HTTP header `Content-Type` _content_types_list = _params.get('_content_type', self.api_client.select_header_content_type( ['application/json'])) if _content_types_list: _header_params['Content-Type'] = _content_types_list # authentication setting _auth_settings = ['Bearer'] # noqa: E501 _response_types_map = {} return self.api_client.call_api( '/v2/bot/richmenu/validate', 'POST', _path_params, _query_params, _header_params, body=_body_params, post_params=_form_params, files=_files, response_types_map=_response_types_map, auth_settings=_auth_settings, async_req=_params.get('async_req'), _return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501 _preload_content=_params.get('_preload_content', True), _request_timeout=_params.get('_request_timeout'), _host=_host, collection_formats=_collection_formats, _request_auth=_params.get('_request_auth'))