/** * 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 ChimeSDKVoice { /** *

The Amazon Chime SDK telephony APIs in this section enable developers to * create PSTN calling solutions that use Amazon Chime SDK Voice Connectors, and * Amazon Chime SDK SIP media applications. Developers can also order and manage * phone numbers, create and manage Voice Connectors and SIP media applications, * and run voice analytics.

*/ class AWS_CHIMESDKVOICE_API ChimeSDKVoiceClient : 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 ChimeSDKVoiceClientConfiguration ClientConfigurationType; typedef ChimeSDKVoiceEndpointProvider 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. */ ChimeSDKVoiceClient(const Aws::ChimeSDKVoice::ChimeSDKVoiceClientConfiguration& clientConfiguration = Aws::ChimeSDKVoice::ChimeSDKVoiceClientConfiguration(), 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. */ ChimeSDKVoiceClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::ChimeSDKVoice::ChimeSDKVoiceClientConfiguration& clientConfiguration = Aws::ChimeSDKVoice::ChimeSDKVoiceClientConfiguration()); /** * 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 */ ChimeSDKVoiceClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::ChimeSDKVoice::ChimeSDKVoiceClientConfiguration& clientConfiguration = Aws::ChimeSDKVoice::ChimeSDKVoiceClientConfiguration()); /* 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. */ ChimeSDKVoiceClient(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. */ ChimeSDKVoiceClient(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 */ ChimeSDKVoiceClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~ChimeSDKVoiceClient(); /** *

Associates phone numbers with the specified Amazon Chime SDK Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::AssociatePhoneNumbersWithVoiceConnectorOutcome AssociatePhoneNumbersWithVoiceConnector(const Model::AssociatePhoneNumbersWithVoiceConnectorRequest& request) const; /** * A Callable wrapper for AssociatePhoneNumbersWithVoiceConnector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociatePhoneNumbersWithVoiceConnectorOutcomeCallable AssociatePhoneNumbersWithVoiceConnectorCallable(const AssociatePhoneNumbersWithVoiceConnectorRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::AssociatePhoneNumbersWithVoiceConnector, request); } /** * An Async wrapper for AssociatePhoneNumbersWithVoiceConnector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociatePhoneNumbersWithVoiceConnectorAsync(const AssociatePhoneNumbersWithVoiceConnectorRequestT& request, const AssociatePhoneNumbersWithVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::AssociatePhoneNumbersWithVoiceConnector, request, handler, context); } /** *

Associates phone numbers with the specified Amazon Chime SDK Voice Connector * group.

See Also:

AWS * API Reference

*/ virtual Model::AssociatePhoneNumbersWithVoiceConnectorGroupOutcome AssociatePhoneNumbersWithVoiceConnectorGroup(const Model::AssociatePhoneNumbersWithVoiceConnectorGroupRequest& request) const; /** * A Callable wrapper for AssociatePhoneNumbersWithVoiceConnectorGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociatePhoneNumbersWithVoiceConnectorGroupOutcomeCallable AssociatePhoneNumbersWithVoiceConnectorGroupCallable(const AssociatePhoneNumbersWithVoiceConnectorGroupRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::AssociatePhoneNumbersWithVoiceConnectorGroup, request); } /** * An Async wrapper for AssociatePhoneNumbersWithVoiceConnectorGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociatePhoneNumbersWithVoiceConnectorGroupAsync(const AssociatePhoneNumbersWithVoiceConnectorGroupRequestT& request, const AssociatePhoneNumbersWithVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::AssociatePhoneNumbersWithVoiceConnectorGroup, request, handler, context); } /** *

Moves phone numbers into the Deletion queue. Phone numbers must be * disassociated from any users or Amazon Chime SDK Voice Connectors before they * can be deleted.

Phone numbers remain in the Deletion queue for 7 * days before they are deleted permanently.

See Also:

AWS * API Reference

*/ virtual Model::BatchDeletePhoneNumberOutcome BatchDeletePhoneNumber(const Model::BatchDeletePhoneNumberRequest& request) const; /** * A Callable wrapper for BatchDeletePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDeletePhoneNumberOutcomeCallable BatchDeletePhoneNumberCallable(const BatchDeletePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::BatchDeletePhoneNumber, request); } /** * An Async wrapper for BatchDeletePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDeletePhoneNumberAsync(const BatchDeletePhoneNumberRequestT& request, const BatchDeletePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::BatchDeletePhoneNumber, request, handler, context); } /** *

Updates one or more phone numbers.

See Also:

AWS * API Reference

*/ virtual Model::BatchUpdatePhoneNumberOutcome BatchUpdatePhoneNumber(const Model::BatchUpdatePhoneNumberRequest& request) const; /** * A Callable wrapper for BatchUpdatePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchUpdatePhoneNumberOutcomeCallable BatchUpdatePhoneNumberCallable(const BatchUpdatePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::BatchUpdatePhoneNumber, request); } /** * An Async wrapper for BatchUpdatePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchUpdatePhoneNumberAsync(const BatchUpdatePhoneNumberRequestT& request, const BatchUpdatePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::BatchUpdatePhoneNumber, request, handler, context); } /** *

Creates an order for phone numbers to be provisioned. For numbers outside the * U.S., you must use the Amazon Chime SDK SIP media application dial-in product * type.

See Also:

AWS * API Reference

*/ virtual Model::CreatePhoneNumberOrderOutcome CreatePhoneNumberOrder(const Model::CreatePhoneNumberOrderRequest& request) const; /** * A Callable wrapper for CreatePhoneNumberOrder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePhoneNumberOrderOutcomeCallable CreatePhoneNumberOrderCallable(const CreatePhoneNumberOrderRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::CreatePhoneNumberOrder, request); } /** * An Async wrapper for CreatePhoneNumberOrder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePhoneNumberOrderAsync(const CreatePhoneNumberOrderRequestT& request, const CreatePhoneNumberOrderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::CreatePhoneNumberOrder, request, handler, context); } /** *

Creates a proxy session for the specified Amazon Chime SDK Voice Connector * for the specified participant phone numbers.

See Also:

AWS * API Reference

*/ virtual Model::CreateProxySessionOutcome CreateProxySession(const Model::CreateProxySessionRequest& request) const; /** * A Callable wrapper for CreateProxySession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProxySessionOutcomeCallable CreateProxySessionCallable(const CreateProxySessionRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::CreateProxySession, request); } /** * An Async wrapper for CreateProxySession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProxySessionAsync(const CreateProxySessionRequestT& request, const CreateProxySessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::CreateProxySession, request, handler, context); } /** *

Creates a SIP media application. For more information about SIP media * applications, see Managing * SIP media applications and rules in the Amazon Chime SDK Administrator * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateSipMediaApplicationOutcome CreateSipMediaApplication(const Model::CreateSipMediaApplicationRequest& request) const; /** * A Callable wrapper for CreateSipMediaApplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSipMediaApplicationOutcomeCallable CreateSipMediaApplicationCallable(const CreateSipMediaApplicationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::CreateSipMediaApplication, request); } /** * An Async wrapper for CreateSipMediaApplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSipMediaApplicationAsync(const CreateSipMediaApplicationRequestT& request, const CreateSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::CreateSipMediaApplication, request, handler, context); } /** *

Creates an outbound call to a phone number from the phone number specified in * the request, and it invokes the endpoint of the specified * sipMediaApplicationId.

See Also:

AWS * API Reference

*/ virtual Model::CreateSipMediaApplicationCallOutcome CreateSipMediaApplicationCall(const Model::CreateSipMediaApplicationCallRequest& request) const; /** * A Callable wrapper for CreateSipMediaApplicationCall that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSipMediaApplicationCallOutcomeCallable CreateSipMediaApplicationCallCallable(const CreateSipMediaApplicationCallRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::CreateSipMediaApplicationCall, request); } /** * An Async wrapper for CreateSipMediaApplicationCall that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSipMediaApplicationCallAsync(const CreateSipMediaApplicationCallRequestT& request, const CreateSipMediaApplicationCallResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::CreateSipMediaApplicationCall, request, handler, context); } /** *

Creates a SIP rule, which can be used to run a SIP media application as a * target for a specific trigger type. For more information about SIP rules, see Managing * SIP media applications and rules in the Amazon Chime SDK Administrator * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateSipRuleOutcome CreateSipRule(const Model::CreateSipRuleRequest& request) const; /** * A Callable wrapper for CreateSipRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSipRuleOutcomeCallable CreateSipRuleCallable(const CreateSipRuleRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::CreateSipRule, request); } /** * An Async wrapper for CreateSipRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSipRuleAsync(const CreateSipRuleRequestT& request, const CreateSipRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::CreateSipRule, request, handler, context); } /** *

Creates an Amazon Chime SDK Voice Connector. For more information about Voice * Connectors, see Managing * Amazon Chime SDK Voice Connector groups in the Amazon Chime SDK * Administrator Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateVoiceConnectorOutcome CreateVoiceConnector(const Model::CreateVoiceConnectorRequest& request) const; /** * A Callable wrapper for CreateVoiceConnector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVoiceConnectorOutcomeCallable CreateVoiceConnectorCallable(const CreateVoiceConnectorRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::CreateVoiceConnector, request); } /** * An Async wrapper for CreateVoiceConnector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVoiceConnectorAsync(const CreateVoiceConnectorRequestT& request, const CreateVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::CreateVoiceConnector, request, handler, context); } /** *

Creates an Amazon Chime SDK Voice Connector group under the administrator's * AWS account. You can associate Amazon Chime SDK Voice Connectors with the Voice * Connector group by including VoiceConnectorItems in the request. *

You can include Voice Connectors from different AWS Regions in your * group. This creates a fault tolerant mechanism for fallback in case of * availability events.

See Also:

AWS * API Reference

*/ virtual Model::CreateVoiceConnectorGroupOutcome CreateVoiceConnectorGroup(const Model::CreateVoiceConnectorGroupRequest& request) const; /** * A Callable wrapper for CreateVoiceConnectorGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVoiceConnectorGroupOutcomeCallable CreateVoiceConnectorGroupCallable(const CreateVoiceConnectorGroupRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::CreateVoiceConnectorGroup, request); } /** * An Async wrapper for CreateVoiceConnectorGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVoiceConnectorGroupAsync(const CreateVoiceConnectorGroupRequestT& request, const CreateVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::CreateVoiceConnectorGroup, request, handler, context); } /** *

Creates a voice profile, which consists of an enrolled user and their latest * voice print.

Before creating any voice profiles, you must * provide all notices and obtain all consents from the speaker as required under * applicable privacy and biometrics laws, and as required under the AWS service terms for the * Amazon Chime SDK.

For more information about voice profiles * and voice analytics, see Using * Amazon Chime SDK Voice Analytics in the Amazon Chime SDK Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateVoiceProfileOutcome CreateVoiceProfile(const Model::CreateVoiceProfileRequest& request) const; /** * A Callable wrapper for CreateVoiceProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVoiceProfileOutcomeCallable CreateVoiceProfileCallable(const CreateVoiceProfileRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::CreateVoiceProfile, request); } /** * An Async wrapper for CreateVoiceProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVoiceProfileAsync(const CreateVoiceProfileRequestT& request, const CreateVoiceProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::CreateVoiceProfile, request, handler, context); } /** *

Creates a voice profile domain, a collection of voice profiles, their voice * prints, and encrypted enrollment audio.

Before creating any * voice profiles, you must provide all notices and obtain all consents from the * speaker as required under applicable privacy and biometrics laws, and as * required under the AWS service * terms for the Amazon Chime SDK.

For more information * about voice profile domains, see Using * Amazon Chime SDK Voice Analytics in the Amazon Chime SDK Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateVoiceProfileDomainOutcome CreateVoiceProfileDomain(const Model::CreateVoiceProfileDomainRequest& request) const; /** * A Callable wrapper for CreateVoiceProfileDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVoiceProfileDomainOutcomeCallable CreateVoiceProfileDomainCallable(const CreateVoiceProfileDomainRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::CreateVoiceProfileDomain, request); } /** * An Async wrapper for CreateVoiceProfileDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVoiceProfileDomainAsync(const CreateVoiceProfileDomainRequestT& request, const CreateVoiceProfileDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::CreateVoiceProfileDomain, request, handler, context); } /** *

Moves the specified phone number into the Deletion queue. A phone * number must be disassociated from any users or Amazon Chime SDK Voice Connectors * before it can be deleted.

Deleted phone numbers remain in the Deletion * queue queue for 7 days before they are deleted permanently.

See * Also:

AWS * API Reference

*/ virtual Model::DeletePhoneNumberOutcome DeletePhoneNumber(const Model::DeletePhoneNumberRequest& request) const; /** * A Callable wrapper for DeletePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePhoneNumberOutcomeCallable DeletePhoneNumberCallable(const DeletePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeletePhoneNumber, request); } /** * An Async wrapper for DeletePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePhoneNumberAsync(const DeletePhoneNumberRequestT& request, const DeletePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeletePhoneNumber, request, handler, context); } /** *

Deletes the specified proxy session from the specified Amazon Chime SDK Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProxySessionOutcome DeleteProxySession(const Model::DeleteProxySessionRequest& request) const; /** * A Callable wrapper for DeleteProxySession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProxySessionOutcomeCallable DeleteProxySessionCallable(const DeleteProxySessionRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteProxySession, request); } /** * An Async wrapper for DeleteProxySession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProxySessionAsync(const DeleteProxySessionRequestT& request, const DeleteProxySessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteProxySession, request, handler, context); } /** *

Deletes a SIP media application.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSipMediaApplicationOutcome DeleteSipMediaApplication(const Model::DeleteSipMediaApplicationRequest& request) const; /** * A Callable wrapper for DeleteSipMediaApplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSipMediaApplicationOutcomeCallable DeleteSipMediaApplicationCallable(const DeleteSipMediaApplicationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteSipMediaApplication, request); } /** * An Async wrapper for DeleteSipMediaApplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSipMediaApplicationAsync(const DeleteSipMediaApplicationRequestT& request, const DeleteSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteSipMediaApplication, request, handler, context); } /** *

Deletes a SIP rule.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSipRuleOutcome DeleteSipRule(const Model::DeleteSipRuleRequest& request) const; /** * A Callable wrapper for DeleteSipRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSipRuleOutcomeCallable DeleteSipRuleCallable(const DeleteSipRuleRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteSipRule, request); } /** * An Async wrapper for DeleteSipRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSipRuleAsync(const DeleteSipRuleRequestT& request, const DeleteSipRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteSipRule, request, handler, context); } /** *

Deletes an Amazon Chime SDK Voice Connector. Any phone numbers associated * with the Amazon Chime SDK Voice Connector must be disassociated from it before * it can be deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVoiceConnectorOutcome DeleteVoiceConnector(const Model::DeleteVoiceConnectorRequest& request) const; /** * A Callable wrapper for DeleteVoiceConnector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceConnectorOutcomeCallable DeleteVoiceConnectorCallable(const DeleteVoiceConnectorRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceConnector, request); } /** * An Async wrapper for DeleteVoiceConnector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceConnectorAsync(const DeleteVoiceConnectorRequestT& request, const DeleteVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceConnector, request, handler, context); } /** *

Deletes the emergency calling details from the specified Amazon Chime SDK * Voice Connector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVoiceConnectorEmergencyCallingConfigurationOutcome DeleteVoiceConnectorEmergencyCallingConfiguration(const Model::DeleteVoiceConnectorEmergencyCallingConfigurationRequest& request) const; /** * A Callable wrapper for DeleteVoiceConnectorEmergencyCallingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceConnectorEmergencyCallingConfigurationOutcomeCallable DeleteVoiceConnectorEmergencyCallingConfigurationCallable(const DeleteVoiceConnectorEmergencyCallingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceConnectorEmergencyCallingConfiguration, request); } /** * An Async wrapper for DeleteVoiceConnectorEmergencyCallingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceConnectorEmergencyCallingConfigurationAsync(const DeleteVoiceConnectorEmergencyCallingConfigurationRequestT& request, const DeleteVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceConnectorEmergencyCallingConfiguration, request, handler, context); } /** *

Deletes an Amazon Chime SDK Voice Connector group. Any * VoiceConnectorItems and phone numbers associated with the group * must be removed before it can be deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVoiceConnectorGroupOutcome DeleteVoiceConnectorGroup(const Model::DeleteVoiceConnectorGroupRequest& request) const; /** * A Callable wrapper for DeleteVoiceConnectorGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceConnectorGroupOutcomeCallable DeleteVoiceConnectorGroupCallable(const DeleteVoiceConnectorGroupRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceConnectorGroup, request); } /** * An Async wrapper for DeleteVoiceConnectorGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceConnectorGroupAsync(const DeleteVoiceConnectorGroupRequestT& request, const DeleteVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceConnectorGroup, request, handler, context); } /** *

Deletes the origination settings for the specified Amazon Chime SDK Voice * Connector.

If emergency calling is configured for the Voice * Connector, it must be deleted prior to deleting the origination settings.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteVoiceConnectorOriginationOutcome DeleteVoiceConnectorOrigination(const Model::DeleteVoiceConnectorOriginationRequest& request) const; /** * A Callable wrapper for DeleteVoiceConnectorOrigination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceConnectorOriginationOutcomeCallable DeleteVoiceConnectorOriginationCallable(const DeleteVoiceConnectorOriginationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceConnectorOrigination, request); } /** * An Async wrapper for DeleteVoiceConnectorOrigination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceConnectorOriginationAsync(const DeleteVoiceConnectorOriginationRequestT& request, const DeleteVoiceConnectorOriginationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceConnectorOrigination, request, handler, context); } /** *

Deletes the proxy configuration from the specified Amazon Chime SDK Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVoiceConnectorProxyOutcome DeleteVoiceConnectorProxy(const Model::DeleteVoiceConnectorProxyRequest& request) const; /** * A Callable wrapper for DeleteVoiceConnectorProxy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceConnectorProxyOutcomeCallable DeleteVoiceConnectorProxyCallable(const DeleteVoiceConnectorProxyRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceConnectorProxy, request); } /** * An Async wrapper for DeleteVoiceConnectorProxy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceConnectorProxyAsync(const DeleteVoiceConnectorProxyRequestT& request, const DeleteVoiceConnectorProxyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceConnectorProxy, request, handler, context); } /** *

Deletes a Voice Connector's streaming configuration.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteVoiceConnectorStreamingConfigurationOutcome DeleteVoiceConnectorStreamingConfiguration(const Model::DeleteVoiceConnectorStreamingConfigurationRequest& request) const; /** * A Callable wrapper for DeleteVoiceConnectorStreamingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceConnectorStreamingConfigurationOutcomeCallable DeleteVoiceConnectorStreamingConfigurationCallable(const DeleteVoiceConnectorStreamingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceConnectorStreamingConfiguration, request); } /** * An Async wrapper for DeleteVoiceConnectorStreamingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceConnectorStreamingConfigurationAsync(const DeleteVoiceConnectorStreamingConfigurationRequestT& request, const DeleteVoiceConnectorStreamingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceConnectorStreamingConfiguration, request, handler, context); } /** *

Deletes the termination settings for the specified Amazon Chime SDK Voice * Connector.

If emergency calling is configured for the Voice * Connector, it must be deleted prior to deleting the termination settings.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteVoiceConnectorTerminationOutcome DeleteVoiceConnectorTermination(const Model::DeleteVoiceConnectorTerminationRequest& request) const; /** * A Callable wrapper for DeleteVoiceConnectorTermination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceConnectorTerminationOutcomeCallable DeleteVoiceConnectorTerminationCallable(const DeleteVoiceConnectorTerminationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceConnectorTermination, request); } /** * An Async wrapper for DeleteVoiceConnectorTermination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceConnectorTerminationAsync(const DeleteVoiceConnectorTerminationRequestT& request, const DeleteVoiceConnectorTerminationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceConnectorTermination, request, handler, context); } /** *

Deletes the specified SIP credentials used by your equipment to authenticate * during call termination.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVoiceConnectorTerminationCredentialsOutcome DeleteVoiceConnectorTerminationCredentials(const Model::DeleteVoiceConnectorTerminationCredentialsRequest& request) const; /** * A Callable wrapper for DeleteVoiceConnectorTerminationCredentials that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceConnectorTerminationCredentialsOutcomeCallable DeleteVoiceConnectorTerminationCredentialsCallable(const DeleteVoiceConnectorTerminationCredentialsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceConnectorTerminationCredentials, request); } /** * An Async wrapper for DeleteVoiceConnectorTerminationCredentials that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceConnectorTerminationCredentialsAsync(const DeleteVoiceConnectorTerminationCredentialsRequestT& request, const DeleteVoiceConnectorTerminationCredentialsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceConnectorTerminationCredentials, request, handler, context); } /** *

Deletes a voice profile, including its voice print and enrollment data. * WARNING: This action is not reversible.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVoiceProfileOutcome DeleteVoiceProfile(const Model::DeleteVoiceProfileRequest& request) const; /** * A Callable wrapper for DeleteVoiceProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceProfileOutcomeCallable DeleteVoiceProfileCallable(const DeleteVoiceProfileRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceProfile, request); } /** * An Async wrapper for DeleteVoiceProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceProfileAsync(const DeleteVoiceProfileRequestT& request, const DeleteVoiceProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceProfile, request, handler, context); } /** *

Deletes all voice profiles in the domain. WARNING: This action is not * reversible.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVoiceProfileDomainOutcome DeleteVoiceProfileDomain(const Model::DeleteVoiceProfileDomainRequest& request) const; /** * A Callable wrapper for DeleteVoiceProfileDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVoiceProfileDomainOutcomeCallable DeleteVoiceProfileDomainCallable(const DeleteVoiceProfileDomainRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DeleteVoiceProfileDomain, request); } /** * An Async wrapper for DeleteVoiceProfileDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVoiceProfileDomainAsync(const DeleteVoiceProfileDomainRequestT& request, const DeleteVoiceProfileDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DeleteVoiceProfileDomain, request, handler, context); } /** *

Disassociates the specified phone numbers from the specified Amazon Chime SDK * Voice Connector.

See Also:

AWS * API Reference

*/ virtual Model::DisassociatePhoneNumbersFromVoiceConnectorOutcome DisassociatePhoneNumbersFromVoiceConnector(const Model::DisassociatePhoneNumbersFromVoiceConnectorRequest& request) const; /** * A Callable wrapper for DisassociatePhoneNumbersFromVoiceConnector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociatePhoneNumbersFromVoiceConnectorOutcomeCallable DisassociatePhoneNumbersFromVoiceConnectorCallable(const DisassociatePhoneNumbersFromVoiceConnectorRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DisassociatePhoneNumbersFromVoiceConnector, request); } /** * An Async wrapper for DisassociatePhoneNumbersFromVoiceConnector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociatePhoneNumbersFromVoiceConnectorAsync(const DisassociatePhoneNumbersFromVoiceConnectorRequestT& request, const DisassociatePhoneNumbersFromVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DisassociatePhoneNumbersFromVoiceConnector, request, handler, context); } /** *

Disassociates the specified phone numbers from the specified Amazon Chime SDK * Voice Connector group.

See Also:

AWS * API Reference

*/ virtual Model::DisassociatePhoneNumbersFromVoiceConnectorGroupOutcome DisassociatePhoneNumbersFromVoiceConnectorGroup(const Model::DisassociatePhoneNumbersFromVoiceConnectorGroupRequest& request) const; /** * A Callable wrapper for DisassociatePhoneNumbersFromVoiceConnectorGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociatePhoneNumbersFromVoiceConnectorGroupOutcomeCallable DisassociatePhoneNumbersFromVoiceConnectorGroupCallable(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::DisassociatePhoneNumbersFromVoiceConnectorGroup, request); } /** * An Async wrapper for DisassociatePhoneNumbersFromVoiceConnectorGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociatePhoneNumbersFromVoiceConnectorGroupAsync(const DisassociatePhoneNumbersFromVoiceConnectorGroupRequestT& request, const DisassociatePhoneNumbersFromVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::DisassociatePhoneNumbersFromVoiceConnectorGroup, request, handler, context); } /** *

Retrieves the global settings for the Amazon Chime SDK Voice Connectors in an * AWS account.

See Also:

AWS * API Reference

*/ virtual Model::GetGlobalSettingsOutcome GetGlobalSettings() const; /** * A Callable wrapper for GetGlobalSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetGlobalSettingsOutcomeCallable GetGlobalSettingsCallable() const { return SubmitCallable(&ChimeSDKVoiceClient::GetGlobalSettings); } /** * An Async wrapper for GetGlobalSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetGlobalSettingsAsync(const GetGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetGlobalSettings, handler, context); } /** *

Retrieves details for the specified phone number ID, such as associations, * capabilities, and product type.

See Also:

AWS * API Reference

*/ virtual Model::GetPhoneNumberOutcome GetPhoneNumber(const Model::GetPhoneNumberRequest& request) const; /** * A Callable wrapper for GetPhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPhoneNumberOutcomeCallable GetPhoneNumberCallable(const GetPhoneNumberRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetPhoneNumber, request); } /** * An Async wrapper for GetPhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPhoneNumberAsync(const GetPhoneNumberRequestT& request, const GetPhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetPhoneNumber, request, handler, context); } /** *

Retrieves details for the specified phone number order, such as the order * creation timestamp, phone numbers in E.164 format, product type, and order * status.

See Also:

AWS * API Reference

*/ virtual Model::GetPhoneNumberOrderOutcome GetPhoneNumberOrder(const Model::GetPhoneNumberOrderRequest& request) const; /** * A Callable wrapper for GetPhoneNumberOrder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPhoneNumberOrderOutcomeCallable GetPhoneNumberOrderCallable(const GetPhoneNumberOrderRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetPhoneNumberOrder, request); } /** * An Async wrapper for GetPhoneNumberOrder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPhoneNumberOrderAsync(const GetPhoneNumberOrderRequestT& request, const GetPhoneNumberOrderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetPhoneNumberOrder, request, handler, context); } /** *

Retrieves the phone number settings for the administrator's AWS account, such * as the default outbound calling name.

See Also:

AWS * API Reference

*/ virtual Model::GetPhoneNumberSettingsOutcome GetPhoneNumberSettings() const; /** * A Callable wrapper for GetPhoneNumberSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPhoneNumberSettingsOutcomeCallable GetPhoneNumberSettingsCallable() const { return SubmitCallable(&ChimeSDKVoiceClient::GetPhoneNumberSettings); } /** * An Async wrapper for GetPhoneNumberSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPhoneNumberSettingsAsync(const GetPhoneNumberSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetPhoneNumberSettings, handler, context); } /** *

Retrieves the specified proxy session details for the specified Amazon Chime * SDK Voice Connector.

See Also:

AWS * API Reference

*/ virtual Model::GetProxySessionOutcome GetProxySession(const Model::GetProxySessionRequest& request) const; /** * A Callable wrapper for GetProxySession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetProxySessionOutcomeCallable GetProxySessionCallable(const GetProxySessionRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetProxySession, request); } /** * An Async wrapper for GetProxySession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetProxySessionAsync(const GetProxySessionRequestT& request, const GetProxySessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetProxySession, request, handler, context); } /** *

Retrieves the information for a SIP media application, including name, AWS * Region, and endpoints.

See Also:

AWS * API Reference

*/ virtual Model::GetSipMediaApplicationOutcome GetSipMediaApplication(const Model::GetSipMediaApplicationRequest& request) const; /** * A Callable wrapper for GetSipMediaApplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSipMediaApplicationOutcomeCallable GetSipMediaApplicationCallable(const GetSipMediaApplicationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetSipMediaApplication, request); } /** * An Async wrapper for GetSipMediaApplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSipMediaApplicationAsync(const GetSipMediaApplicationRequestT& request, const GetSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetSipMediaApplication, request, handler, context); } /** *

Gets the Alexa Skill configuration for the SIP media * application.

See Also:

AWS * API Reference

*/ virtual Model::GetSipMediaApplicationAlexaSkillConfigurationOutcome GetSipMediaApplicationAlexaSkillConfiguration(const Model::GetSipMediaApplicationAlexaSkillConfigurationRequest& request) const; /** * A Callable wrapper for GetSipMediaApplicationAlexaSkillConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSipMediaApplicationAlexaSkillConfigurationOutcomeCallable GetSipMediaApplicationAlexaSkillConfigurationCallable(const GetSipMediaApplicationAlexaSkillConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetSipMediaApplicationAlexaSkillConfiguration, request); } /** * An Async wrapper for GetSipMediaApplicationAlexaSkillConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSipMediaApplicationAlexaSkillConfigurationAsync(const GetSipMediaApplicationAlexaSkillConfigurationRequestT& request, const GetSipMediaApplicationAlexaSkillConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetSipMediaApplicationAlexaSkillConfiguration, request, handler, context); } /** *

Retrieves the logging configuration for the specified SIP media * application.

See Also:

AWS * API Reference

*/ virtual Model::GetSipMediaApplicationLoggingConfigurationOutcome GetSipMediaApplicationLoggingConfiguration(const Model::GetSipMediaApplicationLoggingConfigurationRequest& request) const; /** * A Callable wrapper for GetSipMediaApplicationLoggingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSipMediaApplicationLoggingConfigurationOutcomeCallable GetSipMediaApplicationLoggingConfigurationCallable(const GetSipMediaApplicationLoggingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetSipMediaApplicationLoggingConfiguration, request); } /** * An Async wrapper for GetSipMediaApplicationLoggingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSipMediaApplicationLoggingConfigurationAsync(const GetSipMediaApplicationLoggingConfigurationRequestT& request, const GetSipMediaApplicationLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetSipMediaApplicationLoggingConfiguration, request, handler, context); } /** *

Retrieves the details of a SIP rule, such as the rule ID, name, triggers, and * target endpoints.

See Also:

AWS * API Reference

*/ virtual Model::GetSipRuleOutcome GetSipRule(const Model::GetSipRuleRequest& request) const; /** * A Callable wrapper for GetSipRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSipRuleOutcomeCallable GetSipRuleCallable(const GetSipRuleRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetSipRule, request); } /** * An Async wrapper for GetSipRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSipRuleAsync(const GetSipRuleRequestT& request, const GetSipRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetSipRule, request, handler, context); } /** *

Retrieves the details of the specified speaker search task.

See * Also:

AWS * API Reference

*/ virtual Model::GetSpeakerSearchTaskOutcome GetSpeakerSearchTask(const Model::GetSpeakerSearchTaskRequest& request) const; /** * A Callable wrapper for GetSpeakerSearchTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSpeakerSearchTaskOutcomeCallable GetSpeakerSearchTaskCallable(const GetSpeakerSearchTaskRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetSpeakerSearchTask, request); } /** * An Async wrapper for GetSpeakerSearchTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSpeakerSearchTaskAsync(const GetSpeakerSearchTaskRequestT& request, const GetSpeakerSearchTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetSpeakerSearchTask, request, handler, context); } /** *

Retrieves details for the specified Amazon Chime SDK Voice Connector, such as * timestamps,name, outbound host, and encryption requirements.

See * Also:

AWS * API Reference

*/ virtual Model::GetVoiceConnectorOutcome GetVoiceConnector(const Model::GetVoiceConnectorRequest& request) const; /** * A Callable wrapper for GetVoiceConnector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceConnectorOutcomeCallable GetVoiceConnectorCallable(const GetVoiceConnectorRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceConnector, request); } /** * An Async wrapper for GetVoiceConnector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceConnectorAsync(const GetVoiceConnectorRequestT& request, const GetVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceConnector, request, handler, context); } /** *

Retrieves the emergency calling configuration details for the specified Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::GetVoiceConnectorEmergencyCallingConfigurationOutcome GetVoiceConnectorEmergencyCallingConfiguration(const Model::GetVoiceConnectorEmergencyCallingConfigurationRequest& request) const; /** * A Callable wrapper for GetVoiceConnectorEmergencyCallingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceConnectorEmergencyCallingConfigurationOutcomeCallable GetVoiceConnectorEmergencyCallingConfigurationCallable(const GetVoiceConnectorEmergencyCallingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceConnectorEmergencyCallingConfiguration, request); } /** * An Async wrapper for GetVoiceConnectorEmergencyCallingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceConnectorEmergencyCallingConfigurationAsync(const GetVoiceConnectorEmergencyCallingConfigurationRequestT& request, const GetVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceConnectorEmergencyCallingConfiguration, request, handler, context); } /** *

Retrieves details for the specified Amazon Chime SDK Voice Connector group, * such as timestamps,name, and associated * VoiceConnectorItems.

See Also:

AWS * API Reference

*/ virtual Model::GetVoiceConnectorGroupOutcome GetVoiceConnectorGroup(const Model::GetVoiceConnectorGroupRequest& request) const; /** * A Callable wrapper for GetVoiceConnectorGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceConnectorGroupOutcomeCallable GetVoiceConnectorGroupCallable(const GetVoiceConnectorGroupRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceConnectorGroup, request); } /** * An Async wrapper for GetVoiceConnectorGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceConnectorGroupAsync(const GetVoiceConnectorGroupRequestT& request, const GetVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceConnectorGroup, request, handler, context); } /** *

Retrieves the logging configuration settings for the specified Voice * Connector. Shows whether SIP message logs are enabled for sending to Amazon * CloudWatch Logs.

See Also:

AWS * API Reference

*/ virtual Model::GetVoiceConnectorLoggingConfigurationOutcome GetVoiceConnectorLoggingConfiguration(const Model::GetVoiceConnectorLoggingConfigurationRequest& request) const; /** * A Callable wrapper for GetVoiceConnectorLoggingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceConnectorLoggingConfigurationOutcomeCallable GetVoiceConnectorLoggingConfigurationCallable(const GetVoiceConnectorLoggingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceConnectorLoggingConfiguration, request); } /** * An Async wrapper for GetVoiceConnectorLoggingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceConnectorLoggingConfigurationAsync(const GetVoiceConnectorLoggingConfigurationRequestT& request, const GetVoiceConnectorLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceConnectorLoggingConfiguration, request, handler, context); } /** *

Retrieves the origination settings for the specified Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::GetVoiceConnectorOriginationOutcome GetVoiceConnectorOrigination(const Model::GetVoiceConnectorOriginationRequest& request) const; /** * A Callable wrapper for GetVoiceConnectorOrigination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceConnectorOriginationOutcomeCallable GetVoiceConnectorOriginationCallable(const GetVoiceConnectorOriginationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceConnectorOrigination, request); } /** * An Async wrapper for GetVoiceConnectorOrigination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceConnectorOriginationAsync(const GetVoiceConnectorOriginationRequestT& request, const GetVoiceConnectorOriginationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceConnectorOrigination, request, handler, context); } /** *

Retrieves the proxy configuration details for the specified Amazon Chime SDK * Voice Connector.

See Also:

AWS * API Reference

*/ virtual Model::GetVoiceConnectorProxyOutcome GetVoiceConnectorProxy(const Model::GetVoiceConnectorProxyRequest& request) const; /** * A Callable wrapper for GetVoiceConnectorProxy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceConnectorProxyOutcomeCallable GetVoiceConnectorProxyCallable(const GetVoiceConnectorProxyRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceConnectorProxy, request); } /** * An Async wrapper for GetVoiceConnectorProxy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceConnectorProxyAsync(const GetVoiceConnectorProxyRequestT& request, const GetVoiceConnectorProxyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceConnectorProxy, request, handler, context); } /** *

Retrieves the streaming configuration details for the specified Amazon Chime * SDK Voice Connector. Shows whether media streaming is enabled for sending to * Amazon Kinesis. It also shows the retention period, in hours, for the Amazon * Kinesis data.

See Also:

AWS * API Reference

*/ virtual Model::GetVoiceConnectorStreamingConfigurationOutcome GetVoiceConnectorStreamingConfiguration(const Model::GetVoiceConnectorStreamingConfigurationRequest& request) const; /** * A Callable wrapper for GetVoiceConnectorStreamingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceConnectorStreamingConfigurationOutcomeCallable GetVoiceConnectorStreamingConfigurationCallable(const GetVoiceConnectorStreamingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceConnectorStreamingConfiguration, request); } /** * An Async wrapper for GetVoiceConnectorStreamingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceConnectorStreamingConfigurationAsync(const GetVoiceConnectorStreamingConfigurationRequestT& request, const GetVoiceConnectorStreamingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceConnectorStreamingConfiguration, request, handler, context); } /** *

Retrieves the termination setting details for the specified Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::GetVoiceConnectorTerminationOutcome GetVoiceConnectorTermination(const Model::GetVoiceConnectorTerminationRequest& request) const; /** * A Callable wrapper for GetVoiceConnectorTermination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceConnectorTerminationOutcomeCallable GetVoiceConnectorTerminationCallable(const GetVoiceConnectorTerminationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceConnectorTermination, request); } /** * An Async wrapper for GetVoiceConnectorTermination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceConnectorTerminationAsync(const GetVoiceConnectorTerminationRequestT& request, const GetVoiceConnectorTerminationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceConnectorTermination, request, handler, context); } /** *

Retrieves information about the last time a SIP OPTIONS ping was * received from your SIP infrastructure for the specified Amazon Chime SDK Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::GetVoiceConnectorTerminationHealthOutcome GetVoiceConnectorTerminationHealth(const Model::GetVoiceConnectorTerminationHealthRequest& request) const; /** * A Callable wrapper for GetVoiceConnectorTerminationHealth that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceConnectorTerminationHealthOutcomeCallable GetVoiceConnectorTerminationHealthCallable(const GetVoiceConnectorTerminationHealthRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceConnectorTerminationHealth, request); } /** * An Async wrapper for GetVoiceConnectorTerminationHealth that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceConnectorTerminationHealthAsync(const GetVoiceConnectorTerminationHealthRequestT& request, const GetVoiceConnectorTerminationHealthResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceConnectorTerminationHealth, request, handler, context); } /** *

Retrieves the details of the specified voice profile.

See * Also:

AWS * API Reference

*/ virtual Model::GetVoiceProfileOutcome GetVoiceProfile(const Model::GetVoiceProfileRequest& request) const; /** * A Callable wrapper for GetVoiceProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceProfileOutcomeCallable GetVoiceProfileCallable(const GetVoiceProfileRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceProfile, request); } /** * An Async wrapper for GetVoiceProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceProfileAsync(const GetVoiceProfileRequestT& request, const GetVoiceProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceProfile, request, handler, context); } /** *

Retrieves the details of the specified voice profile domain.

See * Also:

AWS * API Reference

*/ virtual Model::GetVoiceProfileDomainOutcome GetVoiceProfileDomain(const Model::GetVoiceProfileDomainRequest& request) const; /** * A Callable wrapper for GetVoiceProfileDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceProfileDomainOutcomeCallable GetVoiceProfileDomainCallable(const GetVoiceProfileDomainRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceProfileDomain, request); } /** * An Async wrapper for GetVoiceProfileDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceProfileDomainAsync(const GetVoiceProfileDomainRequestT& request, const GetVoiceProfileDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceProfileDomain, request, handler, context); } /** *

Retrieves the details of a voice tone analysis task.

See Also:

* AWS * API Reference

*/ virtual Model::GetVoiceToneAnalysisTaskOutcome GetVoiceToneAnalysisTask(const Model::GetVoiceToneAnalysisTaskRequest& request) const; /** * A Callable wrapper for GetVoiceToneAnalysisTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetVoiceToneAnalysisTaskOutcomeCallable GetVoiceToneAnalysisTaskCallable(const GetVoiceToneAnalysisTaskRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::GetVoiceToneAnalysisTask, request); } /** * An Async wrapper for GetVoiceToneAnalysisTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetVoiceToneAnalysisTaskAsync(const GetVoiceToneAnalysisTaskRequestT& request, const GetVoiceToneAnalysisTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::GetVoiceToneAnalysisTask, request, handler, context); } /** *

Lists the available AWS Regions in which you can create an Amazon Chime SDK * Voice Connector.

See Also:

AWS * API Reference

*/ virtual Model::ListAvailableVoiceConnectorRegionsOutcome ListAvailableVoiceConnectorRegions() const; /** * A Callable wrapper for ListAvailableVoiceConnectorRegions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAvailableVoiceConnectorRegionsOutcomeCallable ListAvailableVoiceConnectorRegionsCallable() const { return SubmitCallable(&ChimeSDKVoiceClient::ListAvailableVoiceConnectorRegions); } /** * An Async wrapper for ListAvailableVoiceConnectorRegions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAvailableVoiceConnectorRegionsAsync(const ListAvailableVoiceConnectorRegionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListAvailableVoiceConnectorRegions, handler, context); } /** *

Lists the phone numbers for an administrator's Amazon Chime SDK * account.

See Also:

AWS * API Reference

*/ virtual Model::ListPhoneNumberOrdersOutcome ListPhoneNumberOrders(const Model::ListPhoneNumberOrdersRequest& request) const; /** * A Callable wrapper for ListPhoneNumberOrders that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPhoneNumberOrdersOutcomeCallable ListPhoneNumberOrdersCallable(const ListPhoneNumberOrdersRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListPhoneNumberOrders, request); } /** * An Async wrapper for ListPhoneNumberOrders that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPhoneNumberOrdersAsync(const ListPhoneNumberOrdersRequestT& request, const ListPhoneNumberOrdersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListPhoneNumberOrders, request, handler, context); } /** *

Lists the phone numbers for the specified Amazon Chime SDK account, Amazon * Chime SDK user, Amazon Chime SDK Voice Connector, or Amazon Chime SDK Voice * Connector group.

See Also:

AWS * API Reference

*/ virtual Model::ListPhoneNumbersOutcome ListPhoneNumbers(const Model::ListPhoneNumbersRequest& request) const; /** * A Callable wrapper for ListPhoneNumbers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPhoneNumbersOutcomeCallable ListPhoneNumbersCallable(const ListPhoneNumbersRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListPhoneNumbers, request); } /** * An Async wrapper for ListPhoneNumbers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPhoneNumbersAsync(const ListPhoneNumbersRequestT& request, const ListPhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListPhoneNumbers, request, handler, context); } /** *

Lists the proxy sessions for the specified Amazon Chime SDK Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::ListProxySessionsOutcome ListProxySessions(const Model::ListProxySessionsRequest& request) const; /** * A Callable wrapper for ListProxySessions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProxySessionsOutcomeCallable ListProxySessionsCallable(const ListProxySessionsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListProxySessions, request); } /** * An Async wrapper for ListProxySessions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProxySessionsAsync(const ListProxySessionsRequestT& request, const ListProxySessionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListProxySessions, request, handler, context); } /** *

Lists the SIP media applications under the administrator's AWS * account.

See Also:

AWS * API Reference

*/ virtual Model::ListSipMediaApplicationsOutcome ListSipMediaApplications(const Model::ListSipMediaApplicationsRequest& request) const; /** * A Callable wrapper for ListSipMediaApplications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSipMediaApplicationsOutcomeCallable ListSipMediaApplicationsCallable(const ListSipMediaApplicationsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListSipMediaApplications, request); } /** * An Async wrapper for ListSipMediaApplications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSipMediaApplicationsAsync(const ListSipMediaApplicationsRequestT& request, const ListSipMediaApplicationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListSipMediaApplications, request, handler, context); } /** *

Lists the SIP rules under the administrator's AWS account.

See * Also:

AWS * API Reference

*/ virtual Model::ListSipRulesOutcome ListSipRules(const Model::ListSipRulesRequest& request) const; /** * A Callable wrapper for ListSipRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSipRulesOutcomeCallable ListSipRulesCallable(const ListSipRulesRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListSipRules, request); } /** * An Async wrapper for ListSipRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSipRulesAsync(const ListSipRulesRequestT& request, const ListSipRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListSipRules, request, handler, context); } /** *

Lists the countries that you can order phone numbers from.

See * Also:

AWS * API Reference

*/ virtual Model::ListSupportedPhoneNumberCountriesOutcome ListSupportedPhoneNumberCountries(const Model::ListSupportedPhoneNumberCountriesRequest& request) const; /** * A Callable wrapper for ListSupportedPhoneNumberCountries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSupportedPhoneNumberCountriesOutcomeCallable ListSupportedPhoneNumberCountriesCallable(const ListSupportedPhoneNumberCountriesRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListSupportedPhoneNumberCountries, request); } /** * An Async wrapper for ListSupportedPhoneNumberCountries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSupportedPhoneNumberCountriesAsync(const ListSupportedPhoneNumberCountriesRequestT& request, const ListSupportedPhoneNumberCountriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListSupportedPhoneNumberCountries, request, handler, context); } /** *

Returns a list of the tags in a given 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(&ChimeSDKVoiceClient::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(&ChimeSDKVoiceClient::ListTagsForResource, request, handler, context); } /** *

Lists the Amazon Chime SDK Voice Connector groups in the administrator's AWS * account.

See Also:

AWS * API Reference

*/ virtual Model::ListVoiceConnectorGroupsOutcome ListVoiceConnectorGroups(const Model::ListVoiceConnectorGroupsRequest& request) const; /** * A Callable wrapper for ListVoiceConnectorGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListVoiceConnectorGroupsOutcomeCallable ListVoiceConnectorGroupsCallable(const ListVoiceConnectorGroupsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListVoiceConnectorGroups, request); } /** * An Async wrapper for ListVoiceConnectorGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListVoiceConnectorGroupsAsync(const ListVoiceConnectorGroupsRequestT& request, const ListVoiceConnectorGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListVoiceConnectorGroups, request, handler, context); } /** *

Lists the SIP credentials for the specified Amazon Chime SDK Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::ListVoiceConnectorTerminationCredentialsOutcome ListVoiceConnectorTerminationCredentials(const Model::ListVoiceConnectorTerminationCredentialsRequest& request) const; /** * A Callable wrapper for ListVoiceConnectorTerminationCredentials that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListVoiceConnectorTerminationCredentialsOutcomeCallable ListVoiceConnectorTerminationCredentialsCallable(const ListVoiceConnectorTerminationCredentialsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListVoiceConnectorTerminationCredentials, request); } /** * An Async wrapper for ListVoiceConnectorTerminationCredentials that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListVoiceConnectorTerminationCredentialsAsync(const ListVoiceConnectorTerminationCredentialsRequestT& request, const ListVoiceConnectorTerminationCredentialsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListVoiceConnectorTerminationCredentials, request, handler, context); } /** *

Lists the Amazon Chime SDK Voice Connectors in the administrators AWS * account.

See Also:

AWS * API Reference

*/ virtual Model::ListVoiceConnectorsOutcome ListVoiceConnectors(const Model::ListVoiceConnectorsRequest& request) const; /** * A Callable wrapper for ListVoiceConnectors that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListVoiceConnectorsOutcomeCallable ListVoiceConnectorsCallable(const ListVoiceConnectorsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListVoiceConnectors, request); } /** * An Async wrapper for ListVoiceConnectors that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListVoiceConnectorsAsync(const ListVoiceConnectorsRequestT& request, const ListVoiceConnectorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListVoiceConnectors, request, handler, context); } /** *

Lists the specified voice profile domains in the administrator's AWS account. *

See Also:

AWS * API Reference

*/ virtual Model::ListVoiceProfileDomainsOutcome ListVoiceProfileDomains(const Model::ListVoiceProfileDomainsRequest& request) const; /** * A Callable wrapper for ListVoiceProfileDomains that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListVoiceProfileDomainsOutcomeCallable ListVoiceProfileDomainsCallable(const ListVoiceProfileDomainsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListVoiceProfileDomains, request); } /** * An Async wrapper for ListVoiceProfileDomains that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListVoiceProfileDomainsAsync(const ListVoiceProfileDomainsRequestT& request, const ListVoiceProfileDomainsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListVoiceProfileDomains, request, handler, context); } /** *

Lists the voice profiles in a voice profile domain.

See Also:

* AWS * API Reference

*/ virtual Model::ListVoiceProfilesOutcome ListVoiceProfiles(const Model::ListVoiceProfilesRequest& request) const; /** * A Callable wrapper for ListVoiceProfiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListVoiceProfilesOutcomeCallable ListVoiceProfilesCallable(const ListVoiceProfilesRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ListVoiceProfiles, request); } /** * An Async wrapper for ListVoiceProfiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListVoiceProfilesAsync(const ListVoiceProfilesRequestT& request, const ListVoiceProfilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ListVoiceProfiles, request, handler, context); } /** *

Updates the Alexa Skill configuration for the SIP media * application.

See Also:

AWS * API Reference

*/ virtual Model::PutSipMediaApplicationAlexaSkillConfigurationOutcome PutSipMediaApplicationAlexaSkillConfiguration(const Model::PutSipMediaApplicationAlexaSkillConfigurationRequest& request) const; /** * A Callable wrapper for PutSipMediaApplicationAlexaSkillConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutSipMediaApplicationAlexaSkillConfigurationOutcomeCallable PutSipMediaApplicationAlexaSkillConfigurationCallable(const PutSipMediaApplicationAlexaSkillConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::PutSipMediaApplicationAlexaSkillConfiguration, request); } /** * An Async wrapper for PutSipMediaApplicationAlexaSkillConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutSipMediaApplicationAlexaSkillConfigurationAsync(const PutSipMediaApplicationAlexaSkillConfigurationRequestT& request, const PutSipMediaApplicationAlexaSkillConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::PutSipMediaApplicationAlexaSkillConfiguration, request, handler, context); } /** *

Updates the logging configuration for the specified SIP media * application.

See Also:

AWS * API Reference

*/ virtual Model::PutSipMediaApplicationLoggingConfigurationOutcome PutSipMediaApplicationLoggingConfiguration(const Model::PutSipMediaApplicationLoggingConfigurationRequest& request) const; /** * A Callable wrapper for PutSipMediaApplicationLoggingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutSipMediaApplicationLoggingConfigurationOutcomeCallable PutSipMediaApplicationLoggingConfigurationCallable(const PutSipMediaApplicationLoggingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::PutSipMediaApplicationLoggingConfiguration, request); } /** * An Async wrapper for PutSipMediaApplicationLoggingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutSipMediaApplicationLoggingConfigurationAsync(const PutSipMediaApplicationLoggingConfigurationRequestT& request, const PutSipMediaApplicationLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::PutSipMediaApplicationLoggingConfiguration, request, handler, context); } /** *

Updates a Voice Connector's emergency calling configuration.

See * Also:

AWS * API Reference

*/ virtual Model::PutVoiceConnectorEmergencyCallingConfigurationOutcome PutVoiceConnectorEmergencyCallingConfiguration(const Model::PutVoiceConnectorEmergencyCallingConfigurationRequest& request) const; /** * A Callable wrapper for PutVoiceConnectorEmergencyCallingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutVoiceConnectorEmergencyCallingConfigurationOutcomeCallable PutVoiceConnectorEmergencyCallingConfigurationCallable(const PutVoiceConnectorEmergencyCallingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::PutVoiceConnectorEmergencyCallingConfiguration, request); } /** * An Async wrapper for PutVoiceConnectorEmergencyCallingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutVoiceConnectorEmergencyCallingConfigurationAsync(const PutVoiceConnectorEmergencyCallingConfigurationRequestT& request, const PutVoiceConnectorEmergencyCallingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::PutVoiceConnectorEmergencyCallingConfiguration, request, handler, context); } /** *

Updates a Voice Connector's logging configuration.

See Also:

* AWS * API Reference

*/ virtual Model::PutVoiceConnectorLoggingConfigurationOutcome PutVoiceConnectorLoggingConfiguration(const Model::PutVoiceConnectorLoggingConfigurationRequest& request) const; /** * A Callable wrapper for PutVoiceConnectorLoggingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutVoiceConnectorLoggingConfigurationOutcomeCallable PutVoiceConnectorLoggingConfigurationCallable(const PutVoiceConnectorLoggingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::PutVoiceConnectorLoggingConfiguration, request); } /** * An Async wrapper for PutVoiceConnectorLoggingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutVoiceConnectorLoggingConfigurationAsync(const PutVoiceConnectorLoggingConfigurationRequestT& request, const PutVoiceConnectorLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::PutVoiceConnectorLoggingConfiguration, request, handler, context); } /** *

Updates a Voice Connector's origination settings.

See Also:

* AWS * API Reference

*/ virtual Model::PutVoiceConnectorOriginationOutcome PutVoiceConnectorOrigination(const Model::PutVoiceConnectorOriginationRequest& request) const; /** * A Callable wrapper for PutVoiceConnectorOrigination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutVoiceConnectorOriginationOutcomeCallable PutVoiceConnectorOriginationCallable(const PutVoiceConnectorOriginationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::PutVoiceConnectorOrigination, request); } /** * An Async wrapper for PutVoiceConnectorOrigination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutVoiceConnectorOriginationAsync(const PutVoiceConnectorOriginationRequestT& request, const PutVoiceConnectorOriginationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::PutVoiceConnectorOrigination, request, handler, context); } /** *

Puts the specified proxy configuration to the specified Amazon Chime SDK * Voice Connector.

See Also:

AWS * API Reference

*/ virtual Model::PutVoiceConnectorProxyOutcome PutVoiceConnectorProxy(const Model::PutVoiceConnectorProxyRequest& request) const; /** * A Callable wrapper for PutVoiceConnectorProxy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutVoiceConnectorProxyOutcomeCallable PutVoiceConnectorProxyCallable(const PutVoiceConnectorProxyRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::PutVoiceConnectorProxy, request); } /** * An Async wrapper for PutVoiceConnectorProxy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutVoiceConnectorProxyAsync(const PutVoiceConnectorProxyRequestT& request, const PutVoiceConnectorProxyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::PutVoiceConnectorProxy, request, handler, context); } /** *

Updates a Voice Connector's streaming configuration settings.

See * Also:

AWS * API Reference

*/ virtual Model::PutVoiceConnectorStreamingConfigurationOutcome PutVoiceConnectorStreamingConfiguration(const Model::PutVoiceConnectorStreamingConfigurationRequest& request) const; /** * A Callable wrapper for PutVoiceConnectorStreamingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutVoiceConnectorStreamingConfigurationOutcomeCallable PutVoiceConnectorStreamingConfigurationCallable(const PutVoiceConnectorStreamingConfigurationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::PutVoiceConnectorStreamingConfiguration, request); } /** * An Async wrapper for PutVoiceConnectorStreamingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutVoiceConnectorStreamingConfigurationAsync(const PutVoiceConnectorStreamingConfigurationRequestT& request, const PutVoiceConnectorStreamingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::PutVoiceConnectorStreamingConfiguration, request, handler, context); } /** *

Updates a Voice Connector's termination settings.

See Also:

* AWS * API Reference

*/ virtual Model::PutVoiceConnectorTerminationOutcome PutVoiceConnectorTermination(const Model::PutVoiceConnectorTerminationRequest& request) const; /** * A Callable wrapper for PutVoiceConnectorTermination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutVoiceConnectorTerminationOutcomeCallable PutVoiceConnectorTerminationCallable(const PutVoiceConnectorTerminationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::PutVoiceConnectorTermination, request); } /** * An Async wrapper for PutVoiceConnectorTermination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutVoiceConnectorTerminationAsync(const PutVoiceConnectorTerminationRequestT& request, const PutVoiceConnectorTerminationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::PutVoiceConnectorTermination, request, handler, context); } /** *

Updates a Voice Connector's termination credentials.

See Also:

* AWS * API Reference

*/ virtual Model::PutVoiceConnectorTerminationCredentialsOutcome PutVoiceConnectorTerminationCredentials(const Model::PutVoiceConnectorTerminationCredentialsRequest& request) const; /** * A Callable wrapper for PutVoiceConnectorTerminationCredentials that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutVoiceConnectorTerminationCredentialsOutcomeCallable PutVoiceConnectorTerminationCredentialsCallable(const PutVoiceConnectorTerminationCredentialsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::PutVoiceConnectorTerminationCredentials, request); } /** * An Async wrapper for PutVoiceConnectorTerminationCredentials that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutVoiceConnectorTerminationCredentialsAsync(const PutVoiceConnectorTerminationCredentialsRequestT& request, const PutVoiceConnectorTerminationCredentialsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::PutVoiceConnectorTerminationCredentials, request, handler, context); } /** *

Restores a deleted phone number.

See Also:

AWS * API Reference

*/ virtual Model::RestorePhoneNumberOutcome RestorePhoneNumber(const Model::RestorePhoneNumberRequest& request) const; /** * A Callable wrapper for RestorePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestorePhoneNumberOutcomeCallable RestorePhoneNumberCallable(const RestorePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::RestorePhoneNumber, request); } /** * An Async wrapper for RestorePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestorePhoneNumberAsync(const RestorePhoneNumberRequestT& request, const RestorePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::RestorePhoneNumber, request, handler, context); } /** *

Searches the provisioned phone numbers in an organization.

See * Also:

AWS * API Reference

*/ virtual Model::SearchAvailablePhoneNumbersOutcome SearchAvailablePhoneNumbers(const Model::SearchAvailablePhoneNumbersRequest& request) const; /** * A Callable wrapper for SearchAvailablePhoneNumbers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchAvailablePhoneNumbersOutcomeCallable SearchAvailablePhoneNumbersCallable(const SearchAvailablePhoneNumbersRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::SearchAvailablePhoneNumbers, request); } /** * An Async wrapper for SearchAvailablePhoneNumbers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchAvailablePhoneNumbersAsync(const SearchAvailablePhoneNumbersRequestT& request, const SearchAvailablePhoneNumbersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::SearchAvailablePhoneNumbers, request, handler, context); } /** *

Starts a speaker search task.

Before starting any speaker * search tasks, you must provide all notices and obtain all consents from the * speaker as required under applicable privacy and biometrics laws, and as * required under the AWS service * terms for the Amazon Chime SDK.

See Also:

AWS * API Reference

*/ virtual Model::StartSpeakerSearchTaskOutcome StartSpeakerSearchTask(const Model::StartSpeakerSearchTaskRequest& request) const; /** * A Callable wrapper for StartSpeakerSearchTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartSpeakerSearchTaskOutcomeCallable StartSpeakerSearchTaskCallable(const StartSpeakerSearchTaskRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::StartSpeakerSearchTask, request); } /** * An Async wrapper for StartSpeakerSearchTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartSpeakerSearchTaskAsync(const StartSpeakerSearchTaskRequestT& request, const StartSpeakerSearchTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::StartSpeakerSearchTask, request, handler, context); } /** *

Starts a voice tone analysis task. For more information about voice tone * analysis, see Using * Amazon Chime SDK voice analytics in the Amazon Chime SDK Developer * Guide.

Before starting any voice tone analysis tasks, you * must provide all notices and obtain all consents from the speaker as required * under applicable privacy and biometrics laws, and as required under the AWS service terms for the * Amazon Chime SDK.

See Also:

AWS * API Reference

*/ virtual Model::StartVoiceToneAnalysisTaskOutcome StartVoiceToneAnalysisTask(const Model::StartVoiceToneAnalysisTaskRequest& request) const; /** * A Callable wrapper for StartVoiceToneAnalysisTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartVoiceToneAnalysisTaskOutcomeCallable StartVoiceToneAnalysisTaskCallable(const StartVoiceToneAnalysisTaskRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::StartVoiceToneAnalysisTask, request); } /** * An Async wrapper for StartVoiceToneAnalysisTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartVoiceToneAnalysisTaskAsync(const StartVoiceToneAnalysisTaskRequestT& request, const StartVoiceToneAnalysisTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::StartVoiceToneAnalysisTask, request, handler, context); } /** *

Stops a speaker search task.

See Also:

AWS * API Reference

*/ virtual Model::StopSpeakerSearchTaskOutcome StopSpeakerSearchTask(const Model::StopSpeakerSearchTaskRequest& request) const; /** * A Callable wrapper for StopSpeakerSearchTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopSpeakerSearchTaskOutcomeCallable StopSpeakerSearchTaskCallable(const StopSpeakerSearchTaskRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::StopSpeakerSearchTask, request); } /** * An Async wrapper for StopSpeakerSearchTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopSpeakerSearchTaskAsync(const StopSpeakerSearchTaskRequestT& request, const StopSpeakerSearchTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::StopSpeakerSearchTask, request, handler, context); } /** *

Stops a voice tone analysis task.

See Also:

AWS * API Reference

*/ virtual Model::StopVoiceToneAnalysisTaskOutcome StopVoiceToneAnalysisTask(const Model::StopVoiceToneAnalysisTaskRequest& request) const; /** * A Callable wrapper for StopVoiceToneAnalysisTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopVoiceToneAnalysisTaskOutcomeCallable StopVoiceToneAnalysisTaskCallable(const StopVoiceToneAnalysisTaskRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::StopVoiceToneAnalysisTask, request); } /** * An Async wrapper for StopVoiceToneAnalysisTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopVoiceToneAnalysisTaskAsync(const StopVoiceToneAnalysisTaskRequestT& request, const StopVoiceToneAnalysisTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::StopVoiceToneAnalysisTask, request, handler, context); } /** *

Adds a tag to the specified 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(&ChimeSDKVoiceClient::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(&ChimeSDKVoiceClient::TagResource, request, handler, context); } /** *

Removes tags from a 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(&ChimeSDKVoiceClient::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(&ChimeSDKVoiceClient::UntagResource, request, handler, context); } /** *

Updates global settings for the Amazon Chime SDK Voice Connectors in an AWS * account.

See Also:

AWS * API Reference

*/ virtual Model::UpdateGlobalSettingsOutcome UpdateGlobalSettings(const Model::UpdateGlobalSettingsRequest& request) const; /** * A Callable wrapper for UpdateGlobalSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateGlobalSettingsOutcomeCallable UpdateGlobalSettingsCallable(const UpdateGlobalSettingsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdateGlobalSettings, request); } /** * An Async wrapper for UpdateGlobalSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateGlobalSettingsAsync(const UpdateGlobalSettingsRequestT& request, const UpdateGlobalSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdateGlobalSettings, request, handler, context); } /** *

Updates phone number details, such as product type or calling name, for the * specified phone number ID. You can update one phone number detail at a time. For * example, you can update either the product type or the calling name in one * action.

For numbers outside the U.S., you must use the Amazon Chime SDK * SIP Media Application Dial-In product type.

Updates to outbound calling * names can take 72 hours to complete. Pending updates to outbound calling names * must be complete before you can request another update.

See Also:

* AWS * API Reference

*/ virtual Model::UpdatePhoneNumberOutcome UpdatePhoneNumber(const Model::UpdatePhoneNumberRequest& request) const; /** * A Callable wrapper for UpdatePhoneNumber that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePhoneNumberOutcomeCallable UpdatePhoneNumberCallable(const UpdatePhoneNumberRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdatePhoneNumber, request); } /** * An Async wrapper for UpdatePhoneNumber that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePhoneNumberAsync(const UpdatePhoneNumberRequestT& request, const UpdatePhoneNumberResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdatePhoneNumber, request, handler, context); } /** *

Updates the phone number settings for the administrator's AWS account, such * as the default outbound calling name. You can update the default outbound * calling name once every seven days. Outbound calling names can take up to 72 * hours to update.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePhoneNumberSettingsOutcome UpdatePhoneNumberSettings(const Model::UpdatePhoneNumberSettingsRequest& request) const; /** * A Callable wrapper for UpdatePhoneNumberSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePhoneNumberSettingsOutcomeCallable UpdatePhoneNumberSettingsCallable(const UpdatePhoneNumberSettingsRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdatePhoneNumberSettings, request); } /** * An Async wrapper for UpdatePhoneNumberSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePhoneNumberSettingsAsync(const UpdatePhoneNumberSettingsRequestT& request, const UpdatePhoneNumberSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdatePhoneNumberSettings, request, handler, context); } /** *

Updates the specified proxy session details, such as voice or SMS * capabilities.

See Also:

AWS * API Reference

*/ virtual Model::UpdateProxySessionOutcome UpdateProxySession(const Model::UpdateProxySessionRequest& request) const; /** * A Callable wrapper for UpdateProxySession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateProxySessionOutcomeCallable UpdateProxySessionCallable(const UpdateProxySessionRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdateProxySession, request); } /** * An Async wrapper for UpdateProxySession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateProxySessionAsync(const UpdateProxySessionRequestT& request, const UpdateProxySessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdateProxySession, request, handler, context); } /** *

Updates the details of the specified SIP media application.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateSipMediaApplicationOutcome UpdateSipMediaApplication(const Model::UpdateSipMediaApplicationRequest& request) const; /** * A Callable wrapper for UpdateSipMediaApplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSipMediaApplicationOutcomeCallable UpdateSipMediaApplicationCallable(const UpdateSipMediaApplicationRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdateSipMediaApplication, request); } /** * An Async wrapper for UpdateSipMediaApplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSipMediaApplicationAsync(const UpdateSipMediaApplicationRequestT& request, const UpdateSipMediaApplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdateSipMediaApplication, request, handler, context); } /** *

Invokes the AWS Lambda function associated with the SIP media application and * transaction ID in an update request. The Lambda function can then return a new * set of actions.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSipMediaApplicationCallOutcome UpdateSipMediaApplicationCall(const Model::UpdateSipMediaApplicationCallRequest& request) const; /** * A Callable wrapper for UpdateSipMediaApplicationCall that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSipMediaApplicationCallOutcomeCallable UpdateSipMediaApplicationCallCallable(const UpdateSipMediaApplicationCallRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdateSipMediaApplicationCall, request); } /** * An Async wrapper for UpdateSipMediaApplicationCall that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSipMediaApplicationCallAsync(const UpdateSipMediaApplicationCallRequestT& request, const UpdateSipMediaApplicationCallResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdateSipMediaApplicationCall, request, handler, context); } /** *

Updates the details of the specified SIP rule.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSipRuleOutcome UpdateSipRule(const Model::UpdateSipRuleRequest& request) const; /** * A Callable wrapper for UpdateSipRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSipRuleOutcomeCallable UpdateSipRuleCallable(const UpdateSipRuleRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdateSipRule, request); } /** * An Async wrapper for UpdateSipRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSipRuleAsync(const UpdateSipRuleRequestT& request, const UpdateSipRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdateSipRule, request, handler, context); } /** *

Updates the details for the specified Amazon Chime SDK Voice * Connector.

See Also:

AWS * API Reference

*/ virtual Model::UpdateVoiceConnectorOutcome UpdateVoiceConnector(const Model::UpdateVoiceConnectorRequest& request) const; /** * A Callable wrapper for UpdateVoiceConnector that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateVoiceConnectorOutcomeCallable UpdateVoiceConnectorCallable(const UpdateVoiceConnectorRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdateVoiceConnector, request); } /** * An Async wrapper for UpdateVoiceConnector that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateVoiceConnectorAsync(const UpdateVoiceConnectorRequestT& request, const UpdateVoiceConnectorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdateVoiceConnector, request, handler, context); } /** *

Updates the settings for the specified Amazon Chime SDK Voice Connector * group.

See Also:

AWS * API Reference

*/ virtual Model::UpdateVoiceConnectorGroupOutcome UpdateVoiceConnectorGroup(const Model::UpdateVoiceConnectorGroupRequest& request) const; /** * A Callable wrapper for UpdateVoiceConnectorGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateVoiceConnectorGroupOutcomeCallable UpdateVoiceConnectorGroupCallable(const UpdateVoiceConnectorGroupRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdateVoiceConnectorGroup, request); } /** * An Async wrapper for UpdateVoiceConnectorGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateVoiceConnectorGroupAsync(const UpdateVoiceConnectorGroupRequestT& request, const UpdateVoiceConnectorGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdateVoiceConnectorGroup, request, handler, context); } /** *

Updates the specified voice profile’s voice print and refreshes its * expiration timestamp.

As a condition of using this feature, * you acknowledge that the collection, use, storage, and retention of your * caller’s biometric identifiers and biometric information (“biometric data”) in * the form of a digital voiceprint requires the caller’s informed consent via a * written release. Such consent is required under various state laws, including * biometrics laws in Illinois, Texas, Washington and other state privacy laws.

*

You must provide a written release to each caller through a process that * clearly reflects each caller��s informed consent before using Amazon Chime SDK * Voice Insights service, as required under the terms of your agreement with AWS * governing your use of the service.

See Also:

AWS * API Reference

*/ virtual Model::UpdateVoiceProfileOutcome UpdateVoiceProfile(const Model::UpdateVoiceProfileRequest& request) const; /** * A Callable wrapper for UpdateVoiceProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateVoiceProfileOutcomeCallable UpdateVoiceProfileCallable(const UpdateVoiceProfileRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdateVoiceProfile, request); } /** * An Async wrapper for UpdateVoiceProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateVoiceProfileAsync(const UpdateVoiceProfileRequestT& request, const UpdateVoiceProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdateVoiceProfile, request, handler, context); } /** *

Updates the settings for the specified voice profile domain.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateVoiceProfileDomainOutcome UpdateVoiceProfileDomain(const Model::UpdateVoiceProfileDomainRequest& request) const; /** * A Callable wrapper for UpdateVoiceProfileDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateVoiceProfileDomainOutcomeCallable UpdateVoiceProfileDomainCallable(const UpdateVoiceProfileDomainRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::UpdateVoiceProfileDomain, request); } /** * An Async wrapper for UpdateVoiceProfileDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateVoiceProfileDomainAsync(const UpdateVoiceProfileDomainRequestT& request, const UpdateVoiceProfileDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::UpdateVoiceProfileDomain, request, handler, context); } /** *

Validates an address to be used for 911 calls made with Amazon Chime SDK * Voice Connectors. You can use validated addresses in a Presence Information Data * Format Location Object file that you include in SIP requests. That helps ensure * that addresses are routed to the appropriate Public Safety Answering * Point.

See Also:

AWS * API Reference

*/ virtual Model::ValidateE911AddressOutcome ValidateE911Address(const Model::ValidateE911AddressRequest& request) const; /** * A Callable wrapper for ValidateE911Address that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ValidateE911AddressOutcomeCallable ValidateE911AddressCallable(const ValidateE911AddressRequestT& request) const { return SubmitCallable(&ChimeSDKVoiceClient::ValidateE911Address, request); } /** * An Async wrapper for ValidateE911Address that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ValidateE911AddressAsync(const ValidateE911AddressRequestT& request, const ValidateE911AddressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ChimeSDKVoiceClient::ValidateE911Address, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const ChimeSDKVoiceClientConfiguration& clientConfiguration); ChimeSDKVoiceClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace ChimeSDKVoice } // namespace Aws