/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace ChimeSDKMessaging { /** *

The Amazon Chime SDK messaging APIs in this section allow software developers * to send and receive messages in custom messaging applications. These APIs depend * on the frameworks provided by the Amazon Chime SDK identity APIs. For more * information about the messaging APIs, see Amazon * Chime SDK messaging.

*/ class AWS_CHIMESDKMESSAGING_API ChimeSDKMessagingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef ChimeSDKMessagingClientConfiguration ClientConfigurationType; typedef ChimeSDKMessagingEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ChimeSDKMessagingClient(const Aws::ChimeSDKMessaging::ChimeSDKMessagingClientConfiguration& clientConfiguration = Aws::ChimeSDKMessaging::ChimeSDKMessagingClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ChimeSDKMessagingClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::ChimeSDKMessaging::ChimeSDKMessagingClientConfiguration& clientConfiguration = Aws::ChimeSDKMessaging::ChimeSDKMessagingClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ChimeSDKMessagingClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::ChimeSDKMessaging::ChimeSDKMessagingClientConfiguration& clientConfiguration = Aws::ChimeSDKMessaging::ChimeSDKMessagingClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ChimeSDKMessagingClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ ChimeSDKMessagingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ ChimeSDKMessagingClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~ChimeSDKMessagingClient(); /** *

Associates a channel flow with a channel. Once associated, all messages to * that channel go through channel flow processors. To stop processing, use the * DisassociateChannelFlow API.

Only administrators or * channel moderators can associate a channel flow. The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::AssociateChannelFlowOutcome AssociateChannelFlow(const Model::AssociateChannelFlowRequest& request) const; /** * A Callable wrapper for AssociateChannelFlow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateChannelFlowOutcomeCallable AssociateChannelFlowCallable(const AssociateChannelFlowRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::AssociateChannelFlow, request); } /** * An Async wrapper for AssociateChannelFlow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateChannelFlowAsync(const AssociateChannelFlowRequestT& request, const AssociateChannelFlowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::AssociateChannelFlow, request, handler, context); } /** *

Adds a specified number of users and bots to a channel.

See * Also:

AWS * API Reference

*/ virtual Model::BatchCreateChannelMembershipOutcome BatchCreateChannelMembership(const Model::BatchCreateChannelMembershipRequest& request) const; /** * A Callable wrapper for BatchCreateChannelMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchCreateChannelMembershipOutcomeCallable BatchCreateChannelMembershipCallable(const BatchCreateChannelMembershipRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::BatchCreateChannelMembership, request); } /** * An Async wrapper for BatchCreateChannelMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchCreateChannelMembershipAsync(const BatchCreateChannelMembershipRequestT& request, const BatchCreateChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::BatchCreateChannelMembership, request, handler, context); } /** *

Calls back Amazon Chime SDK messaging with a processing response message. * This should be invoked from the processor Lambda. This is a developer API.

*

You can return one of the following processing responses:

  • *

    Update message content or metadata

  • Deny a message

    • *

  • Make no changes to the message

See Also:

AWS * API Reference

*/ virtual Model::ChannelFlowCallbackOutcome ChannelFlowCallback(const Model::ChannelFlowCallbackRequest& request) const; /** * A Callable wrapper for ChannelFlowCallback that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ChannelFlowCallbackOutcomeCallable ChannelFlowCallbackCallable(const ChannelFlowCallbackRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ChannelFlowCallback, request); } /** * An Async wrapper for ChannelFlowCallback that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ChannelFlowCallbackAsync(const ChannelFlowCallbackRequestT& request, const ChannelFlowCallbackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ChannelFlowCallback, request, handler, context); } /** *

Creates a channel to which you can add users and send messages.

* Restriction: You can't change a channel's privacy.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::CreateChannelOutcome CreateChannel(const Model::CreateChannelRequest& request) const; /** * A Callable wrapper for CreateChannel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateChannelOutcomeCallable CreateChannelCallable(const CreateChannelRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::CreateChannel, request); } /** * An Async wrapper for CreateChannel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateChannelAsync(const CreateChannelRequestT& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::CreateChannel, request, handler, context); } /** *

Permanently bans a member from a channel. Moderators can't add banned members * to a channel. To undo a ban, you first have to DeleteChannelBan, * and then CreateChannelMembership. Bans are cleaned up when you * delete users or channels.

If you ban a user who is already part of a * channel, that user is automatically kicked from the channel.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::CreateChannelBanOutcome CreateChannelBan(const Model::CreateChannelBanRequest& request) const; /** * A Callable wrapper for CreateChannelBan that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateChannelBanOutcomeCallable CreateChannelBanCallable(const CreateChannelBanRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::CreateChannelBan, request); } /** * An Async wrapper for CreateChannelBan that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateChannelBanAsync(const CreateChannelBanRequestT& request, const CreateChannelBanResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::CreateChannelBan, request, handler, context); } /** *

Creates a channel flow, a container for processors. Processors are AWS Lambda * functions that perform actions on chat messages, such as stripping out * profanity. You can associate channel flows with channels, and the processors in * the channel flow then take action on all messages sent to that channel. This is * a developer API.

Channel flows process the following items:

  1. *

    New and updated messages

  2. Persistent and non-persistent * messages

  3. The Standard message type

*

Channel flows don't process Control or System messages. For more information * about the message types provided by Chime SDK messaging, refer to Message * types in the Amazon Chime developer guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateChannelFlowOutcome CreateChannelFlow(const Model::CreateChannelFlowRequest& request) const; /** * A Callable wrapper for CreateChannelFlow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateChannelFlowOutcomeCallable CreateChannelFlowCallable(const CreateChannelFlowRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::CreateChannelFlow, request); } /** * An Async wrapper for CreateChannelFlow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateChannelFlowAsync(const CreateChannelFlowRequestT& request, const CreateChannelFlowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::CreateChannelFlow, request, handler, context); } /** *

Adds a member to a channel. The InvitedBy field in * ChannelMembership is derived from the request header. A channel * member can:

  • List messages

  • Send messages

    *

  • Receive messages

  • Edit their own messages

    *

  • Leave the channel

Privacy settings impact this * action as follows:

  • Public Channels: You do not need to be a * member to list messages, but you must be a member to send messages.

    • *

  • Private Channels: You must be a member to list or send messages.

    *

The x-amz-chime-bearer request header is * mandatory. Use the ARN of the AppInstanceUserArn or * AppInstanceBot that makes the API call as the value in the * header.

See Also:

AWS * API Reference

*/ virtual Model::CreateChannelMembershipOutcome CreateChannelMembership(const Model::CreateChannelMembershipRequest& request) const; /** * A Callable wrapper for CreateChannelMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateChannelMembershipOutcomeCallable CreateChannelMembershipCallable(const CreateChannelMembershipRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::CreateChannelMembership, request); } /** * An Async wrapper for CreateChannelMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateChannelMembershipAsync(const CreateChannelMembershipRequestT& request, const CreateChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::CreateChannelMembership, request, handler, context); } /** *

Creates a new ChannelModerator. A channel moderator can:

*

  • Add and remove other members of the channel.

  • Add * and remove other moderators of the channel.

  • Add and remove * user bans for the channel.

  • Redact messages in the channel.

    *

  • List messages in the channel.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBotof the user that * makes the API call as the value in the header.

See Also:

* AWS * API Reference

*/ virtual Model::CreateChannelModeratorOutcome CreateChannelModerator(const Model::CreateChannelModeratorRequest& request) const; /** * A Callable wrapper for CreateChannelModerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateChannelModeratorOutcomeCallable CreateChannelModeratorCallable(const CreateChannelModeratorRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::CreateChannelModerator, request); } /** * An Async wrapper for CreateChannelModerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateChannelModeratorAsync(const CreateChannelModeratorRequestT& request, const CreateChannelModeratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::CreateChannelModerator, request, handler, context); } /** *

Immediately makes a channel and its memberships inaccessible and marks them * for deletion. This is an irreversible process.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUserArn or AppInstanceBot that makes the * API call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::DeleteChannelOutcome DeleteChannel(const Model::DeleteChannelRequest& request) const; /** * A Callable wrapper for DeleteChannel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteChannelOutcomeCallable DeleteChannelCallable(const DeleteChannelRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DeleteChannel, request); } /** * An Async wrapper for DeleteChannel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteChannelAsync(const DeleteChannelRequestT& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DeleteChannel, request, handler, context); } /** *

Removes a member from a channel's ban list.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::DeleteChannelBanOutcome DeleteChannelBan(const Model::DeleteChannelBanRequest& request) const; /** * A Callable wrapper for DeleteChannelBan that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteChannelBanOutcomeCallable DeleteChannelBanCallable(const DeleteChannelBanRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DeleteChannelBan, request); } /** * An Async wrapper for DeleteChannelBan that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteChannelBanAsync(const DeleteChannelBanRequestT& request, const DeleteChannelBanResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DeleteChannelBan, request, handler, context); } /** *

Deletes a channel flow, an irreversible process. This is a developer API.

*

This API works only when the channel flow is not associated with any * channel. To get a list of all channels that a channel flow is associated with, * use the ListChannelsAssociatedWithChannelFlow API. Use the * DisassociateChannelFlow API to disassociate a channel flow from all * channels.

See Also:

AWS * API Reference

*/ virtual Model::DeleteChannelFlowOutcome DeleteChannelFlow(const Model::DeleteChannelFlowRequest& request) const; /** * A Callable wrapper for DeleteChannelFlow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteChannelFlowOutcomeCallable DeleteChannelFlowCallable(const DeleteChannelFlowRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DeleteChannelFlow, request); } /** * An Async wrapper for DeleteChannelFlow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteChannelFlowAsync(const DeleteChannelFlowRequestT& request, const DeleteChannelFlowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DeleteChannelFlow, request, handler, context); } /** *

Removes a member from a channel.

The * x-amz-chime-bearer request header is mandatory. Use the * AppInstanceUserArn of the user that makes the API call as the value * in the header.

See Also:

AWS * API Reference

*/ virtual Model::DeleteChannelMembershipOutcome DeleteChannelMembership(const Model::DeleteChannelMembershipRequest& request) const; /** * A Callable wrapper for DeleteChannelMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteChannelMembershipOutcomeCallable DeleteChannelMembershipCallable(const DeleteChannelMembershipRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DeleteChannelMembership, request); } /** * An Async wrapper for DeleteChannelMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteChannelMembershipAsync(const DeleteChannelMembershipRequestT& request, const DeleteChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DeleteChannelMembership, request, handler, context); } /** *

Deletes a channel message. Only admins can perform this action. Deletion * makes messages inaccessible immediately. A background process deletes any * revisions created by UpdateChannelMessage.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::DeleteChannelMessageOutcome DeleteChannelMessage(const Model::DeleteChannelMessageRequest& request) const; /** * A Callable wrapper for DeleteChannelMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteChannelMessageOutcomeCallable DeleteChannelMessageCallable(const DeleteChannelMessageRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DeleteChannelMessage, request); } /** * An Async wrapper for DeleteChannelMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteChannelMessageAsync(const DeleteChannelMessageRequestT& request, const DeleteChannelMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DeleteChannelMessage, request, handler, context); } /** *

Deletes a channel moderator.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::DeleteChannelModeratorOutcome DeleteChannelModerator(const Model::DeleteChannelModeratorRequest& request) const; /** * A Callable wrapper for DeleteChannelModerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteChannelModeratorOutcomeCallable DeleteChannelModeratorCallable(const DeleteChannelModeratorRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DeleteChannelModerator, request); } /** * An Async wrapper for DeleteChannelModerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteChannelModeratorAsync(const DeleteChannelModeratorRequestT& request, const DeleteChannelModeratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DeleteChannelModerator, request, handler, context); } /** *

Deletes the streaming configurations for an AppInstance. For * more information, see Streaming * messaging data in the Amazon Chime SDK Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteMessagingStreamingConfigurationsOutcome DeleteMessagingStreamingConfigurations(const Model::DeleteMessagingStreamingConfigurationsRequest& request) const; /** * A Callable wrapper for DeleteMessagingStreamingConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMessagingStreamingConfigurationsOutcomeCallable DeleteMessagingStreamingConfigurationsCallable(const DeleteMessagingStreamingConfigurationsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DeleteMessagingStreamingConfigurations, request); } /** * An Async wrapper for DeleteMessagingStreamingConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMessagingStreamingConfigurationsAsync(const DeleteMessagingStreamingConfigurationsRequestT& request, const DeleteMessagingStreamingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DeleteMessagingStreamingConfigurations, request, handler, context); } /** *

Returns the full details of a channel in an Amazon Chime * AppInstance.

The x-amz-chime-bearer * request header is mandatory. Use the ARN of the AppInstanceUser or * AppInstanceBot that makes the API call as the value in the * header.

See Also:

AWS * API Reference

*/ virtual Model::DescribeChannelOutcome DescribeChannel(const Model::DescribeChannelRequest& request) const; /** * A Callable wrapper for DescribeChannel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeChannelOutcomeCallable DescribeChannelCallable(const DescribeChannelRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DescribeChannel, request); } /** * An Async wrapper for DescribeChannel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeChannelAsync(const DescribeChannelRequestT& request, const DescribeChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DescribeChannel, request, handler, context); } /** *

Returns the full details of a channel ban.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::DescribeChannelBanOutcome DescribeChannelBan(const Model::DescribeChannelBanRequest& request) const; /** * A Callable wrapper for DescribeChannelBan that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeChannelBanOutcomeCallable DescribeChannelBanCallable(const DescribeChannelBanRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DescribeChannelBan, request); } /** * An Async wrapper for DescribeChannelBan that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeChannelBanAsync(const DescribeChannelBanRequestT& request, const DescribeChannelBanResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DescribeChannelBan, request, handler, context); } /** *

Returns the full details of a channel flow in an Amazon Chime * AppInstance. This is a developer API.

See Also:

AWS * API Reference

*/ virtual Model::DescribeChannelFlowOutcome DescribeChannelFlow(const Model::DescribeChannelFlowRequest& request) const; /** * A Callable wrapper for DescribeChannelFlow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeChannelFlowOutcomeCallable DescribeChannelFlowCallable(const DescribeChannelFlowRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DescribeChannelFlow, request); } /** * An Async wrapper for DescribeChannelFlow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeChannelFlowAsync(const DescribeChannelFlowRequestT& request, const DescribeChannelFlowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DescribeChannelFlow, request, handler, context); } /** *

Returns the full details of a user's channel membership.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::DescribeChannelMembershipOutcome DescribeChannelMembership(const Model::DescribeChannelMembershipRequest& request) const; /** * A Callable wrapper for DescribeChannelMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeChannelMembershipOutcomeCallable DescribeChannelMembershipCallable(const DescribeChannelMembershipRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DescribeChannelMembership, request); } /** * An Async wrapper for DescribeChannelMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeChannelMembershipAsync(const DescribeChannelMembershipRequestT& request, const DescribeChannelMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DescribeChannelMembership, request, handler, context); } /** *

Returns the details of a channel based on the membership of the specified * AppInstanceUser or AppInstanceBot.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::DescribeChannelMembershipForAppInstanceUserOutcome DescribeChannelMembershipForAppInstanceUser(const Model::DescribeChannelMembershipForAppInstanceUserRequest& request) const; /** * A Callable wrapper for DescribeChannelMembershipForAppInstanceUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeChannelMembershipForAppInstanceUserOutcomeCallable DescribeChannelMembershipForAppInstanceUserCallable(const DescribeChannelMembershipForAppInstanceUserRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DescribeChannelMembershipForAppInstanceUser, request); } /** * An Async wrapper for DescribeChannelMembershipForAppInstanceUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeChannelMembershipForAppInstanceUserAsync(const DescribeChannelMembershipForAppInstanceUserRequestT& request, const DescribeChannelMembershipForAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DescribeChannelMembershipForAppInstanceUser, request, handler, context); } /** *

Returns the full details of a channel moderated by the specified * AppInstanceUser or AppInstanceBot.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::DescribeChannelModeratedByAppInstanceUserOutcome DescribeChannelModeratedByAppInstanceUser(const Model::DescribeChannelModeratedByAppInstanceUserRequest& request) const; /** * A Callable wrapper for DescribeChannelModeratedByAppInstanceUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeChannelModeratedByAppInstanceUserOutcomeCallable DescribeChannelModeratedByAppInstanceUserCallable(const DescribeChannelModeratedByAppInstanceUserRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DescribeChannelModeratedByAppInstanceUser, request); } /** * An Async wrapper for DescribeChannelModeratedByAppInstanceUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeChannelModeratedByAppInstanceUserAsync(const DescribeChannelModeratedByAppInstanceUserRequestT& request, const DescribeChannelModeratedByAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DescribeChannelModeratedByAppInstanceUser, request, handler, context); } /** *

Returns the full details of a single ChannelModerator.

The * x-amz-chime-bearer request header is mandatory. Use the * AppInstanceUserArn of the user that makes the API call as the value * in the header.

See Also:

AWS * API Reference

*/ virtual Model::DescribeChannelModeratorOutcome DescribeChannelModerator(const Model::DescribeChannelModeratorRequest& request) const; /** * A Callable wrapper for DescribeChannelModerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeChannelModeratorOutcomeCallable DescribeChannelModeratorCallable(const DescribeChannelModeratorRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DescribeChannelModerator, request); } /** * An Async wrapper for DescribeChannelModerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeChannelModeratorAsync(const DescribeChannelModeratorRequestT& request, const DescribeChannelModeratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DescribeChannelModerator, request, handler, context); } /** *

Disassociates a channel flow from all its channels. Once disassociated, all * messages to that channel stop going through the channel flow processor.

*

Only administrators or channel moderators can disassociate a channel * flow.

The x-amz-chime-bearer request header is mandatory. * Use the ARN of the AppInstanceUser or AppInstanceBot * that makes the API call as the value in the header.

See * Also:

AWS * API Reference

*/ virtual Model::DisassociateChannelFlowOutcome DisassociateChannelFlow(const Model::DisassociateChannelFlowRequest& request) const; /** * A Callable wrapper for DisassociateChannelFlow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateChannelFlowOutcomeCallable DisassociateChannelFlowCallable(const DisassociateChannelFlowRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::DisassociateChannelFlow, request); } /** * An Async wrapper for DisassociateChannelFlow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateChannelFlowAsync(const DisassociateChannelFlowRequestT& request, const DisassociateChannelFlowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::DisassociateChannelFlow, request, handler, context); } /** *

Gets the membership preferences of an AppInstanceUser or * AppInstanceBot for the specified channel. A user or a bot must be a * member of the channel and own the membership in order to retrieve membership * preferences. Users or bots in the AppInstanceAdmin and channel * moderator roles can't retrieve preferences for other users or bots. Banned users * or bots can't retrieve membership preferences for the channel from which they * are banned.

The x-amz-chime-bearer request header is * mandatory. Use the ARN of the AppInstanceUser or * AppInstanceBot that makes the API call as the value in the * header.

See Also:

AWS * API Reference

*/ virtual Model::GetChannelMembershipPreferencesOutcome GetChannelMembershipPreferences(const Model::GetChannelMembershipPreferencesRequest& request) const; /** * A Callable wrapper for GetChannelMembershipPreferences that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetChannelMembershipPreferencesOutcomeCallable GetChannelMembershipPreferencesCallable(const GetChannelMembershipPreferencesRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::GetChannelMembershipPreferences, request); } /** * An Async wrapper for GetChannelMembershipPreferences that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetChannelMembershipPreferencesAsync(const GetChannelMembershipPreferencesRequestT& request, const GetChannelMembershipPreferencesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::GetChannelMembershipPreferences, request, handler, context); } /** *

Gets the full details of a channel message.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::GetChannelMessageOutcome GetChannelMessage(const Model::GetChannelMessageRequest& request) const; /** * A Callable wrapper for GetChannelMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetChannelMessageOutcomeCallable GetChannelMessageCallable(const GetChannelMessageRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::GetChannelMessage, request); } /** * An Async wrapper for GetChannelMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetChannelMessageAsync(const GetChannelMessageRequestT& request, const GetChannelMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::GetChannelMessage, request, handler, context); } /** *

Gets message status for a specified messageId. Use this API to * determine the intermediate status of messages going through channel flow * processing. The API provides an alternative to retrieving message status if the * event was not received because a client wasn't connected to a websocket.

*

Messages can have any one of these statuses.

SENT
*

Message processed successfully

PENDING

Ongoing * processing

FAILED

Processing failed

*
DENIED

Message denied by the processor

*

  • This API does not return statuses for denied messages, because we * don't store them once the processor denies them.

  • Only the * message sender can invoke this API.

  • The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

* AWS * API Reference

*/ virtual Model::GetChannelMessageStatusOutcome GetChannelMessageStatus(const Model::GetChannelMessageStatusRequest& request) const; /** * A Callable wrapper for GetChannelMessageStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetChannelMessageStatusOutcomeCallable GetChannelMessageStatusCallable(const GetChannelMessageStatusRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::GetChannelMessageStatus, request); } /** * An Async wrapper for GetChannelMessageStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetChannelMessageStatusAsync(const GetChannelMessageStatusRequestT& request, const GetChannelMessageStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::GetChannelMessageStatus, request, handler, context); } /** *

The details of the endpoint for the messaging session.

See * Also:

AWS * API Reference

*/ virtual Model::GetMessagingSessionEndpointOutcome GetMessagingSessionEndpoint(const Model::GetMessagingSessionEndpointRequest& request) const; /** * A Callable wrapper for GetMessagingSessionEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMessagingSessionEndpointOutcomeCallable GetMessagingSessionEndpointCallable(const GetMessagingSessionEndpointRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::GetMessagingSessionEndpoint, request); } /** * An Async wrapper for GetMessagingSessionEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMessagingSessionEndpointAsync(const GetMessagingSessionEndpointRequestT& request, const GetMessagingSessionEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::GetMessagingSessionEndpoint, request, handler, context); } /** *

Retrieves the data streaming configuration for an AppInstance. * For more information, see Streaming * messaging data in the Amazon Chime SDK Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::GetMessagingStreamingConfigurationsOutcome GetMessagingStreamingConfigurations(const Model::GetMessagingStreamingConfigurationsRequest& request) const; /** * A Callable wrapper for GetMessagingStreamingConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMessagingStreamingConfigurationsOutcomeCallable GetMessagingStreamingConfigurationsCallable(const GetMessagingStreamingConfigurationsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::GetMessagingStreamingConfigurations, request); } /** * An Async wrapper for GetMessagingStreamingConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMessagingStreamingConfigurationsAsync(const GetMessagingStreamingConfigurationsRequestT& request, const GetMessagingStreamingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::GetMessagingStreamingConfigurations, request, handler, context); } /** *

Lists all the users and bots banned from a particular channel.

*

The x-amz-chime-bearer request header is mandatory. Use the ARN * of the AppInstanceUser or AppInstanceBot that makes * the API call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::ListChannelBansOutcome ListChannelBans(const Model::ListChannelBansRequest& request) const; /** * A Callable wrapper for ListChannelBans that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChannelBansOutcomeCallable ListChannelBansCallable(const ListChannelBansRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListChannelBans, request); } /** * An Async wrapper for ListChannelBans that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChannelBansAsync(const ListChannelBansRequestT& request, const ListChannelBansResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListChannelBans, request, handler, context); } /** *

Returns a paginated lists of all the channel flows created under a single * Chime. This is a developer API.

See Also:

AWS * API Reference

*/ virtual Model::ListChannelFlowsOutcome ListChannelFlows(const Model::ListChannelFlowsRequest& request) const; /** * A Callable wrapper for ListChannelFlows that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChannelFlowsOutcomeCallable ListChannelFlowsCallable(const ListChannelFlowsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListChannelFlows, request); } /** * An Async wrapper for ListChannelFlows that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChannelFlowsAsync(const ListChannelFlowsRequestT& request, const ListChannelFlowsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListChannelFlows, request, handler, context); } /** *

Lists all channel memberships in a channel.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

If you want to list the channels * to which a specific app instance user belongs, see the ListChannelMembershipsForAppInstanceUser * API.

See Also:

AWS * API Reference

*/ virtual Model::ListChannelMembershipsOutcome ListChannelMemberships(const Model::ListChannelMembershipsRequest& request) const; /** * A Callable wrapper for ListChannelMemberships that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChannelMembershipsOutcomeCallable ListChannelMembershipsCallable(const ListChannelMembershipsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListChannelMemberships, request); } /** * An Async wrapper for ListChannelMemberships that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChannelMembershipsAsync(const ListChannelMembershipsRequestT& request, const ListChannelMembershipsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListChannelMemberships, request, handler, context); } /** *

Lists all channels that an AppInstanceUser or * AppInstanceBot is a part of. Only an AppInstanceAdmin * can call the API with a user ARN that is not their own.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::ListChannelMembershipsForAppInstanceUserOutcome ListChannelMembershipsForAppInstanceUser(const Model::ListChannelMembershipsForAppInstanceUserRequest& request) const; /** * A Callable wrapper for ListChannelMembershipsForAppInstanceUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChannelMembershipsForAppInstanceUserOutcomeCallable ListChannelMembershipsForAppInstanceUserCallable(const ListChannelMembershipsForAppInstanceUserRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListChannelMembershipsForAppInstanceUser, request); } /** * An Async wrapper for ListChannelMembershipsForAppInstanceUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChannelMembershipsForAppInstanceUserAsync(const ListChannelMembershipsForAppInstanceUserRequestT& request, const ListChannelMembershipsForAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListChannelMembershipsForAppInstanceUser, request, handler, context); } /** *

List all the messages in a channel. Returns a paginated list of * ChannelMessages. By default, sorted by creation timestamp in * descending order.

Redacted messages appear in the results as * empty, since they are only redacted, not deleted. Deleted messages do not appear * in the results. This action always returns the latest version of an edited * message.

Also, the x-amz-chime-bearer request header is * mandatory. Use the ARN of the AppInstanceUser or * AppInstanceBot that makes the API call as the value in the * header.

See Also:

AWS * API Reference

*/ virtual Model::ListChannelMessagesOutcome ListChannelMessages(const Model::ListChannelMessagesRequest& request) const; /** * A Callable wrapper for ListChannelMessages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChannelMessagesOutcomeCallable ListChannelMessagesCallable(const ListChannelMessagesRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListChannelMessages, request); } /** * An Async wrapper for ListChannelMessages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChannelMessagesAsync(const ListChannelMessagesRequestT& request, const ListChannelMessagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListChannelMessages, request, handler, context); } /** *

Lists all the moderators for a channel.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::ListChannelModeratorsOutcome ListChannelModerators(const Model::ListChannelModeratorsRequest& request) const; /** * A Callable wrapper for ListChannelModerators that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChannelModeratorsOutcomeCallable ListChannelModeratorsCallable(const ListChannelModeratorsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListChannelModerators, request); } /** * An Async wrapper for ListChannelModerators that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChannelModeratorsAsync(const ListChannelModeratorsRequestT& request, const ListChannelModeratorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListChannelModerators, request, handler, context); } /** *

Lists all Channels created under a single Chime App as a paginated list. You * can specify filters to narrow results.

Functionality * & restrictions

  • Use privacy = PUBLIC to * retrieve all public channels in the account.

  • Only an * AppInstanceAdmin can set privacy = PRIVATE to list the * private channels in an account.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::ListChannelsOutcome ListChannels(const Model::ListChannelsRequest& request) const; /** * A Callable wrapper for ListChannels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChannelsOutcomeCallable ListChannelsCallable(const ListChannelsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListChannels, request); } /** * An Async wrapper for ListChannels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChannelsAsync(const ListChannelsRequestT& request, const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListChannels, request, handler, context); } /** *

Lists all channels associated with a specified channel flow. You can * associate a channel flow with multiple channels, but you can only associate a * channel with one channel flow. This is a developer API.

See Also:

* AWS * API Reference

*/ virtual Model::ListChannelsAssociatedWithChannelFlowOutcome ListChannelsAssociatedWithChannelFlow(const Model::ListChannelsAssociatedWithChannelFlowRequest& request) const; /** * A Callable wrapper for ListChannelsAssociatedWithChannelFlow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChannelsAssociatedWithChannelFlowOutcomeCallable ListChannelsAssociatedWithChannelFlowCallable(const ListChannelsAssociatedWithChannelFlowRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListChannelsAssociatedWithChannelFlow, request); } /** * An Async wrapper for ListChannelsAssociatedWithChannelFlow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChannelsAssociatedWithChannelFlowAsync(const ListChannelsAssociatedWithChannelFlowRequestT& request, const ListChannelsAssociatedWithChannelFlowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListChannelsAssociatedWithChannelFlow, request, handler, context); } /** *

A list of the channels moderated by an AppInstanceUser.

*

The x-amz-chime-bearer request header is mandatory. Use * the ARN of the AppInstanceUser or AppInstanceBot that * makes the API call as the value in the header.

See Also:

* AWS * API Reference

*/ virtual Model::ListChannelsModeratedByAppInstanceUserOutcome ListChannelsModeratedByAppInstanceUser(const Model::ListChannelsModeratedByAppInstanceUserRequest& request) const; /** * A Callable wrapper for ListChannelsModeratedByAppInstanceUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChannelsModeratedByAppInstanceUserOutcomeCallable ListChannelsModeratedByAppInstanceUserCallable(const ListChannelsModeratedByAppInstanceUserRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListChannelsModeratedByAppInstanceUser, request); } /** * An Async wrapper for ListChannelsModeratedByAppInstanceUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChannelsModeratedByAppInstanceUserAsync(const ListChannelsModeratedByAppInstanceUserRequestT& request, const ListChannelsModeratedByAppInstanceUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListChannelsModeratedByAppInstanceUser, request, handler, context); } /** *

Lists all the SubChannels in an elastic channel when given a channel ID. * Available only to the app instance admins and channel moderators of elastic * channels.

See Also:

AWS * API Reference

*/ virtual Model::ListSubChannelsOutcome ListSubChannels(const Model::ListSubChannelsRequest& request) const; /** * A Callable wrapper for ListSubChannels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSubChannelsOutcomeCallable ListSubChannelsCallable(const ListSubChannelsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListSubChannels, request); } /** * An Async wrapper for ListSubChannels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSubChannelsAsync(const ListSubChannelsRequestT& request, const ListSubChannelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListSubChannels, request, handler, context); } /** *

Lists the tags applied to an Amazon Chime SDK messaging * resource.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::ListTagsForResource, request, handler, context); } /** *

Sets the number of days before the channel is automatically deleted.

*

  • A background process deletes expired channels within 6 hours * of expiration. Actual deletion times may vary.

  • Expired * channels that have not yet been deleted appear as active, and you can update * their expiration settings. The system honors the new settings.

  • *

    The x-amz-chime-bearer request header is mandatory. Use the ARN * of the AppInstanceUser or AppInstanceBot that makes * the API call as the value in the header.

See * Also:

AWS * API Reference

*/ virtual Model::PutChannelExpirationSettingsOutcome PutChannelExpirationSettings(const Model::PutChannelExpirationSettingsRequest& request) const; /** * A Callable wrapper for PutChannelExpirationSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutChannelExpirationSettingsOutcomeCallable PutChannelExpirationSettingsCallable(const PutChannelExpirationSettingsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::PutChannelExpirationSettings, request); } /** * An Async wrapper for PutChannelExpirationSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutChannelExpirationSettingsAsync(const PutChannelExpirationSettingsRequestT& request, const PutChannelExpirationSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::PutChannelExpirationSettings, request, handler, context); } /** *

Sets the membership preferences of an AppInstanceUser or * AppInstanceBot for the specified channel. The user or bot must be a * member of the channel. Only the user or bot who owns the membership can set * preferences. Users or bots in the AppInstanceAdmin and channel * moderator roles can't set preferences for other users. Banned users or bots * can't set membership preferences for the channel from which they are banned.

*

The x-amz-chime-bearer request header is mandatory. Use the ARN of an * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::PutChannelMembershipPreferencesOutcome PutChannelMembershipPreferences(const Model::PutChannelMembershipPreferencesRequest& request) const; /** * A Callable wrapper for PutChannelMembershipPreferences that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutChannelMembershipPreferencesOutcomeCallable PutChannelMembershipPreferencesCallable(const PutChannelMembershipPreferencesRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::PutChannelMembershipPreferences, request); } /** * An Async wrapper for PutChannelMembershipPreferences that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutChannelMembershipPreferencesAsync(const PutChannelMembershipPreferencesRequestT& request, const PutChannelMembershipPreferencesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::PutChannelMembershipPreferences, request, handler, context); } /** *

Sets the data streaming configuration for an AppInstance. For * more information, see Streaming * messaging data in the Amazon Chime SDK Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::PutMessagingStreamingConfigurationsOutcome PutMessagingStreamingConfigurations(const Model::PutMessagingStreamingConfigurationsRequest& request) const; /** * A Callable wrapper for PutMessagingStreamingConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutMessagingStreamingConfigurationsOutcomeCallable PutMessagingStreamingConfigurationsCallable(const PutMessagingStreamingConfigurationsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::PutMessagingStreamingConfigurations, request); } /** * An Async wrapper for PutMessagingStreamingConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutMessagingStreamingConfigurationsAsync(const PutMessagingStreamingConfigurationsRequestT& request, const PutMessagingStreamingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::PutMessagingStreamingConfigurations, request, handler, context); } /** *

Redacts message content, but not metadata. The message exists in the back * end, but the action returns null content, and the state shows as redacted.

*

The x-amz-chime-bearer request header is mandatory. Use * the ARN of the AppInstanceUser or AppInstanceBot that * makes the API call as the value in the header.

See Also:

* AWS * API Reference

*/ virtual Model::RedactChannelMessageOutcome RedactChannelMessage(const Model::RedactChannelMessageRequest& request) const; /** * A Callable wrapper for RedactChannelMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RedactChannelMessageOutcomeCallable RedactChannelMessageCallable(const RedactChannelMessageRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::RedactChannelMessage, request); } /** * An Async wrapper for RedactChannelMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RedactChannelMessageAsync(const RedactChannelMessageRequestT& request, const RedactChannelMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::RedactChannelMessage, request, handler, context); } /** *

Allows the ChimeBearer to search channels by channel members. * Users or bots can search across the channels that they belong to. Users in the * AppInstanceAdmin role can search across all channels.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::SearchChannelsOutcome SearchChannels(const Model::SearchChannelsRequest& request) const; /** * A Callable wrapper for SearchChannels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchChannelsOutcomeCallable SearchChannelsCallable(const SearchChannelsRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::SearchChannels, request); } /** * An Async wrapper for SearchChannels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchChannelsAsync(const SearchChannelsRequestT& request, const SearchChannelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::SearchChannels, request, handler, context); } /** *

Sends a message to a particular channel that the member is a part of.

*

The x-amz-chime-bearer request header is mandatory. Use * the ARN of the AppInstanceUser or AppInstanceBot that * makes the API call as the value in the header.

Also, * STANDARD messages can be up to 4KB in size and contain metadata. * Metadata is arbitrary, and you can use it in a variety of ways, such as * containing a link to an attachment.

CONTROL messages are * limited to 30 bytes and do not contain metadata.

See * Also:

AWS * API Reference

*/ virtual Model::SendChannelMessageOutcome SendChannelMessage(const Model::SendChannelMessageRequest& request) const; /** * A Callable wrapper for SendChannelMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendChannelMessageOutcomeCallable SendChannelMessageCallable(const SendChannelMessageRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::SendChannelMessage, request); } /** * An Async wrapper for SendChannelMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendChannelMessageAsync(const SendChannelMessageRequestT& request, const SendChannelMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::SendChannelMessage, request, handler, context); } /** *

Applies the specified tags to the specified Amazon Chime SDK messaging * resource.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::TagResource, request, handler, context); } /** *

Removes the specified tags from the specified Amazon Chime SDK messaging * resource.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::UntagResource, request, handler, context); } /** *

Update a channel's attributes.

Restriction: You can't change a * channel's privacy.

The x-amz-chime-bearer request * header is mandatory. Use the ARN of the AppInstanceUser or * AppInstanceBot that makes the API call as the value in the * header.

See Also:

AWS * API Reference

*/ virtual Model::UpdateChannelOutcome UpdateChannel(const Model::UpdateChannelRequest& request) const; /** * A Callable wrapper for UpdateChannel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateChannelOutcomeCallable UpdateChannelCallable(const UpdateChannelRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::UpdateChannel, request); } /** * An Async wrapper for UpdateChannel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateChannelAsync(const UpdateChannelRequestT& request, const UpdateChannelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::UpdateChannel, request, handler, context); } /** *

Updates channel flow attributes. This is a developer API.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateChannelFlowOutcome UpdateChannelFlow(const Model::UpdateChannelFlowRequest& request) const; /** * A Callable wrapper for UpdateChannelFlow that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateChannelFlowOutcomeCallable UpdateChannelFlowCallable(const UpdateChannelFlowRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::UpdateChannelFlow, request); } /** * An Async wrapper for UpdateChannelFlow that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateChannelFlowAsync(const UpdateChannelFlowRequestT& request, const UpdateChannelFlowResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::UpdateChannelFlow, request, handler, context); } /** *

Updates the content of a message.

The * x-amz-chime-bearer request header is mandatory. Use the ARN of the * AppInstanceUser or AppInstanceBot that makes the API * call as the value in the header.

See Also:

AWS * API Reference

*/ virtual Model::UpdateChannelMessageOutcome UpdateChannelMessage(const Model::UpdateChannelMessageRequest& request) const; /** * A Callable wrapper for UpdateChannelMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateChannelMessageOutcomeCallable UpdateChannelMessageCallable(const UpdateChannelMessageRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::UpdateChannelMessage, request); } /** * An Async wrapper for UpdateChannelMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateChannelMessageAsync(const UpdateChannelMessageRequestT& request, const UpdateChannelMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::UpdateChannelMessage, request, handler, context); } /** *

The details of the time when a user last read messages in a channel.

*

The x-amz-chime-bearer request header is mandatory. Use * the ARN of the AppInstanceUser or AppInstanceBot that * makes the API call as the value in the header.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateChannelReadMarkerOutcome UpdateChannelReadMarker(const Model::UpdateChannelReadMarkerRequest& request) const; /** * A Callable wrapper for UpdateChannelReadMarker that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateChannelReadMarkerOutcomeCallable UpdateChannelReadMarkerCallable(const UpdateChannelReadMarkerRequestT& request) const { return SubmitCallable(&ChimeSDKMessagingClient::UpdateChannelReadMarker, request); } /** * An Async wrapper for UpdateChannelReadMarker that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateChannelReadMarkerAsync(const UpdateChannelReadMarkerRequestT& request, const UpdateChannelReadMarkerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKMessagingClient::UpdateChannelReadMarker, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const ChimeSDKMessagingClientConfiguration& clientConfiguration); ChimeSDKMessagingClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace ChimeSDKMessaging } // namespace Aws