/** * 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 QuickSight { /** * Amazon QuickSight API Reference

Amazon QuickSight is a * fully managed, serverless business intelligence service for the Amazon Web * Services Cloud that makes it easy to extend data and insights to every user in * your organization. This API reference contains documentation for a programming * interface that you can use to manage Amazon QuickSight.

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

Cancels an ongoing ingestion of data into SPICE.

See Also:

* AWS * API Reference

*/ virtual Model::CancelIngestionOutcome CancelIngestion(const Model::CancelIngestionRequest& request) const; /** * A Callable wrapper for CancelIngestion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelIngestionOutcomeCallable CancelIngestionCallable(const CancelIngestionRequestT& request) const { return SubmitCallable(&QuickSightClient::CancelIngestion, request); } /** * An Async wrapper for CancelIngestion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelIngestionAsync(const CancelIngestionRequestT& request, const CancelIngestionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CancelIngestion, request, handler, context); } /** *

Creates Amazon QuickSight customizations for the current Amazon Web Services * Region. Currently, you can add a custom default theme by using the * CreateAccountCustomization or * UpdateAccountCustomization API operation. To further customize * Amazon QuickSight by removing Amazon QuickSight sample assets and videos for all * new users, see Customizing * Amazon QuickSight in the Amazon QuickSight User Guide.

You * can create customizations for your Amazon Web Services account or, if you * specify a namespace, for a QuickSight namespace instead. Customizations that * apply to a namespace always override customizations that apply to an Amazon Web * Services account. To find out which customizations apply, use the * DescribeAccountCustomization API operation.

Before you use * the CreateAccountCustomization API operation to add a theme as the * namespace default, make sure that you first share the theme with the namespace. * If you don't share it with the namespace, the theme isn't visible to your users * even if you make it the default theme. To check if the theme is shared, view the * current permissions by using the DescribeThemePermissions * API operation. To share the theme, grant permissions by using the * UpdateThemePermissions * API operation.

See Also:

AWS * API Reference

*/ virtual Model::CreateAccountCustomizationOutcome CreateAccountCustomization(const Model::CreateAccountCustomizationRequest& request) const; /** * A Callable wrapper for CreateAccountCustomization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAccountCustomizationOutcomeCallable CreateAccountCustomizationCallable(const CreateAccountCustomizationRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateAccountCustomization, request); } /** * An Async wrapper for CreateAccountCustomization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAccountCustomizationAsync(const CreateAccountCustomizationRequestT& request, const CreateAccountCustomizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateAccountCustomization, request, handler, context); } /** *

Creates an Amazon QuickSight account, or subscribes to Amazon QuickSight * Q.

The Amazon Web Services Region for the account is derived from what is * configured in the CLI or SDK. This operation isn't supported in the US East * (Ohio) Region, South America (Sao Paulo) Region, or Asia Pacific (Singapore) * Region.

Before you use this operation, make sure that you can connect to * an existing Amazon Web Services account. If you don't have an Amazon Web * Services account, see Sign * up for Amazon Web Services in the Amazon QuickSight User Guide. The * person who signs up for Amazon QuickSight needs to have the correct Identity and * Access Management (IAM) permissions. For more information, see IAM * Policy Examples for Amazon QuickSight in the Amazon QuickSight User * Guide.

If your IAM policy includes both the Subscribe * and CreateAccountSubscription actions, make sure that both actions * are set to Allow. If either action is set to Deny, the * Deny action prevails and your API call fails.

You can't pass * an existing IAM role to access other Amazon Web Services services using this API * operation. To pass your existing IAM role to Amazon QuickSight, see Passing * IAM roles to Amazon QuickSight in the Amazon QuickSight User * Guide.

You can't set default resource access on the new account from * the Amazon QuickSight API. Instead, add default resource access from the Amazon * QuickSight console. For more information about setting default resource access * to Amazon Web Services services, see Setting * default resource access to Amazon Web Services services in the Amazon * QuickSight User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateAccountSubscriptionOutcome CreateAccountSubscription(const Model::CreateAccountSubscriptionRequest& request) const; /** * A Callable wrapper for CreateAccountSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAccountSubscriptionOutcomeCallable CreateAccountSubscriptionCallable(const CreateAccountSubscriptionRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateAccountSubscription, request); } /** * An Async wrapper for CreateAccountSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAccountSubscriptionAsync(const CreateAccountSubscriptionRequestT& request, const CreateAccountSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateAccountSubscription, request, handler, context); } /** *

Creates an analysis in Amazon QuickSight. Analyses can be created either from * a template or from an AnalysisDefinition.

See Also:

* AWS * API Reference

*/ virtual Model::CreateAnalysisOutcome CreateAnalysis(const Model::CreateAnalysisRequest& request) const; /** * A Callable wrapper for CreateAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAnalysisOutcomeCallable CreateAnalysisCallable(const CreateAnalysisRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateAnalysis, request); } /** * An Async wrapper for CreateAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAnalysisAsync(const CreateAnalysisRequestT& request, const CreateAnalysisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateAnalysis, request, handler, context); } /** *

Creates a dashboard from either a template or directly with a * DashboardDefinition. To first create a template, see the CreateTemplate * API operation.

A dashboard is an entity in Amazon QuickSight that * identifies Amazon QuickSight reports, created from analyses. You can share * Amazon QuickSight dashboards. With the right permissions, you can create * scheduled email reports from them. If you have the correct permissions, you can * create a dashboard from a template that exists in a different Amazon Web * Services account.

See Also:

AWS * API Reference

*/ virtual Model::CreateDashboardOutcome CreateDashboard(const Model::CreateDashboardRequest& request) const; /** * A Callable wrapper for CreateDashboard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDashboardOutcomeCallable CreateDashboardCallable(const CreateDashboardRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateDashboard, request); } /** * An Async wrapper for CreateDashboard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDashboardAsync(const CreateDashboardRequestT& request, const CreateDashboardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateDashboard, request, handler, context); } /** *

Creates a dataset. This operation doesn't support datasets that include * uploaded files as a source.

See Also:

AWS * API Reference

*/ virtual Model::CreateDataSetOutcome CreateDataSet(const Model::CreateDataSetRequest& request) const; /** * A Callable wrapper for CreateDataSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDataSetOutcomeCallable CreateDataSetCallable(const CreateDataSetRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateDataSet, request); } /** * An Async wrapper for CreateDataSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDataSetAsync(const CreateDataSetRequestT& request, const CreateDataSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateDataSet, request, handler, context); } /** *

Creates a data source.

See Also:

AWS * API Reference

*/ virtual Model::CreateDataSourceOutcome CreateDataSource(const Model::CreateDataSourceRequest& request) const; /** * A Callable wrapper for CreateDataSource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDataSourceOutcomeCallable CreateDataSourceCallable(const CreateDataSourceRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateDataSource, request); } /** * An Async wrapper for CreateDataSource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDataSourceAsync(const CreateDataSourceRequestT& request, const CreateDataSourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateDataSource, request, handler, context); } /** *

Creates an empty shared folder.

See Also:

AWS * API Reference

*/ virtual Model::CreateFolderOutcome CreateFolder(const Model::CreateFolderRequest& request) const; /** * A Callable wrapper for CreateFolder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFolderOutcomeCallable CreateFolderCallable(const CreateFolderRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateFolder, request); } /** * An Async wrapper for CreateFolder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFolderAsync(const CreateFolderRequestT& request, const CreateFolderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateFolder, request, handler, context); } /** *

Adds an asset, such as a dashboard, analysis, or dataset into a * folder.

See Also:

AWS * API Reference

*/ virtual Model::CreateFolderMembershipOutcome CreateFolderMembership(const Model::CreateFolderMembershipRequest& request) const; /** * A Callable wrapper for CreateFolderMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFolderMembershipOutcomeCallable CreateFolderMembershipCallable(const CreateFolderMembershipRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateFolderMembership, request); } /** * An Async wrapper for CreateFolderMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFolderMembershipAsync(const CreateFolderMembershipRequestT& request, const CreateFolderMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateFolderMembership, request, handler, context); } /** *

Use the CreateGroup operation to create a group in Amazon * QuickSight. You can create up to 10,000 groups in a namespace. If you want to * create more than 10,000 groups in a namespace, contact AWS Support.

The * permissions resource is * arn:aws:quicksight:<your-region>:<relevant-aws-account-id>:group/default/<group-name> * .

The response is a group object.

See Also:

AWS * API Reference

*/ virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const; /** * A Callable wrapper for CreateGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateGroup, request); } /** * An Async wrapper for CreateGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGroupAsync(const CreateGroupRequestT& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateGroup, request, handler, context); } /** *

Adds an Amazon QuickSight user to an Amazon QuickSight group.

See * Also:

AWS * API Reference

*/ virtual Model::CreateGroupMembershipOutcome CreateGroupMembership(const Model::CreateGroupMembershipRequest& request) const; /** * A Callable wrapper for CreateGroupMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGroupMembershipOutcomeCallable CreateGroupMembershipCallable(const CreateGroupMembershipRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateGroupMembership, request); } /** * An Async wrapper for CreateGroupMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGroupMembershipAsync(const CreateGroupMembershipRequestT& request, const CreateGroupMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateGroupMembership, request, handler, context); } /** *

Creates an assignment with one specified IAM policy, identified by its Amazon * Resource Name (ARN). This policy assignment is attached to the specified groups * or users of Amazon QuickSight. Assignment names are unique per Amazon Web * Services account. To avoid overwriting rules in other namespaces, use assignment * names that are unique.

See Also:

AWS * API Reference

*/ virtual Model::CreateIAMPolicyAssignmentOutcome CreateIAMPolicyAssignment(const Model::CreateIAMPolicyAssignmentRequest& request) const; /** * A Callable wrapper for CreateIAMPolicyAssignment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIAMPolicyAssignmentOutcomeCallable CreateIAMPolicyAssignmentCallable(const CreateIAMPolicyAssignmentRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateIAMPolicyAssignment, request); } /** * An Async wrapper for CreateIAMPolicyAssignment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIAMPolicyAssignmentAsync(const CreateIAMPolicyAssignmentRequestT& request, const CreateIAMPolicyAssignmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateIAMPolicyAssignment, request, handler, context); } /** *

Creates and starts a new SPICE ingestion for a dataset. You can manually * refresh datasets in an Enterprise edition account 32 times in a 24-hour period. * You can manually refresh datasets in a Standard edition account 8 times in a * 24-hour period. Each 24-hour period is measured starting 24 hours before the * current date and time.

Any ingestions operating on tagged datasets * inherit the same tags automatically for use in access control. For an example, * see How * do I create an IAM policy to control access to Amazon EC2 resources using * tags? in the Amazon Web Services Knowledge Center. Tags are visible on the * tagged dataset, but not on the ingestion resource.

See Also:

AWS * API Reference

*/ virtual Model::CreateIngestionOutcome CreateIngestion(const Model::CreateIngestionRequest& request) const; /** * A Callable wrapper for CreateIngestion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIngestionOutcomeCallable CreateIngestionCallable(const CreateIngestionRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateIngestion, request); } /** * An Async wrapper for CreateIngestion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIngestionAsync(const CreateIngestionRequestT& request, const CreateIngestionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateIngestion, request, handler, context); } /** *

(Enterprise edition only) Creates a new namespace for you to use with Amazon * QuickSight.

A namespace allows you to isolate the Amazon QuickSight users * and groups that are registered for that namespace. Users that access the * namespace can share assets only with other users or groups in the same * namespace. They can't see users and groups in other namespaces. You can create a * namespace after your Amazon Web Services account is subscribed to Amazon * QuickSight. The namespace must be unique within the Amazon Web Services account. * By default, there is a limit of 100 namespaces per Amazon Web Services account. * To increase your limit, create a ticket with Amazon Web Services Support. *

See Also:

AWS * API Reference

*/ virtual Model::CreateNamespaceOutcome CreateNamespace(const Model::CreateNamespaceRequest& request) const; /** * A Callable wrapper for CreateNamespace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNamespaceOutcomeCallable CreateNamespaceCallable(const CreateNamespaceRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateNamespace, request); } /** * An Async wrapper for CreateNamespace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNamespaceAsync(const CreateNamespaceRequestT& request, const CreateNamespaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateNamespace, request, handler, context); } /** *

Creates a refresh schedule for a dataset. You can create up to 5 different * schedules for a single dataset.

See Also:

AWS * API Reference

*/ virtual Model::CreateRefreshScheduleOutcome CreateRefreshSchedule(const Model::CreateRefreshScheduleRequest& request) const; /** * A Callable wrapper for CreateRefreshSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRefreshScheduleOutcomeCallable CreateRefreshScheduleCallable(const CreateRefreshScheduleRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateRefreshSchedule, request); } /** * An Async wrapper for CreateRefreshSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRefreshScheduleAsync(const CreateRefreshScheduleRequestT& request, const CreateRefreshScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateRefreshSchedule, request, handler, context); } /** *

Creates a template either from a TemplateDefinition or from an * existing Amazon QuickSight analysis or template. You can use the resulting * template to create additional dashboards, templates, or analyses.

A * template is an entity in Amazon QuickSight that encapsulates the metadata * required to create an analysis and that you can use to create s dashboard. A * template adds a layer of abstraction by using placeholders to replace the * dataset associated with the analysis. You can use templates to create dashboards * by replacing dataset placeholders with datasets that follow the same schema that * was used to create the source analysis and template.

See Also:

* AWS * API Reference

*/ virtual Model::CreateTemplateOutcome CreateTemplate(const Model::CreateTemplateRequest& request) const; /** * A Callable wrapper for CreateTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTemplateOutcomeCallable CreateTemplateCallable(const CreateTemplateRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateTemplate, request); } /** * An Async wrapper for CreateTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTemplateAsync(const CreateTemplateRequestT& request, const CreateTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateTemplate, request, handler, context); } /** *

Creates a template alias for a template.

See Also:

AWS * API Reference

*/ virtual Model::CreateTemplateAliasOutcome CreateTemplateAlias(const Model::CreateTemplateAliasRequest& request) const; /** * A Callable wrapper for CreateTemplateAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTemplateAliasOutcomeCallable CreateTemplateAliasCallable(const CreateTemplateAliasRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateTemplateAlias, request); } /** * An Async wrapper for CreateTemplateAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTemplateAliasAsync(const CreateTemplateAliasRequestT& request, const CreateTemplateAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateTemplateAlias, request, handler, context); } /** *

Creates a theme.

A theme is set of configuration options for * color and layout. Themes apply to analyses and dashboards. For more information, * see Using * Themes in Amazon QuickSight in the Amazon QuickSight User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateThemeOutcome CreateTheme(const Model::CreateThemeRequest& request) const; /** * A Callable wrapper for CreateTheme that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateThemeOutcomeCallable CreateThemeCallable(const CreateThemeRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateTheme, request); } /** * An Async wrapper for CreateTheme that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateThemeAsync(const CreateThemeRequestT& request, const CreateThemeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateTheme, request, handler, context); } /** *

Creates a theme alias for a theme.

See Also:

AWS * API Reference

*/ virtual Model::CreateThemeAliasOutcome CreateThemeAlias(const Model::CreateThemeAliasRequest& request) const; /** * A Callable wrapper for CreateThemeAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateThemeAliasOutcomeCallable CreateThemeAliasCallable(const CreateThemeAliasRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateThemeAlias, request); } /** * An Async wrapper for CreateThemeAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateThemeAliasAsync(const CreateThemeAliasRequestT& request, const CreateThemeAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateThemeAlias, request, handler, context); } /** *

Creates a new Q topic.

See Also:

AWS * API Reference

*/ virtual Model::CreateTopicOutcome CreateTopic(const Model::CreateTopicRequest& request) const; /** * A Callable wrapper for CreateTopic that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTopicOutcomeCallable CreateTopicCallable(const CreateTopicRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateTopic, request); } /** * An Async wrapper for CreateTopic that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTopicAsync(const CreateTopicRequestT& request, const CreateTopicResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateTopic, request, handler, context); } /** *

Creates a topic refresh schedule.

See Also:

AWS * API Reference

*/ virtual Model::CreateTopicRefreshScheduleOutcome CreateTopicRefreshSchedule(const Model::CreateTopicRefreshScheduleRequest& request) const; /** * A Callable wrapper for CreateTopicRefreshSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTopicRefreshScheduleOutcomeCallable CreateTopicRefreshScheduleCallable(const CreateTopicRefreshScheduleRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateTopicRefreshSchedule, request); } /** * An Async wrapper for CreateTopicRefreshSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTopicRefreshScheduleAsync(const CreateTopicRefreshScheduleRequestT& request, const CreateTopicRefreshScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateTopicRefreshSchedule, request, handler, context); } /** *

Creates a new VPC connection.

See Also:

AWS * API Reference

*/ virtual Model::CreateVPCConnectionOutcome CreateVPCConnection(const Model::CreateVPCConnectionRequest& request) const; /** * A Callable wrapper for CreateVPCConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateVPCConnectionOutcomeCallable CreateVPCConnectionCallable(const CreateVPCConnectionRequestT& request) const { return SubmitCallable(&QuickSightClient::CreateVPCConnection, request); } /** * An Async wrapper for CreateVPCConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateVPCConnectionAsync(const CreateVPCConnectionRequestT& request, const CreateVPCConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::CreateVPCConnection, request, handler, context); } /** *

Deletes all Amazon QuickSight customizations in this Amazon Web Services * Region for the specified Amazon Web Services account and Amazon QuickSight * namespace.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccountCustomizationOutcome DeleteAccountCustomization(const Model::DeleteAccountCustomizationRequest& request) const; /** * A Callable wrapper for DeleteAccountCustomization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccountCustomizationOutcomeCallable DeleteAccountCustomizationCallable(const DeleteAccountCustomizationRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteAccountCustomization, request); } /** * An Async wrapper for DeleteAccountCustomization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccountCustomizationAsync(const DeleteAccountCustomizationRequestT& request, const DeleteAccountCustomizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteAccountCustomization, request, handler, context); } /** *

Use the DeleteAccountSubscription operation to delete an Amazon * QuickSight account. This operation will result in an error message if you have * configured your account termination protection settings to True. To * change this setting and delete your account, call the * UpdateAccountSettings API and set the value of the * TerminationProtectionEnabled parameter to False, then * make another call to the DeleteAccountSubscription * API.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccountSubscriptionOutcome DeleteAccountSubscription(const Model::DeleteAccountSubscriptionRequest& request) const; /** * A Callable wrapper for DeleteAccountSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccountSubscriptionOutcomeCallable DeleteAccountSubscriptionCallable(const DeleteAccountSubscriptionRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteAccountSubscription, request); } /** * An Async wrapper for DeleteAccountSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccountSubscriptionAsync(const DeleteAccountSubscriptionRequestT& request, const DeleteAccountSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteAccountSubscription, request, handler, context); } /** *

Deletes an analysis from Amazon QuickSight. You can optionally include a * recovery window during which you can restore the analysis. If you don't specify * a recovery window value, the operation defaults to 30 days. Amazon QuickSight * attaches a DeletionTime stamp to the response that specifies the * end of the recovery window. At the end of the recovery window, Amazon QuickSight * deletes the analysis permanently.

At any time before recovery window * ends, you can use the RestoreAnalysis API operation to remove the * DeletionTime stamp and cancel the deletion of the analysis. The * analysis remains visible in the API until it's deleted, so you can describe it * but you can't make a template from it.

An analysis that's scheduled for * deletion isn't accessible in the Amazon QuickSight console. To access it in the * console, restore it. Deleting an analysis doesn't delete the dashboards that you * publish from it.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAnalysisOutcome DeleteAnalysis(const Model::DeleteAnalysisRequest& request) const; /** * A Callable wrapper for DeleteAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAnalysisOutcomeCallable DeleteAnalysisCallable(const DeleteAnalysisRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteAnalysis, request); } /** * An Async wrapper for DeleteAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAnalysisAsync(const DeleteAnalysisRequestT& request, const DeleteAnalysisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteAnalysis, request, handler, context); } /** *

Deletes a dashboard.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDashboardOutcome DeleteDashboard(const Model::DeleteDashboardRequest& request) const; /** * A Callable wrapper for DeleteDashboard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDashboardOutcomeCallable DeleteDashboardCallable(const DeleteDashboardRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteDashboard, request); } /** * An Async wrapper for DeleteDashboard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDashboardAsync(const DeleteDashboardRequestT& request, const DeleteDashboardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteDashboard, request, handler, context); } /** *

Deletes a dataset.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDataSetOutcome DeleteDataSet(const Model::DeleteDataSetRequest& request) const; /** * A Callable wrapper for DeleteDataSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDataSetOutcomeCallable DeleteDataSetCallable(const DeleteDataSetRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteDataSet, request); } /** * An Async wrapper for DeleteDataSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDataSetAsync(const DeleteDataSetRequestT& request, const DeleteDataSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteDataSet, request, handler, context); } /** *

Deletes the dataset refresh properties of the dataset.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteDataSetRefreshPropertiesOutcome DeleteDataSetRefreshProperties(const Model::DeleteDataSetRefreshPropertiesRequest& request) const; /** * A Callable wrapper for DeleteDataSetRefreshProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDataSetRefreshPropertiesOutcomeCallable DeleteDataSetRefreshPropertiesCallable(const DeleteDataSetRefreshPropertiesRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteDataSetRefreshProperties, request); } /** * An Async wrapper for DeleteDataSetRefreshProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDataSetRefreshPropertiesAsync(const DeleteDataSetRefreshPropertiesRequestT& request, const DeleteDataSetRefreshPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteDataSetRefreshProperties, request, handler, context); } /** *

Deletes the data source permanently. This operation breaks all the datasets * that reference the deleted data source.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDataSourceOutcome DeleteDataSource(const Model::DeleteDataSourceRequest& request) const; /** * A Callable wrapper for DeleteDataSource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDataSourceOutcomeCallable DeleteDataSourceCallable(const DeleteDataSourceRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteDataSource, request); } /** * An Async wrapper for DeleteDataSource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDataSourceAsync(const DeleteDataSourceRequestT& request, const DeleteDataSourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteDataSource, request, handler, context); } /** *

Deletes an empty folder.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFolderOutcome DeleteFolder(const Model::DeleteFolderRequest& request) const; /** * A Callable wrapper for DeleteFolder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFolderOutcomeCallable DeleteFolderCallable(const DeleteFolderRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteFolder, request); } /** * An Async wrapper for DeleteFolder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFolderAsync(const DeleteFolderRequestT& request, const DeleteFolderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteFolder, request, handler, context); } /** *

Removes an asset, such as a dashboard, analysis, or dataset, from a * folder.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFolderMembershipOutcome DeleteFolderMembership(const Model::DeleteFolderMembershipRequest& request) const; /** * A Callable wrapper for DeleteFolderMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFolderMembershipOutcomeCallable DeleteFolderMembershipCallable(const DeleteFolderMembershipRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteFolderMembership, request); } /** * An Async wrapper for DeleteFolderMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFolderMembershipAsync(const DeleteFolderMembershipRequestT& request, const DeleteFolderMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteFolderMembership, request, handler, context); } /** *

Removes a user group from Amazon QuickSight.

See Also:

AWS * API Reference

*/ virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request) const; /** * A Callable wrapper for DeleteGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteGroup, request); } /** * An Async wrapper for DeleteGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteGroupAsync(const DeleteGroupRequestT& request, const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteGroup, request, handler, context); } /** *

Removes a user from a group so that the user is no longer a member of the * group.

See Also:

AWS * API Reference

*/ virtual Model::DeleteGroupMembershipOutcome DeleteGroupMembership(const Model::DeleteGroupMembershipRequest& request) const; /** * A Callable wrapper for DeleteGroupMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteGroupMembershipOutcomeCallable DeleteGroupMembershipCallable(const DeleteGroupMembershipRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteGroupMembership, request); } /** * An Async wrapper for DeleteGroupMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteGroupMembershipAsync(const DeleteGroupMembershipRequestT& request, const DeleteGroupMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteGroupMembership, request, handler, context); } /** *

Deletes an existing IAM policy assignment.

See Also:

AWS * API Reference

*/ virtual Model::DeleteIAMPolicyAssignmentOutcome DeleteIAMPolicyAssignment(const Model::DeleteIAMPolicyAssignmentRequest& request) const; /** * A Callable wrapper for DeleteIAMPolicyAssignment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIAMPolicyAssignmentOutcomeCallable DeleteIAMPolicyAssignmentCallable(const DeleteIAMPolicyAssignmentRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteIAMPolicyAssignment, request); } /** * An Async wrapper for DeleteIAMPolicyAssignment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIAMPolicyAssignmentAsync(const DeleteIAMPolicyAssignmentRequestT& request, const DeleteIAMPolicyAssignmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteIAMPolicyAssignment, request, handler, context); } /** *

Deletes a namespace and the users and groups that are associated with the * namespace. This is an asynchronous process. Assets including dashboards, * analyses, datasets and data sources are not deleted. To delete these assets, you * use the API operations for the relevant asset.

See Also:

AWS * API Reference

*/ virtual Model::DeleteNamespaceOutcome DeleteNamespace(const Model::DeleteNamespaceRequest& request) const; /** * A Callable wrapper for DeleteNamespace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNamespaceOutcomeCallable DeleteNamespaceCallable(const DeleteNamespaceRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteNamespace, request); } /** * An Async wrapper for DeleteNamespace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNamespaceAsync(const DeleteNamespaceRequestT& request, const DeleteNamespaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteNamespace, request, handler, context); } /** *

Deletes a refresh schedule from a dataset.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRefreshScheduleOutcome DeleteRefreshSchedule(const Model::DeleteRefreshScheduleRequest& request) const; /** * A Callable wrapper for DeleteRefreshSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRefreshScheduleOutcomeCallable DeleteRefreshScheduleCallable(const DeleteRefreshScheduleRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteRefreshSchedule, request); } /** * An Async wrapper for DeleteRefreshSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRefreshScheduleAsync(const DeleteRefreshScheduleRequestT& request, const DeleteRefreshScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteRefreshSchedule, request, handler, context); } /** *

Deletes a template.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTemplateOutcome DeleteTemplate(const Model::DeleteTemplateRequest& request) const; /** * A Callable wrapper for DeleteTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTemplateOutcomeCallable DeleteTemplateCallable(const DeleteTemplateRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteTemplate, request); } /** * An Async wrapper for DeleteTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTemplateAsync(const DeleteTemplateRequestT& request, const DeleteTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteTemplate, request, handler, context); } /** *

Deletes the item that the specified template alias points to. If you provide * a specific alias, you delete the version of the template that the alias points * to.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTemplateAliasOutcome DeleteTemplateAlias(const Model::DeleteTemplateAliasRequest& request) const; /** * A Callable wrapper for DeleteTemplateAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTemplateAliasOutcomeCallable DeleteTemplateAliasCallable(const DeleteTemplateAliasRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteTemplateAlias, request); } /** * An Async wrapper for DeleteTemplateAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTemplateAliasAsync(const DeleteTemplateAliasRequestT& request, const DeleteTemplateAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteTemplateAlias, request, handler, context); } /** *

Deletes a theme.

See Also:

AWS * API Reference

*/ virtual Model::DeleteThemeOutcome DeleteTheme(const Model::DeleteThemeRequest& request) const; /** * A Callable wrapper for DeleteTheme that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteThemeOutcomeCallable DeleteThemeCallable(const DeleteThemeRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteTheme, request); } /** * An Async wrapper for DeleteTheme that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteThemeAsync(const DeleteThemeRequestT& request, const DeleteThemeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteTheme, request, handler, context); } /** *

Deletes the version of the theme that the specified theme alias points to. If * you provide a specific alias, you delete the version of the theme that the alias * points to.

See Also:

AWS * API Reference

*/ virtual Model::DeleteThemeAliasOutcome DeleteThemeAlias(const Model::DeleteThemeAliasRequest& request) const; /** * A Callable wrapper for DeleteThemeAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteThemeAliasOutcomeCallable DeleteThemeAliasCallable(const DeleteThemeAliasRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteThemeAlias, request); } /** * An Async wrapper for DeleteThemeAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteThemeAliasAsync(const DeleteThemeAliasRequestT& request, const DeleteThemeAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteThemeAlias, request, handler, context); } /** *

Deletes a topic.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTopicOutcome DeleteTopic(const Model::DeleteTopicRequest& request) const; /** * A Callable wrapper for DeleteTopic that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTopicOutcomeCallable DeleteTopicCallable(const DeleteTopicRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteTopic, request); } /** * An Async wrapper for DeleteTopic that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTopicAsync(const DeleteTopicRequestT& request, const DeleteTopicResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteTopic, request, handler, context); } /** *

Deletes a topic refresh schedule.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTopicRefreshScheduleOutcome DeleteTopicRefreshSchedule(const Model::DeleteTopicRefreshScheduleRequest& request) const; /** * A Callable wrapper for DeleteTopicRefreshSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTopicRefreshScheduleOutcomeCallable DeleteTopicRefreshScheduleCallable(const DeleteTopicRefreshScheduleRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteTopicRefreshSchedule, request); } /** * An Async wrapper for DeleteTopicRefreshSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTopicRefreshScheduleAsync(const DeleteTopicRefreshScheduleRequestT& request, const DeleteTopicRefreshScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteTopicRefreshSchedule, request, handler, context); } /** *

Deletes the Amazon QuickSight user that is associated with the identity of * the IAM user or role that's making the call. The IAM user isn't deleted as a * result of this call.

See Also:

AWS * API Reference

*/ virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const; /** * A Callable wrapper for DeleteUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteUser, request); } /** * An Async wrapper for DeleteUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteUser, request, handler, context); } /** *

Deletes a user identified by its principal ID.

See Also:

AWS * API Reference

*/ virtual Model::DeleteUserByPrincipalIdOutcome DeleteUserByPrincipalId(const Model::DeleteUserByPrincipalIdRequest& request) const; /** * A Callable wrapper for DeleteUserByPrincipalId that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUserByPrincipalIdOutcomeCallable DeleteUserByPrincipalIdCallable(const DeleteUserByPrincipalIdRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteUserByPrincipalId, request); } /** * An Async wrapper for DeleteUserByPrincipalId that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUserByPrincipalIdAsync(const DeleteUserByPrincipalIdRequestT& request, const DeleteUserByPrincipalIdResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteUserByPrincipalId, request, handler, context); } /** *

Deletes a VPC connection.

See Also:

AWS * API Reference

*/ virtual Model::DeleteVPCConnectionOutcome DeleteVPCConnection(const Model::DeleteVPCConnectionRequest& request) const; /** * A Callable wrapper for DeleteVPCConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteVPCConnectionOutcomeCallable DeleteVPCConnectionCallable(const DeleteVPCConnectionRequestT& request) const { return SubmitCallable(&QuickSightClient::DeleteVPCConnection, request); } /** * An Async wrapper for DeleteVPCConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteVPCConnectionAsync(const DeleteVPCConnectionRequestT& request, const DeleteVPCConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DeleteVPCConnection, request, handler, context); } /** *

Describes the customizations associated with the provided Amazon Web Services * account and Amazon Amazon QuickSight namespace in an Amazon Web Services Region. * The Amazon QuickSight console evaluates which customizations to apply by running * this API operation with the Resolved flag included.

To * determine what customizations display when you run this command, it can help to * visualize the relationship of the entities involved.

  • * Amazon Web Services account - The Amazon Web Services account * exists at the top of the hierarchy. It has the potential to use all of the * Amazon Web Services Regions and Amazon Web Services Services. When you subscribe * to Amazon QuickSight, you choose one Amazon Web Services Region to use as your * home Region. That's where your free SPICE capacity is located. You can use * Amazon QuickSight in any supported Amazon Web Services Region.

  • *

    Amazon Web Services Region - In each Amazon Web Services Region * where you sign in to Amazon QuickSight at least once, Amazon QuickSight acts as * a separate instance of the same service. If you have a user directory, it * resides in us-east-1, which is the US East (N. Virginia). Generally speaking, * these users have access to Amazon QuickSight in any Amazon Web Services Region, * unless they are constrained to a namespace.

    To run the command in a * different Amazon Web Services Region, you change your Region settings. If you're * using the CLI, you can use one of the following options:

  • Namespace - A * QuickSight namespace is a partition that contains users and assets (data * sources, datasets, dashboards, and so on). To access assets that are in a * specific namespace, users and groups must also be part of the same namespace. * People who share a namespace are completely isolated from users and assets in * other namespaces, even if they are in the same Amazon Web Services account and * Amazon Web Services Region.

  • Applied * customizations - Within an Amazon Web Services Region, a set of Amazon * QuickSight customizations can apply to an Amazon Web Services account or to a * namespace. Settings that you apply to a namespace override settings that you * apply to an Amazon Web Services account. All settings are isolated to a single * Amazon Web Services Region. To apply them in other Amazon Web Services Regions, * run the CreateAccountCustomization command in each Amazon Web * Services Region where you want to apply the same customizations.

    • *

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountCustomizationOutcome DescribeAccountCustomization(const Model::DescribeAccountCustomizationRequest& request) const; /** * A Callable wrapper for DescribeAccountCustomization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountCustomizationOutcomeCallable DescribeAccountCustomizationCallable(const DescribeAccountCustomizationRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeAccountCustomization, request); } /** * An Async wrapper for DescribeAccountCustomization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountCustomizationAsync(const DescribeAccountCustomizationRequestT& request, const DescribeAccountCustomizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeAccountCustomization, request, handler, context); } /** *

Describes the settings that were used when your Amazon QuickSight * subscription was first created in this Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountSettingsOutcome DescribeAccountSettings(const Model::DescribeAccountSettingsRequest& request) const; /** * A Callable wrapper for DescribeAccountSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountSettingsOutcomeCallable DescribeAccountSettingsCallable(const DescribeAccountSettingsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeAccountSettings, request); } /** * An Async wrapper for DescribeAccountSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountSettingsAsync(const DescribeAccountSettingsRequestT& request, const DescribeAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeAccountSettings, request, handler, context); } /** *

Use the DescribeAccountSubscription operation to receive a description of an * Amazon QuickSight account's subscription. A successful API call returns an * AccountInfo object that includes an account's name, subscription * status, authentication type, edition, and notification email * address.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountSubscriptionOutcome DescribeAccountSubscription(const Model::DescribeAccountSubscriptionRequest& request) const; /** * A Callable wrapper for DescribeAccountSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountSubscriptionOutcomeCallable DescribeAccountSubscriptionCallable(const DescribeAccountSubscriptionRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeAccountSubscription, request); } /** * An Async wrapper for DescribeAccountSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountSubscriptionAsync(const DescribeAccountSubscriptionRequestT& request, const DescribeAccountSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeAccountSubscription, request, handler, context); } /** *

Provides a summary of the metadata for an analysis.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeAnalysisOutcome DescribeAnalysis(const Model::DescribeAnalysisRequest& request) const; /** * A Callable wrapper for DescribeAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAnalysisOutcomeCallable DescribeAnalysisCallable(const DescribeAnalysisRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeAnalysis, request); } /** * An Async wrapper for DescribeAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAnalysisAsync(const DescribeAnalysisRequestT& request, const DescribeAnalysisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeAnalysis, request, handler, context); } /** *

Provides a detailed description of the definition of an analysis.

*

If you do not need to know details about the content of an Analysis, for * instance if you are trying to check the status of a recently created or updated * Analysis, use the * DescribeAnalysis instead.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeAnalysisDefinitionOutcome DescribeAnalysisDefinition(const Model::DescribeAnalysisDefinitionRequest& request) const; /** * A Callable wrapper for DescribeAnalysisDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAnalysisDefinitionOutcomeCallable DescribeAnalysisDefinitionCallable(const DescribeAnalysisDefinitionRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeAnalysisDefinition, request); } /** * An Async wrapper for DescribeAnalysisDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAnalysisDefinitionAsync(const DescribeAnalysisDefinitionRequestT& request, const DescribeAnalysisDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeAnalysisDefinition, request, handler, context); } /** *

Provides the read and write permissions for an analysis.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAnalysisPermissionsOutcome DescribeAnalysisPermissions(const Model::DescribeAnalysisPermissionsRequest& request) const; /** * A Callable wrapper for DescribeAnalysisPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAnalysisPermissionsOutcomeCallable DescribeAnalysisPermissionsCallable(const DescribeAnalysisPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeAnalysisPermissions, request); } /** * An Async wrapper for DescribeAnalysisPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAnalysisPermissionsAsync(const DescribeAnalysisPermissionsRequestT& request, const DescribeAnalysisPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeAnalysisPermissions, request, handler, context); } /** *

Describes an existing export job.

Poll job descriptions after a job * starts to know the status of the job. When a job succeeds, a URL is provided to * download the exported assets' data from. Download URLs are valid for five * minutes after they are generated. You can call the * DescribeAssetBundleExportJob API for a new download URL as * needed.

Job descriptions are available for 14 days after the job * starts.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAssetBundleExportJobOutcome DescribeAssetBundleExportJob(const Model::DescribeAssetBundleExportJobRequest& request) const; /** * A Callable wrapper for DescribeAssetBundleExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAssetBundleExportJobOutcomeCallable DescribeAssetBundleExportJobCallable(const DescribeAssetBundleExportJobRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeAssetBundleExportJob, request); } /** * An Async wrapper for DescribeAssetBundleExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAssetBundleExportJobAsync(const DescribeAssetBundleExportJobRequestT& request, const DescribeAssetBundleExportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeAssetBundleExportJob, request, handler, context); } /** *

Describes an existing import job.

Poll job descriptions after starting * a job to know when it has succeeded or failed. Job descriptions are available * for 14 days after job starts.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAssetBundleImportJobOutcome DescribeAssetBundleImportJob(const Model::DescribeAssetBundleImportJobRequest& request) const; /** * A Callable wrapper for DescribeAssetBundleImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAssetBundleImportJobOutcomeCallable DescribeAssetBundleImportJobCallable(const DescribeAssetBundleImportJobRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeAssetBundleImportJob, request); } /** * An Async wrapper for DescribeAssetBundleImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAssetBundleImportJobAsync(const DescribeAssetBundleImportJobRequestT& request, const DescribeAssetBundleImportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeAssetBundleImportJob, request, handler, context); } /** *

Provides a summary for a dashboard.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDashboardOutcome DescribeDashboard(const Model::DescribeDashboardRequest& request) const; /** * A Callable wrapper for DescribeDashboard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDashboardOutcomeCallable DescribeDashboardCallable(const DescribeDashboardRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDashboard, request); } /** * An Async wrapper for DescribeDashboard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDashboardAsync(const DescribeDashboardRequestT& request, const DescribeDashboardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDashboard, request, handler, context); } /** *

Provides a detailed description of the definition of a dashboard.

*

If you do not need to know details about the content of a dashboard, for * instance if you are trying to check the status of a recently created or updated * dashboard, use the * DescribeDashboard instead.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeDashboardDefinitionOutcome DescribeDashboardDefinition(const Model::DescribeDashboardDefinitionRequest& request) const; /** * A Callable wrapper for DescribeDashboardDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDashboardDefinitionOutcomeCallable DescribeDashboardDefinitionCallable(const DescribeDashboardDefinitionRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDashboardDefinition, request); } /** * An Async wrapper for DescribeDashboardDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDashboardDefinitionAsync(const DescribeDashboardDefinitionRequestT& request, const DescribeDashboardDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDashboardDefinition, request, handler, context); } /** *

Describes read and write permissions for a dashboard.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeDashboardPermissionsOutcome DescribeDashboardPermissions(const Model::DescribeDashboardPermissionsRequest& request) const; /** * A Callable wrapper for DescribeDashboardPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDashboardPermissionsOutcomeCallable DescribeDashboardPermissionsCallable(const DescribeDashboardPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDashboardPermissions, request); } /** * An Async wrapper for DescribeDashboardPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDashboardPermissionsAsync(const DescribeDashboardPermissionsRequestT& request, const DescribeDashboardPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDashboardPermissions, request, handler, context); } /** *

Describes an existing snapshot job.

Poll job descriptions after a job * starts to know the status of the job. For information on available status codes, * see JobStatus.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDashboardSnapshotJobOutcome DescribeDashboardSnapshotJob(const Model::DescribeDashboardSnapshotJobRequest& request) const; /** * A Callable wrapper for DescribeDashboardSnapshotJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDashboardSnapshotJobOutcomeCallable DescribeDashboardSnapshotJobCallable(const DescribeDashboardSnapshotJobRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDashboardSnapshotJob, request); } /** * An Async wrapper for DescribeDashboardSnapshotJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDashboardSnapshotJobAsync(const DescribeDashboardSnapshotJobRequestT& request, const DescribeDashboardSnapshotJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDashboardSnapshotJob, request, handler, context); } /** *

Describes the result of an existing snapshot job that has finished * running.

A finished snapshot job will return a COMPLETED or * FAILED status when you poll the job with a * DescribeDashboardSnapshotJob API call.

If the job has not * finished running, this operation returns a message that says Dashboard * Snapshot Job with id <SnapshotjobId> has not reached a terminal * state..

See Also:

AWS * API Reference

*/ virtual Model::DescribeDashboardSnapshotJobResultOutcome DescribeDashboardSnapshotJobResult(const Model::DescribeDashboardSnapshotJobResultRequest& request) const; /** * A Callable wrapper for DescribeDashboardSnapshotJobResult that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDashboardSnapshotJobResultOutcomeCallable DescribeDashboardSnapshotJobResultCallable(const DescribeDashboardSnapshotJobResultRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDashboardSnapshotJobResult, request); } /** * An Async wrapper for DescribeDashboardSnapshotJobResult that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDashboardSnapshotJobResultAsync(const DescribeDashboardSnapshotJobResultRequestT& request, const DescribeDashboardSnapshotJobResultResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDashboardSnapshotJobResult, request, handler, context); } /** *

Describes a dataset. This operation doesn't support datasets that include * uploaded files as a source.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDataSetOutcome DescribeDataSet(const Model::DescribeDataSetRequest& request) const; /** * A Callable wrapper for DescribeDataSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataSetOutcomeCallable DescribeDataSetCallable(const DescribeDataSetRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDataSet, request); } /** * An Async wrapper for DescribeDataSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataSetAsync(const DescribeDataSetRequestT& request, const DescribeDataSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDataSet, request, handler, context); } /** *

Describes the permissions on a dataset.

The permissions resource is * arn:aws:quicksight:region:aws-account-id:dataset/data-set-id.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeDataSetPermissionsOutcome DescribeDataSetPermissions(const Model::DescribeDataSetPermissionsRequest& request) const; /** * A Callable wrapper for DescribeDataSetPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataSetPermissionsOutcomeCallable DescribeDataSetPermissionsCallable(const DescribeDataSetPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDataSetPermissions, request); } /** * An Async wrapper for DescribeDataSetPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataSetPermissionsAsync(const DescribeDataSetPermissionsRequestT& request, const DescribeDataSetPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDataSetPermissions, request, handler, context); } /** *

Describes the refresh properties of a dataset.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDataSetRefreshPropertiesOutcome DescribeDataSetRefreshProperties(const Model::DescribeDataSetRefreshPropertiesRequest& request) const; /** * A Callable wrapper for DescribeDataSetRefreshProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataSetRefreshPropertiesOutcomeCallable DescribeDataSetRefreshPropertiesCallable(const DescribeDataSetRefreshPropertiesRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDataSetRefreshProperties, request); } /** * An Async wrapper for DescribeDataSetRefreshProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataSetRefreshPropertiesAsync(const DescribeDataSetRefreshPropertiesRequestT& request, const DescribeDataSetRefreshPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDataSetRefreshProperties, request, handler, context); } /** *

Describes a data source.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDataSourceOutcome DescribeDataSource(const Model::DescribeDataSourceRequest& request) const; /** * A Callable wrapper for DescribeDataSource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataSourceOutcomeCallable DescribeDataSourceCallable(const DescribeDataSourceRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDataSource, request); } /** * An Async wrapper for DescribeDataSource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataSourceAsync(const DescribeDataSourceRequestT& request, const DescribeDataSourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDataSource, request, handler, context); } /** *

Describes the resource permissions for a data source.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeDataSourcePermissionsOutcome DescribeDataSourcePermissions(const Model::DescribeDataSourcePermissionsRequest& request) const; /** * A Callable wrapper for DescribeDataSourcePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataSourcePermissionsOutcomeCallable DescribeDataSourcePermissionsCallable(const DescribeDataSourcePermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeDataSourcePermissions, request); } /** * An Async wrapper for DescribeDataSourcePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataSourcePermissionsAsync(const DescribeDataSourcePermissionsRequestT& request, const DescribeDataSourcePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeDataSourcePermissions, request, handler, context); } /** *

Describes a folder.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFolderOutcome DescribeFolder(const Model::DescribeFolderRequest& request) const; /** * A Callable wrapper for DescribeFolder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFolderOutcomeCallable DescribeFolderCallable(const DescribeFolderRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeFolder, request); } /** * An Async wrapper for DescribeFolder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFolderAsync(const DescribeFolderRequestT& request, const DescribeFolderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeFolder, request, handler, context); } /** *

Describes permissions for a folder.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFolderPermissionsOutcome DescribeFolderPermissions(const Model::DescribeFolderPermissionsRequest& request) const; /** * A Callable wrapper for DescribeFolderPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFolderPermissionsOutcomeCallable DescribeFolderPermissionsCallable(const DescribeFolderPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeFolderPermissions, request); } /** * An Async wrapper for DescribeFolderPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFolderPermissionsAsync(const DescribeFolderPermissionsRequestT& request, const DescribeFolderPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeFolderPermissions, request, handler, context); } /** *

Describes the folder resolved permissions. Permissions consists of both * folder direct permissions and the inherited permissions from the ancestor * folders.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFolderResolvedPermissionsOutcome DescribeFolderResolvedPermissions(const Model::DescribeFolderResolvedPermissionsRequest& request) const; /** * A Callable wrapper for DescribeFolderResolvedPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFolderResolvedPermissionsOutcomeCallable DescribeFolderResolvedPermissionsCallable(const DescribeFolderResolvedPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeFolderResolvedPermissions, request); } /** * An Async wrapper for DescribeFolderResolvedPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFolderResolvedPermissionsAsync(const DescribeFolderResolvedPermissionsRequestT& request, const DescribeFolderResolvedPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeFolderResolvedPermissions, request, handler, context); } /** *

Returns an Amazon QuickSight group's description and Amazon Resource Name * (ARN).

See Also:

AWS * API Reference

*/ virtual Model::DescribeGroupOutcome DescribeGroup(const Model::DescribeGroupRequest& request) const; /** * A Callable wrapper for DescribeGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeGroupOutcomeCallable DescribeGroupCallable(const DescribeGroupRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeGroup, request); } /** * An Async wrapper for DescribeGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeGroupAsync(const DescribeGroupRequestT& request, const DescribeGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeGroup, request, handler, context); } /** *

Use the DescribeGroupMembership operation to determine if a user * is a member of the specified group. If the user exists and is a member of the * specified group, an associated GroupMember object is * returned.

See Also:

AWS * API Reference

*/ virtual Model::DescribeGroupMembershipOutcome DescribeGroupMembership(const Model::DescribeGroupMembershipRequest& request) const; /** * A Callable wrapper for DescribeGroupMembership that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeGroupMembershipOutcomeCallable DescribeGroupMembershipCallable(const DescribeGroupMembershipRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeGroupMembership, request); } /** * An Async wrapper for DescribeGroupMembership that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeGroupMembershipAsync(const DescribeGroupMembershipRequestT& request, const DescribeGroupMembershipResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeGroupMembership, request, handler, context); } /** *

Describes an existing IAM policy assignment, as specified by the assignment * name.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIAMPolicyAssignmentOutcome DescribeIAMPolicyAssignment(const Model::DescribeIAMPolicyAssignmentRequest& request) const; /** * A Callable wrapper for DescribeIAMPolicyAssignment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIAMPolicyAssignmentOutcomeCallable DescribeIAMPolicyAssignmentCallable(const DescribeIAMPolicyAssignmentRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeIAMPolicyAssignment, request); } /** * An Async wrapper for DescribeIAMPolicyAssignment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIAMPolicyAssignmentAsync(const DescribeIAMPolicyAssignmentRequestT& request, const DescribeIAMPolicyAssignmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeIAMPolicyAssignment, request, handler, context); } /** *

Describes a SPICE ingestion.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIngestionOutcome DescribeIngestion(const Model::DescribeIngestionRequest& request) const; /** * A Callable wrapper for DescribeIngestion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIngestionOutcomeCallable DescribeIngestionCallable(const DescribeIngestionRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeIngestion, request); } /** * An Async wrapper for DescribeIngestion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIngestionAsync(const DescribeIngestionRequestT& request, const DescribeIngestionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeIngestion, request, handler, context); } /** *

Provides a summary and status of IP rules.

See Also:

AWS * API Reference

*/ virtual Model::DescribeIpRestrictionOutcome DescribeIpRestriction(const Model::DescribeIpRestrictionRequest& request) const; /** * A Callable wrapper for DescribeIpRestriction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIpRestrictionOutcomeCallable DescribeIpRestrictionCallable(const DescribeIpRestrictionRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeIpRestriction, request); } /** * An Async wrapper for DescribeIpRestriction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIpRestrictionAsync(const DescribeIpRestrictionRequestT& request, const DescribeIpRestrictionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeIpRestriction, request, handler, context); } /** *

Describes the current namespace.

See Also:

AWS * API Reference

*/ virtual Model::DescribeNamespaceOutcome DescribeNamespace(const Model::DescribeNamespaceRequest& request) const; /** * A Callable wrapper for DescribeNamespace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNamespaceOutcomeCallable DescribeNamespaceCallable(const DescribeNamespaceRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeNamespace, request); } /** * An Async wrapper for DescribeNamespace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNamespaceAsync(const DescribeNamespaceRequestT& request, const DescribeNamespaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeNamespace, request, handler, context); } /** *

Provides a summary of a refresh schedule.

See Also:

AWS * API Reference

*/ virtual Model::DescribeRefreshScheduleOutcome DescribeRefreshSchedule(const Model::DescribeRefreshScheduleRequest& request) const; /** * A Callable wrapper for DescribeRefreshSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeRefreshScheduleOutcomeCallable DescribeRefreshScheduleCallable(const DescribeRefreshScheduleRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeRefreshSchedule, request); } /** * An Async wrapper for DescribeRefreshSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeRefreshScheduleAsync(const DescribeRefreshScheduleRequestT& request, const DescribeRefreshScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeRefreshSchedule, request, handler, context); } /** *

Describes a template's metadata.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTemplateOutcome DescribeTemplate(const Model::DescribeTemplateRequest& request) const; /** * A Callable wrapper for DescribeTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTemplateOutcomeCallable DescribeTemplateCallable(const DescribeTemplateRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeTemplate, request); } /** * An Async wrapper for DescribeTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTemplateAsync(const DescribeTemplateRequestT& request, const DescribeTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeTemplate, request, handler, context); } /** *

Describes the template alias for a template.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTemplateAliasOutcome DescribeTemplateAlias(const Model::DescribeTemplateAliasRequest& request) const; /** * A Callable wrapper for DescribeTemplateAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTemplateAliasOutcomeCallable DescribeTemplateAliasCallable(const DescribeTemplateAliasRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeTemplateAlias, request); } /** * An Async wrapper for DescribeTemplateAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTemplateAliasAsync(const DescribeTemplateAliasRequestT& request, const DescribeTemplateAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeTemplateAlias, request, handler, context); } /** *

Provides a detailed description of the definition of a template.

*

If you do not need to know details about the content of a template, for * instance if you are trying to check the status of a recently created or updated * template, use the * DescribeTemplate instead.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeTemplateDefinitionOutcome DescribeTemplateDefinition(const Model::DescribeTemplateDefinitionRequest& request) const; /** * A Callable wrapper for DescribeTemplateDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTemplateDefinitionOutcomeCallable DescribeTemplateDefinitionCallable(const DescribeTemplateDefinitionRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeTemplateDefinition, request); } /** * An Async wrapper for DescribeTemplateDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTemplateDefinitionAsync(const DescribeTemplateDefinitionRequestT& request, const DescribeTemplateDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeTemplateDefinition, request, handler, context); } /** *

Describes read and write permissions on a template.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeTemplatePermissionsOutcome DescribeTemplatePermissions(const Model::DescribeTemplatePermissionsRequest& request) const; /** * A Callable wrapper for DescribeTemplatePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTemplatePermissionsOutcomeCallable DescribeTemplatePermissionsCallable(const DescribeTemplatePermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeTemplatePermissions, request); } /** * An Async wrapper for DescribeTemplatePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTemplatePermissionsAsync(const DescribeTemplatePermissionsRequestT& request, const DescribeTemplatePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeTemplatePermissions, request, handler, context); } /** *

Describes a theme.

See Also:

AWS * API Reference

*/ virtual Model::DescribeThemeOutcome DescribeTheme(const Model::DescribeThemeRequest& request) const; /** * A Callable wrapper for DescribeTheme that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeThemeOutcomeCallable DescribeThemeCallable(const DescribeThemeRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeTheme, request); } /** * An Async wrapper for DescribeTheme that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeThemeAsync(const DescribeThemeRequestT& request, const DescribeThemeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeTheme, request, handler, context); } /** *

Describes the alias for a theme.

See Also:

AWS * API Reference

*/ virtual Model::DescribeThemeAliasOutcome DescribeThemeAlias(const Model::DescribeThemeAliasRequest& request) const; /** * A Callable wrapper for DescribeThemeAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeThemeAliasOutcomeCallable DescribeThemeAliasCallable(const DescribeThemeAliasRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeThemeAlias, request); } /** * An Async wrapper for DescribeThemeAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeThemeAliasAsync(const DescribeThemeAliasRequestT& request, const DescribeThemeAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeThemeAlias, request, handler, context); } /** *

Describes the read and write permissions for a theme.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeThemePermissionsOutcome DescribeThemePermissions(const Model::DescribeThemePermissionsRequest& request) const; /** * A Callable wrapper for DescribeThemePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeThemePermissionsOutcomeCallable DescribeThemePermissionsCallable(const DescribeThemePermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeThemePermissions, request); } /** * An Async wrapper for DescribeThemePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeThemePermissionsAsync(const DescribeThemePermissionsRequestT& request, const DescribeThemePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeThemePermissions, request, handler, context); } /** *

Describes a topic.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTopicOutcome DescribeTopic(const Model::DescribeTopicRequest& request) const; /** * A Callable wrapper for DescribeTopic that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTopicOutcomeCallable DescribeTopicCallable(const DescribeTopicRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeTopic, request); } /** * An Async wrapper for DescribeTopic that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTopicAsync(const DescribeTopicRequestT& request, const DescribeTopicResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeTopic, request, handler, context); } /** *

Describes the permissions of a topic.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTopicPermissionsOutcome DescribeTopicPermissions(const Model::DescribeTopicPermissionsRequest& request) const; /** * A Callable wrapper for DescribeTopicPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTopicPermissionsOutcomeCallable DescribeTopicPermissionsCallable(const DescribeTopicPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeTopicPermissions, request); } /** * An Async wrapper for DescribeTopicPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTopicPermissionsAsync(const DescribeTopicPermissionsRequestT& request, const DescribeTopicPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeTopicPermissions, request, handler, context); } /** *

Describes the status of a topic refresh.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTopicRefreshOutcome DescribeTopicRefresh(const Model::DescribeTopicRefreshRequest& request) const; /** * A Callable wrapper for DescribeTopicRefresh that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTopicRefreshOutcomeCallable DescribeTopicRefreshCallable(const DescribeTopicRefreshRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeTopicRefresh, request); } /** * An Async wrapper for DescribeTopicRefresh that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTopicRefreshAsync(const DescribeTopicRefreshRequestT& request, const DescribeTopicRefreshResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeTopicRefresh, request, handler, context); } /** *

Deletes a topic refresh schedule.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTopicRefreshScheduleOutcome DescribeTopicRefreshSchedule(const Model::DescribeTopicRefreshScheduleRequest& request) const; /** * A Callable wrapper for DescribeTopicRefreshSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTopicRefreshScheduleOutcomeCallable DescribeTopicRefreshScheduleCallable(const DescribeTopicRefreshScheduleRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeTopicRefreshSchedule, request); } /** * An Async wrapper for DescribeTopicRefreshSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTopicRefreshScheduleAsync(const DescribeTopicRefreshScheduleRequestT& request, const DescribeTopicRefreshScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeTopicRefreshSchedule, request, handler, context); } /** *

Returns information about a user, given the user name.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeUserOutcome DescribeUser(const Model::DescribeUserRequest& request) const; /** * A Callable wrapper for DescribeUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUserOutcomeCallable DescribeUserCallable(const DescribeUserRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeUser, request); } /** * An Async wrapper for DescribeUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUserAsync(const DescribeUserRequestT& request, const DescribeUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeUser, request, handler, context); } /** *

Describes a VPC connection.

See Also:

AWS * API Reference

*/ virtual Model::DescribeVPCConnectionOutcome DescribeVPCConnection(const Model::DescribeVPCConnectionRequest& request) const; /** * A Callable wrapper for DescribeVPCConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeVPCConnectionOutcomeCallable DescribeVPCConnectionCallable(const DescribeVPCConnectionRequestT& request) const { return SubmitCallable(&QuickSightClient::DescribeVPCConnection, request); } /** * An Async wrapper for DescribeVPCConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeVPCConnectionAsync(const DescribeVPCConnectionRequestT& request, const DescribeVPCConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::DescribeVPCConnection, request, handler, context); } /** *

Generates an embed URL that you can use to embed an Amazon QuickSight * dashboard or visual in your website, without having to register any reader * users. Before you use this action, make sure that you have configured the * dashboards and permissions.

The following rules apply to the generated * URL:

  • It contains a temporary bearer token. It is valid for 5 * minutes after it is generated. Once redeemed within this period, it cannot be * re-used again.

  • The URL validity period should not be confused * with the actual session lifetime that can be customized using the SessionLifetimeInMinutes * parameter. The resulting user session is valid for 15 minutes (minimum) * to 10 hours (maximum). The default session duration is 10 hours.

  • *

    You are charged only when the URL is used or there is interaction with Amazon * QuickSight.

For more information, see Embedded * Analytics in the Amazon QuickSight User Guide.

For more * information about the high-level steps for embedding and for an interactive demo * of the ways you can customize embedding, visit the Amazon * QuickSight Developer Portal.

See Also:

AWS * API Reference

*/ virtual Model::GenerateEmbedUrlForAnonymousUserOutcome GenerateEmbedUrlForAnonymousUser(const Model::GenerateEmbedUrlForAnonymousUserRequest& request) const; /** * A Callable wrapper for GenerateEmbedUrlForAnonymousUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GenerateEmbedUrlForAnonymousUserOutcomeCallable GenerateEmbedUrlForAnonymousUserCallable(const GenerateEmbedUrlForAnonymousUserRequestT& request) const { return SubmitCallable(&QuickSightClient::GenerateEmbedUrlForAnonymousUser, request); } /** * An Async wrapper for GenerateEmbedUrlForAnonymousUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GenerateEmbedUrlForAnonymousUserAsync(const GenerateEmbedUrlForAnonymousUserRequestT& request, const GenerateEmbedUrlForAnonymousUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::GenerateEmbedUrlForAnonymousUser, request, handler, context); } /** *

Generates an embed URL that you can use to embed an Amazon QuickSight * experience in your website. This action can be used for any type of user * registered in an Amazon QuickSight account. Before you use this action, make * sure that you have configured the relevant Amazon QuickSight resource and * permissions.

The following rules apply to the generated URL:

    *

  • It contains a temporary bearer token. It is valid for 5 minutes after it * is generated. Once redeemed within this period, it cannot be re-used again.

    *

  • The URL validity period should not be confused with the actual * session lifetime that can be customized using the SessionLifetimeInMinutes * parameter.

    The resulting user session is valid for 15 minutes * (minimum) to 10 hours (maximum). The default session duration is 10 hours.

    *

  • You are charged only when the URL is used or there is interaction * with Amazon QuickSight.

For more information, see Embedded * Analytics in the Amazon QuickSight User Guide.

For more * information about the high-level steps for embedding and for an interactive demo * of the ways you can customize embedding, visit the Amazon * QuickSight Developer Portal.

See Also:

AWS * API Reference

*/ virtual Model::GenerateEmbedUrlForRegisteredUserOutcome GenerateEmbedUrlForRegisteredUser(const Model::GenerateEmbedUrlForRegisteredUserRequest& request) const; /** * A Callable wrapper for GenerateEmbedUrlForRegisteredUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GenerateEmbedUrlForRegisteredUserOutcomeCallable GenerateEmbedUrlForRegisteredUserCallable(const GenerateEmbedUrlForRegisteredUserRequestT& request) const { return SubmitCallable(&QuickSightClient::GenerateEmbedUrlForRegisteredUser, request); } /** * An Async wrapper for GenerateEmbedUrlForRegisteredUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GenerateEmbedUrlForRegisteredUserAsync(const GenerateEmbedUrlForRegisteredUserRequestT& request, const GenerateEmbedUrlForRegisteredUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::GenerateEmbedUrlForRegisteredUser, request, handler, context); } /** *

Generates a temporary session URL and authorization code(bearer token) that * you can use to embed an Amazon QuickSight read-only dashboard in your website or * application. Before you use this command, make sure that you have configured the * dashboards and permissions.

Currently, you can use * GetDashboardEmbedURL only from the server, not from the user's * browser. The following rules apply to the generated URL:

  • They * must be used together.

  • They can be used one time only.

    *

  • They are valid for 5 minutes after you run this command.

    • *

  • You are charged only when the URL is used or there is interaction with * Amazon QuickSight.

  • The resulting user session is valid for 15 * minutes (default) up to 10 hours (maximum). You can use the optional * SessionLifetimeInMinutes parameter to customize session * duration.

For more information, see Embedding * Analytics Using GetDashboardEmbedUrl in the Amazon QuickSight User * Guide.

For more information about the high-level steps for embedding * and for an interactive demo of the ways you can customize embedding, visit the * Amazon * QuickSight Developer Portal.

See Also:

AWS * API Reference

*/ virtual Model::GetDashboardEmbedUrlOutcome GetDashboardEmbedUrl(const Model::GetDashboardEmbedUrlRequest& request) const; /** * A Callable wrapper for GetDashboardEmbedUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDashboardEmbedUrlOutcomeCallable GetDashboardEmbedUrlCallable(const GetDashboardEmbedUrlRequestT& request) const { return SubmitCallable(&QuickSightClient::GetDashboardEmbedUrl, request); } /** * An Async wrapper for GetDashboardEmbedUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDashboardEmbedUrlAsync(const GetDashboardEmbedUrlRequestT& request, const GetDashboardEmbedUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::GetDashboardEmbedUrl, request, handler, context); } /** *

Generates a session URL and authorization code that you can use to embed the * Amazon Amazon QuickSight console in your web server code. Use * GetSessionEmbedUrl where you want to provide an authoring portal * that allows users to create data sources, datasets, analyses, and dashboards. * The users who access an embedded Amazon QuickSight console need belong to the * author or admin security cohort. If you want to restrict permissions to some of * these features, add a custom permissions profile to the user with the UpdateUser * API operation. Use RegisterUser * API operation to add a new user with a custom permission profile * attached. For more information, see the following sections in the Amazon * QuickSight User Guide:

See * Also:

AWS * API Reference

*/ virtual Model::GetSessionEmbedUrlOutcome GetSessionEmbedUrl(const Model::GetSessionEmbedUrlRequest& request) const; /** * A Callable wrapper for GetSessionEmbedUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSessionEmbedUrlOutcomeCallable GetSessionEmbedUrlCallable(const GetSessionEmbedUrlRequestT& request) const { return SubmitCallable(&QuickSightClient::GetSessionEmbedUrl, request); } /** * An Async wrapper for GetSessionEmbedUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSessionEmbedUrlAsync(const GetSessionEmbedUrlRequestT& request, const GetSessionEmbedUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::GetSessionEmbedUrl, request, handler, context); } /** *

Lists Amazon QuickSight analyses that exist in the specified Amazon Web * Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListAnalysesOutcome ListAnalyses(const Model::ListAnalysesRequest& request) const; /** * A Callable wrapper for ListAnalyses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAnalysesOutcomeCallable ListAnalysesCallable(const ListAnalysesRequestT& request) const { return SubmitCallable(&QuickSightClient::ListAnalyses, request); } /** * An Async wrapper for ListAnalyses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAnalysesAsync(const ListAnalysesRequestT& request, const ListAnalysesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListAnalyses, request, handler, context); } /** *

Lists all asset bundle export jobs that have been taken place in the last 14 * days. Jobs created more than 14 days ago are deleted forever and are not * returned. If you are using the same job ID for multiple jobs, * ListAssetBundleExportJobs only returns the most recent job that * uses the repeated job ID.

See Also:

AWS * API Reference

*/ virtual Model::ListAssetBundleExportJobsOutcome ListAssetBundleExportJobs(const Model::ListAssetBundleExportJobsRequest& request) const; /** * A Callable wrapper for ListAssetBundleExportJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssetBundleExportJobsOutcomeCallable ListAssetBundleExportJobsCallable(const ListAssetBundleExportJobsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListAssetBundleExportJobs, request); } /** * An Async wrapper for ListAssetBundleExportJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssetBundleExportJobsAsync(const ListAssetBundleExportJobsRequestT& request, const ListAssetBundleExportJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListAssetBundleExportJobs, request, handler, context); } /** *

Lists all asset bundle import jobs that have taken place in the last 14 days. * Jobs created more than 14 days ago are deleted forever and are not returned. If * you are using the same job ID for multiple jobs, * ListAssetBundleImportJobs only returns the most recent job that * uses the repeated job ID.

See Also:

AWS * API Reference

*/ virtual Model::ListAssetBundleImportJobsOutcome ListAssetBundleImportJobs(const Model::ListAssetBundleImportJobsRequest& request) const; /** * A Callable wrapper for ListAssetBundleImportJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssetBundleImportJobsOutcomeCallable ListAssetBundleImportJobsCallable(const ListAssetBundleImportJobsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListAssetBundleImportJobs, request); } /** * An Async wrapper for ListAssetBundleImportJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssetBundleImportJobsAsync(const ListAssetBundleImportJobsRequestT& request, const ListAssetBundleImportJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListAssetBundleImportJobs, request, handler, context); } /** *

Lists all the versions of the dashboards in the Amazon QuickSight * subscription.

See Also:

AWS * API Reference

*/ virtual Model::ListDashboardVersionsOutcome ListDashboardVersions(const Model::ListDashboardVersionsRequest& request) const; /** * A Callable wrapper for ListDashboardVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDashboardVersionsOutcomeCallable ListDashboardVersionsCallable(const ListDashboardVersionsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListDashboardVersions, request); } /** * An Async wrapper for ListDashboardVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDashboardVersionsAsync(const ListDashboardVersionsRequestT& request, const ListDashboardVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListDashboardVersions, request, handler, context); } /** *

Lists dashboards in an Amazon Web Services account.

See Also:

* AWS * API Reference

*/ virtual Model::ListDashboardsOutcome ListDashboards(const Model::ListDashboardsRequest& request) const; /** * A Callable wrapper for ListDashboards that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDashboardsOutcomeCallable ListDashboardsCallable(const ListDashboardsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListDashboards, request); } /** * An Async wrapper for ListDashboards that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDashboardsAsync(const ListDashboardsRequestT& request, const ListDashboardsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListDashboards, request, handler, context); } /** *

Lists all of the datasets belonging to the current Amazon Web Services * account in an Amazon Web Services Region.

The permissions resource is * arn:aws:quicksight:region:aws-account-id:dataset/ *.

See * Also:

AWS * API Reference

*/ virtual Model::ListDataSetsOutcome ListDataSets(const Model::ListDataSetsRequest& request) const; /** * A Callable wrapper for ListDataSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDataSetsOutcomeCallable ListDataSetsCallable(const ListDataSetsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListDataSets, request); } /** * An Async wrapper for ListDataSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDataSetsAsync(const ListDataSetsRequestT& request, const ListDataSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListDataSets, request, handler, context); } /** *

Lists data sources in current Amazon Web Services Region that belong to this * Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListDataSourcesOutcome ListDataSources(const Model::ListDataSourcesRequest& request) const; /** * A Callable wrapper for ListDataSources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDataSourcesOutcomeCallable ListDataSourcesCallable(const ListDataSourcesRequestT& request) const { return SubmitCallable(&QuickSightClient::ListDataSources, request); } /** * An Async wrapper for ListDataSources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDataSourcesAsync(const ListDataSourcesRequestT& request, const ListDataSourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListDataSources, request, handler, context); } /** *

List all assets (DASHBOARD, ANALYSIS, and * DATASET) in a folder.

See Also:

AWS * API Reference

*/ virtual Model::ListFolderMembersOutcome ListFolderMembers(const Model::ListFolderMembersRequest& request) const; /** * A Callable wrapper for ListFolderMembers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFolderMembersOutcomeCallable ListFolderMembersCallable(const ListFolderMembersRequestT& request) const { return SubmitCallable(&QuickSightClient::ListFolderMembers, request); } /** * An Async wrapper for ListFolderMembers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFolderMembersAsync(const ListFolderMembersRequestT& request, const ListFolderMembersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListFolderMembers, request, handler, context); } /** *

Lists all folders in an account.

See Also:

AWS * API Reference

*/ virtual Model::ListFoldersOutcome ListFolders(const Model::ListFoldersRequest& request) const; /** * A Callable wrapper for ListFolders that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFoldersOutcomeCallable ListFoldersCallable(const ListFoldersRequestT& request) const { return SubmitCallable(&QuickSightClient::ListFolders, request); } /** * An Async wrapper for ListFolders that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFoldersAsync(const ListFoldersRequestT& request, const ListFoldersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListFolders, request, handler, context); } /** *

Lists member users in a group.

See Also:

AWS * API Reference

*/ virtual Model::ListGroupMembershipsOutcome ListGroupMemberships(const Model::ListGroupMembershipsRequest& request) const; /** * A Callable wrapper for ListGroupMemberships that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListGroupMembershipsOutcomeCallable ListGroupMembershipsCallable(const ListGroupMembershipsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListGroupMemberships, request); } /** * An Async wrapper for ListGroupMemberships that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListGroupMembershipsAsync(const ListGroupMembershipsRequestT& request, const ListGroupMembershipsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListGroupMemberships, request, handler, context); } /** *

Lists all user groups in Amazon QuickSight.

See Also:

AWS * API Reference

*/ virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request) const; /** * A Callable wrapper for ListGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListGroupsOutcomeCallable ListGroupsCallable(const ListGroupsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListGroups, request); } /** * An Async wrapper for ListGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListGroupsAsync(const ListGroupsRequestT& request, const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListGroups, request, handler, context); } /** *

Lists the IAM policy assignments in the current Amazon QuickSight * account.

See Also:

AWS * API Reference

*/ virtual Model::ListIAMPolicyAssignmentsOutcome ListIAMPolicyAssignments(const Model::ListIAMPolicyAssignmentsRequest& request) const; /** * A Callable wrapper for ListIAMPolicyAssignments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIAMPolicyAssignmentsOutcomeCallable ListIAMPolicyAssignmentsCallable(const ListIAMPolicyAssignmentsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListIAMPolicyAssignments, request); } /** * An Async wrapper for ListIAMPolicyAssignments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIAMPolicyAssignmentsAsync(const ListIAMPolicyAssignmentsRequestT& request, const ListIAMPolicyAssignmentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListIAMPolicyAssignments, request, handler, context); } /** *

Lists all of the IAM policy assignments, including the Amazon Resource Names * (ARNs), for the IAM policies assigned to the specified user and group, or groups * that the user belongs to.

See Also:

AWS * API Reference

*/ virtual Model::ListIAMPolicyAssignmentsForUserOutcome ListIAMPolicyAssignmentsForUser(const Model::ListIAMPolicyAssignmentsForUserRequest& request) const; /** * A Callable wrapper for ListIAMPolicyAssignmentsForUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIAMPolicyAssignmentsForUserOutcomeCallable ListIAMPolicyAssignmentsForUserCallable(const ListIAMPolicyAssignmentsForUserRequestT& request) const { return SubmitCallable(&QuickSightClient::ListIAMPolicyAssignmentsForUser, request); } /** * An Async wrapper for ListIAMPolicyAssignmentsForUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIAMPolicyAssignmentsForUserAsync(const ListIAMPolicyAssignmentsForUserRequestT& request, const ListIAMPolicyAssignmentsForUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListIAMPolicyAssignmentsForUser, request, handler, context); } /** *

Lists the history of SPICE ingestions for a dataset.

See Also:

* AWS * API Reference

*/ virtual Model::ListIngestionsOutcome ListIngestions(const Model::ListIngestionsRequest& request) const; /** * A Callable wrapper for ListIngestions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIngestionsOutcomeCallable ListIngestionsCallable(const ListIngestionsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListIngestions, request); } /** * An Async wrapper for ListIngestions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIngestionsAsync(const ListIngestionsRequestT& request, const ListIngestionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListIngestions, request, handler, context); } /** *

Lists the namespaces for the specified Amazon Web Services account. This * operation doesn't list deleted namespaces.

See Also:

AWS * API Reference

*/ virtual Model::ListNamespacesOutcome ListNamespaces(const Model::ListNamespacesRequest& request) const; /** * A Callable wrapper for ListNamespaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListNamespacesOutcomeCallable ListNamespacesCallable(const ListNamespacesRequestT& request) const { return SubmitCallable(&QuickSightClient::ListNamespaces, request); } /** * An Async wrapper for ListNamespaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListNamespacesAsync(const ListNamespacesRequestT& request, const ListNamespacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListNamespaces, request, handler, context); } /** *

Lists the refresh schedules of a dataset. Each dataset can have up to 5 * schedules.

See Also:

AWS * API Reference

*/ virtual Model::ListRefreshSchedulesOutcome ListRefreshSchedules(const Model::ListRefreshSchedulesRequest& request) const; /** * A Callable wrapper for ListRefreshSchedules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRefreshSchedulesOutcomeCallable ListRefreshSchedulesCallable(const ListRefreshSchedulesRequestT& request) const { return SubmitCallable(&QuickSightClient::ListRefreshSchedules, request); } /** * An Async wrapper for ListRefreshSchedules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRefreshSchedulesAsync(const ListRefreshSchedulesRequestT& request, const ListRefreshSchedulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListRefreshSchedules, request, handler, context); } /** *

Lists the tags assigned to a 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(&QuickSightClient::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(&QuickSightClient::ListTagsForResource, request, handler, context); } /** *

Lists all the aliases of a template.

See Also:

AWS * API Reference

*/ virtual Model::ListTemplateAliasesOutcome ListTemplateAliases(const Model::ListTemplateAliasesRequest& request) const; /** * A Callable wrapper for ListTemplateAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTemplateAliasesOutcomeCallable ListTemplateAliasesCallable(const ListTemplateAliasesRequestT& request) const { return SubmitCallable(&QuickSightClient::ListTemplateAliases, request); } /** * An Async wrapper for ListTemplateAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTemplateAliasesAsync(const ListTemplateAliasesRequestT& request, const ListTemplateAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListTemplateAliases, request, handler, context); } /** *

Lists all the versions of the templates in the current Amazon QuickSight * account.

See Also:

AWS * API Reference

*/ virtual Model::ListTemplateVersionsOutcome ListTemplateVersions(const Model::ListTemplateVersionsRequest& request) const; /** * A Callable wrapper for ListTemplateVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTemplateVersionsOutcomeCallable ListTemplateVersionsCallable(const ListTemplateVersionsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListTemplateVersions, request); } /** * An Async wrapper for ListTemplateVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTemplateVersionsAsync(const ListTemplateVersionsRequestT& request, const ListTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListTemplateVersions, request, handler, context); } /** *

Lists all the templates in the current Amazon QuickSight * account.

See Also:

AWS * API Reference

*/ virtual Model::ListTemplatesOutcome ListTemplates(const Model::ListTemplatesRequest& request) const; /** * A Callable wrapper for ListTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTemplatesOutcomeCallable ListTemplatesCallable(const ListTemplatesRequestT& request) const { return SubmitCallable(&QuickSightClient::ListTemplates, request); } /** * An Async wrapper for ListTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTemplatesAsync(const ListTemplatesRequestT& request, const ListTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListTemplates, request, handler, context); } /** *

Lists all the aliases of a theme.

See Also:

AWS * API Reference

*/ virtual Model::ListThemeAliasesOutcome ListThemeAliases(const Model::ListThemeAliasesRequest& request) const; /** * A Callable wrapper for ListThemeAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThemeAliasesOutcomeCallable ListThemeAliasesCallable(const ListThemeAliasesRequestT& request) const { return SubmitCallable(&QuickSightClient::ListThemeAliases, request); } /** * An Async wrapper for ListThemeAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThemeAliasesAsync(const ListThemeAliasesRequestT& request, const ListThemeAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListThemeAliases, request, handler, context); } /** *

Lists all the versions of the themes in the current Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::ListThemeVersionsOutcome ListThemeVersions(const Model::ListThemeVersionsRequest& request) const; /** * A Callable wrapper for ListThemeVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThemeVersionsOutcomeCallable ListThemeVersionsCallable(const ListThemeVersionsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListThemeVersions, request); } /** * An Async wrapper for ListThemeVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThemeVersionsAsync(const ListThemeVersionsRequestT& request, const ListThemeVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListThemeVersions, request, handler, context); } /** *

Lists all the themes in the current Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::ListThemesOutcome ListThemes(const Model::ListThemesRequest& request) const; /** * A Callable wrapper for ListThemes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListThemesOutcomeCallable ListThemesCallable(const ListThemesRequestT& request) const { return SubmitCallable(&QuickSightClient::ListThemes, request); } /** * An Async wrapper for ListThemes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListThemesAsync(const ListThemesRequestT& request, const ListThemesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListThemes, request, handler, context); } /** *

Lists all of the refresh schedules for a topic.

See Also:

AWS * API Reference

*/ virtual Model::ListTopicRefreshSchedulesOutcome ListTopicRefreshSchedules(const Model::ListTopicRefreshSchedulesRequest& request) const; /** * A Callable wrapper for ListTopicRefreshSchedules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTopicRefreshSchedulesOutcomeCallable ListTopicRefreshSchedulesCallable(const ListTopicRefreshSchedulesRequestT& request) const { return SubmitCallable(&QuickSightClient::ListTopicRefreshSchedules, request); } /** * An Async wrapper for ListTopicRefreshSchedules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTopicRefreshSchedulesAsync(const ListTopicRefreshSchedulesRequestT& request, const ListTopicRefreshSchedulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListTopicRefreshSchedules, request, handler, context); } /** *

Lists all of the topics within an account.

See Also:

AWS * API Reference

*/ virtual Model::ListTopicsOutcome ListTopics(const Model::ListTopicsRequest& request) const; /** * A Callable wrapper for ListTopics that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTopicsOutcomeCallable ListTopicsCallable(const ListTopicsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListTopics, request); } /** * An Async wrapper for ListTopics that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTopicsAsync(const ListTopicsRequestT& request, const ListTopicsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListTopics, request, handler, context); } /** *

Lists the Amazon QuickSight groups that an Amazon QuickSight user is a member * of.

See Also:

AWS * API Reference

*/ virtual Model::ListUserGroupsOutcome ListUserGroups(const Model::ListUserGroupsRequest& request) const; /** * A Callable wrapper for ListUserGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListUserGroupsOutcomeCallable ListUserGroupsCallable(const ListUserGroupsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListUserGroups, request); } /** * An Async wrapper for ListUserGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListUserGroupsAsync(const ListUserGroupsRequestT& request, const ListUserGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListUserGroups, request, handler, context); } /** *

Returns a list of all of the Amazon QuickSight users belonging to this * account.

See Also:

AWS * API Reference

*/ virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const; /** * A Callable wrapper for ListUsers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListUsersOutcomeCallable ListUsersCallable(const ListUsersRequestT& request) const { return SubmitCallable(&QuickSightClient::ListUsers, request); } /** * An Async wrapper for ListUsers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListUsersAsync(const ListUsersRequestT& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListUsers, request, handler, context); } /** *

Lists all of the VPC connections in the current set Amazon Web Services * Region of an Amazon Web Services account.

See Also:

AWS * API Reference

*/ virtual Model::ListVPCConnectionsOutcome ListVPCConnections(const Model::ListVPCConnectionsRequest& request) const; /** * A Callable wrapper for ListVPCConnections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListVPCConnectionsOutcomeCallable ListVPCConnectionsCallable(const ListVPCConnectionsRequestT& request) const { return SubmitCallable(&QuickSightClient::ListVPCConnections, request); } /** * An Async wrapper for ListVPCConnections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListVPCConnectionsAsync(const ListVPCConnectionsRequestT& request, const ListVPCConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::ListVPCConnections, request, handler, context); } /** *

Creates or updates the dataset refresh properties for the * dataset.

See Also:

AWS * API Reference

*/ virtual Model::PutDataSetRefreshPropertiesOutcome PutDataSetRefreshProperties(const Model::PutDataSetRefreshPropertiesRequest& request) const; /** * A Callable wrapper for PutDataSetRefreshProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutDataSetRefreshPropertiesOutcomeCallable PutDataSetRefreshPropertiesCallable(const PutDataSetRefreshPropertiesRequestT& request) const { return SubmitCallable(&QuickSightClient::PutDataSetRefreshProperties, request); } /** * An Async wrapper for PutDataSetRefreshProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutDataSetRefreshPropertiesAsync(const PutDataSetRefreshPropertiesRequestT& request, const PutDataSetRefreshPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::PutDataSetRefreshProperties, request, handler, context); } /** *

Creates an Amazon QuickSight user whose identity is associated with the * Identity and Access Management (IAM) identity or role specified in the request. * When you register a new user from the Amazon QuickSight API, Amazon QuickSight * generates a registration URL. The user accesses this registration URL to create * their account. Amazon QuickSight doesn't send a registration email to users who * are registered from the Amazon QuickSight API. If you want new users to receive * a registration email, then add those users in the Amazon QuickSight console. For * more information on registering a new user in the Amazon QuickSight console, see * * Inviting users to access Amazon QuickSight.

See Also:

AWS * API Reference

*/ virtual Model::RegisterUserOutcome RegisterUser(const Model::RegisterUserRequest& request) const; /** * A Callable wrapper for RegisterUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterUserOutcomeCallable RegisterUserCallable(const RegisterUserRequestT& request) const { return SubmitCallable(&QuickSightClient::RegisterUser, request); } /** * An Async wrapper for RegisterUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterUserAsync(const RegisterUserRequestT& request, const RegisterUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::RegisterUser, request, handler, context); } /** *

Restores an analysis.

See Also:

AWS * API Reference

*/ virtual Model::RestoreAnalysisOutcome RestoreAnalysis(const Model::RestoreAnalysisRequest& request) const; /** * A Callable wrapper for RestoreAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreAnalysisOutcomeCallable RestoreAnalysisCallable(const RestoreAnalysisRequestT& request) const { return SubmitCallable(&QuickSightClient::RestoreAnalysis, request); } /** * An Async wrapper for RestoreAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreAnalysisAsync(const RestoreAnalysisRequestT& request, const RestoreAnalysisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::RestoreAnalysis, request, handler, context); } /** *

Searches for analyses that belong to the user specified in the filter.

*

This operation is eventually consistent. The results are best effort * and may not reflect very recent updates and changes.

See * Also:

AWS * API Reference

*/ virtual Model::SearchAnalysesOutcome SearchAnalyses(const Model::SearchAnalysesRequest& request) const; /** * A Callable wrapper for SearchAnalyses that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchAnalysesOutcomeCallable SearchAnalysesCallable(const SearchAnalysesRequestT& request) const { return SubmitCallable(&QuickSightClient::SearchAnalyses, request); } /** * An Async wrapper for SearchAnalyses that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchAnalysesAsync(const SearchAnalysesRequestT& request, const SearchAnalysesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::SearchAnalyses, request, handler, context); } /** *

Searches for dashboards that belong to a user.

This operation * is eventually consistent. The results are best effort and may not reflect very * recent updates and changes.

See Also:

AWS * API Reference

*/ virtual Model::SearchDashboardsOutcome SearchDashboards(const Model::SearchDashboardsRequest& request) const; /** * A Callable wrapper for SearchDashboards that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchDashboardsOutcomeCallable SearchDashboardsCallable(const SearchDashboardsRequestT& request) const { return SubmitCallable(&QuickSightClient::SearchDashboards, request); } /** * An Async wrapper for SearchDashboards that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchDashboardsAsync(const SearchDashboardsRequestT& request, const SearchDashboardsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::SearchDashboards, request, handler, context); } /** *

Use the SearchDataSets operation to search for datasets that * belong to an account.

See Also:

AWS * API Reference

*/ virtual Model::SearchDataSetsOutcome SearchDataSets(const Model::SearchDataSetsRequest& request) const; /** * A Callable wrapper for SearchDataSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchDataSetsOutcomeCallable SearchDataSetsCallable(const SearchDataSetsRequestT& request) const { return SubmitCallable(&QuickSightClient::SearchDataSets, request); } /** * An Async wrapper for SearchDataSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchDataSetsAsync(const SearchDataSetsRequestT& request, const SearchDataSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::SearchDataSets, request, handler, context); } /** *

Use the SearchDataSources operation to search for data sources * that belong to an account.

See Also:

AWS * API Reference

*/ virtual Model::SearchDataSourcesOutcome SearchDataSources(const Model::SearchDataSourcesRequest& request) const; /** * A Callable wrapper for SearchDataSources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchDataSourcesOutcomeCallable SearchDataSourcesCallable(const SearchDataSourcesRequestT& request) const { return SubmitCallable(&QuickSightClient::SearchDataSources, request); } /** * An Async wrapper for SearchDataSources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchDataSourcesAsync(const SearchDataSourcesRequestT& request, const SearchDataSourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::SearchDataSources, request, handler, context); } /** *

Searches the subfolders in a folder.

See Also:

AWS * API Reference

*/ virtual Model::SearchFoldersOutcome SearchFolders(const Model::SearchFoldersRequest& request) const; /** * A Callable wrapper for SearchFolders that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchFoldersOutcomeCallable SearchFoldersCallable(const SearchFoldersRequestT& request) const { return SubmitCallable(&QuickSightClient::SearchFolders, request); } /** * An Async wrapper for SearchFolders that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchFoldersAsync(const SearchFoldersRequestT& request, const SearchFoldersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::SearchFolders, request, handler, context); } /** *

Use the SearchGroups operation to search groups in a specified * Amazon QuickSight namespace using the supplied filters.

See Also:

* AWS * API Reference

*/ virtual Model::SearchGroupsOutcome SearchGroups(const Model::SearchGroupsRequest& request) const; /** * A Callable wrapper for SearchGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchGroupsOutcomeCallable SearchGroupsCallable(const SearchGroupsRequestT& request) const { return SubmitCallable(&QuickSightClient::SearchGroups, request); } /** * An Async wrapper for SearchGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchGroupsAsync(const SearchGroupsRequestT& request, const SearchGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::SearchGroups, request, handler, context); } /** *

Starts an Asset Bundle export job.

An Asset Bundle export job exports * specified Amazon QuickSight assets. You can also choose to export any asset * dependencies in the same job. Export jobs run asynchronously and can be polled * with a DescribeAssetBundleExportJob API call. When a job is * successfully completed, a download URL that contains the exported assets is * returned. The URL is valid for 5 minutes and can be refreshed with a * DescribeAssetBundleExportJob API call. Each Amazon QuickSight * account can run up to 5 export jobs concurrently.

The API caller must * have the necessary permissions in their IAM role to access each resource before * the resources can be exported.

See Also:

AWS * API Reference

*/ virtual Model::StartAssetBundleExportJobOutcome StartAssetBundleExportJob(const Model::StartAssetBundleExportJobRequest& request) const; /** * A Callable wrapper for StartAssetBundleExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartAssetBundleExportJobOutcomeCallable StartAssetBundleExportJobCallable(const StartAssetBundleExportJobRequestT& request) const { return SubmitCallable(&QuickSightClient::StartAssetBundleExportJob, request); } /** * An Async wrapper for StartAssetBundleExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartAssetBundleExportJobAsync(const StartAssetBundleExportJobRequestT& request, const StartAssetBundleExportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::StartAssetBundleExportJob, request, handler, context); } /** *

Starts an Asset Bundle import job.

An Asset Bundle import job imports * specified Amazon QuickSight assets into an Amazon QuickSight account. You can * also choose to import a naming prefix and specified configuration overrides. The * assets that are contained in the bundle file that you provide are used to create * or update a new or existing asset in your Amazon QuickSight account. Each Amazon * QuickSight account can run up to 5 import jobs concurrently.

The API * caller must have the necessary "create", "describe", * and "update" permissions in their IAM role to access each resource * type that is contained in the bundle file before the resources can be * imported.

See Also:

AWS * API Reference

*/ virtual Model::StartAssetBundleImportJobOutcome StartAssetBundleImportJob(const Model::StartAssetBundleImportJobRequest& request) const; /** * A Callable wrapper for StartAssetBundleImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartAssetBundleImportJobOutcomeCallable StartAssetBundleImportJobCallable(const StartAssetBundleImportJobRequestT& request) const { return SubmitCallable(&QuickSightClient::StartAssetBundleImportJob, request); } /** * An Async wrapper for StartAssetBundleImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartAssetBundleImportJobAsync(const StartAssetBundleImportJobRequestT& request, const StartAssetBundleImportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::StartAssetBundleImportJob, request, handler, context); } /** *

Starts an asynchronous job that generates a dashboard snapshot. You can * request up to one paginated PDF and up to five CSVs per API call.

Poll * job descriptions with a DescribeDashboardSnapshotJob API call. Once * the job succeeds, use the DescribeDashboardSnapshotJobResult API to * obtain the download URIs that the job generates.

See Also:

AWS * API Reference

*/ virtual Model::StartDashboardSnapshotJobOutcome StartDashboardSnapshotJob(const Model::StartDashboardSnapshotJobRequest& request) const; /** * A Callable wrapper for StartDashboardSnapshotJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartDashboardSnapshotJobOutcomeCallable StartDashboardSnapshotJobCallable(const StartDashboardSnapshotJobRequestT& request) const { return SubmitCallable(&QuickSightClient::StartDashboardSnapshotJob, request); } /** * An Async wrapper for StartDashboardSnapshotJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartDashboardSnapshotJobAsync(const StartDashboardSnapshotJobRequestT& request, const StartDashboardSnapshotJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::StartDashboardSnapshotJob, request, handler, context); } /** *

Assigns one or more tags (key-value pairs) to the specified Amazon QuickSight * resource.

Tags can help you organize and categorize your resources. You * can also use them to scope user permissions, by granting a user permission to * access or change only resources with certain tag values. You can use the * TagResource operation with a resource that already has tags. If you * specify a new tag key for the resource, this tag is appended to the list of tags * associated with the resource. If you specify a tag key that is already * associated with the resource, the new tag value that you specify replaces the * previous value for that tag.

You can associate as many as 50 tags with a * resource. Amazon QuickSight supports tagging on data set, data source, * dashboard, template, and topic.

Tagging for Amazon QuickSight works in a * similar way to tagging for other Amazon Web Services services, except for the * following:

  • You can't use tags to track costs for Amazon * QuickSight. This isn't possible because you can't tag the resources that Amazon * QuickSight costs are based on, for example Amazon QuickSight storage capacity * (SPICE), number of users, type of users, and usage metrics.

  • *

    Amazon QuickSight doesn't currently support the tag editor for Resource * Groups.

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(&QuickSightClient::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(&QuickSightClient::TagResource, request, handler, context); } /** *

Removes a tag or 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(&QuickSightClient::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(&QuickSightClient::UntagResource, request, handler, context); } /** *

Updates Amazon QuickSight customizations for the current Amazon Web Services * Region. Currently, the only customization that you can use is a theme.

*

You can use customizations for your Amazon Web Services account or, if you * specify a namespace, for a Amazon QuickSight namespace instead. Customizations * that apply to a namespace override customizations that apply to an Amazon Web * Services account. To find out which customizations apply, use the * DescribeAccountCustomization API operation.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateAccountCustomizationOutcome UpdateAccountCustomization(const Model::UpdateAccountCustomizationRequest& request) const; /** * A Callable wrapper for UpdateAccountCustomization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAccountCustomizationOutcomeCallable UpdateAccountCustomizationCallable(const UpdateAccountCustomizationRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateAccountCustomization, request); } /** * An Async wrapper for UpdateAccountCustomization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAccountCustomizationAsync(const UpdateAccountCustomizationRequestT& request, const UpdateAccountCustomizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateAccountCustomization, request, handler, context); } /** *

Updates the Amazon QuickSight settings in your Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request) const; /** * A Callable wrapper for UpdateAccountSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateAccountSettings, request); } /** * An Async wrapper for UpdateAccountSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAccountSettingsAsync(const UpdateAccountSettingsRequestT& request, const UpdateAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateAccountSettings, request, handler, context); } /** *

Updates an analysis in Amazon QuickSight

See Also:

AWS * API Reference

*/ virtual Model::UpdateAnalysisOutcome UpdateAnalysis(const Model::UpdateAnalysisRequest& request) const; /** * A Callable wrapper for UpdateAnalysis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAnalysisOutcomeCallable UpdateAnalysisCallable(const UpdateAnalysisRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateAnalysis, request); } /** * An Async wrapper for UpdateAnalysis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAnalysisAsync(const UpdateAnalysisRequestT& request, const UpdateAnalysisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateAnalysis, request, handler, context); } /** *

Updates the read and write permissions for an analysis.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateAnalysisPermissionsOutcome UpdateAnalysisPermissions(const Model::UpdateAnalysisPermissionsRequest& request) const; /** * A Callable wrapper for UpdateAnalysisPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAnalysisPermissionsOutcomeCallable UpdateAnalysisPermissionsCallable(const UpdateAnalysisPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateAnalysisPermissions, request); } /** * An Async wrapper for UpdateAnalysisPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAnalysisPermissionsAsync(const UpdateAnalysisPermissionsRequestT& request, const UpdateAnalysisPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateAnalysisPermissions, request, handler, context); } /** *

Updates a dashboard in an Amazon Web Services account.

Updating * a Dashboard creates a new dashboard version but does not immediately publish the * new version. You can update the published version of a dashboard by using the * UpdateDashboardPublishedVersion * API operation.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDashboardOutcome UpdateDashboard(const Model::UpdateDashboardRequest& request) const; /** * A Callable wrapper for UpdateDashboard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDashboardOutcomeCallable UpdateDashboardCallable(const UpdateDashboardRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateDashboard, request); } /** * An Async wrapper for UpdateDashboard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDashboardAsync(const UpdateDashboardRequestT& request, const UpdateDashboardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateDashboard, request, handler, context); } /** *

Updates read and write permissions on a dashboard.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateDashboardPermissionsOutcome UpdateDashboardPermissions(const Model::UpdateDashboardPermissionsRequest& request) const; /** * A Callable wrapper for UpdateDashboardPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDashboardPermissionsOutcomeCallable UpdateDashboardPermissionsCallable(const UpdateDashboardPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateDashboardPermissions, request); } /** * An Async wrapper for UpdateDashboardPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDashboardPermissionsAsync(const UpdateDashboardPermissionsRequestT& request, const UpdateDashboardPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateDashboardPermissions, request, handler, context); } /** *

Updates the published version of a dashboard.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDashboardPublishedVersionOutcome UpdateDashboardPublishedVersion(const Model::UpdateDashboardPublishedVersionRequest& request) const; /** * A Callable wrapper for UpdateDashboardPublishedVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDashboardPublishedVersionOutcomeCallable UpdateDashboardPublishedVersionCallable(const UpdateDashboardPublishedVersionRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateDashboardPublishedVersion, request); } /** * An Async wrapper for UpdateDashboardPublishedVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDashboardPublishedVersionAsync(const UpdateDashboardPublishedVersionRequestT& request, const UpdateDashboardPublishedVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateDashboardPublishedVersion, request, handler, context); } /** *

Updates a dataset. This operation doesn't support datasets that include * uploaded files as a source. Partial updates are not supported by this * operation.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDataSetOutcome UpdateDataSet(const Model::UpdateDataSetRequest& request) const; /** * A Callable wrapper for UpdateDataSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDataSetOutcomeCallable UpdateDataSetCallable(const UpdateDataSetRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateDataSet, request); } /** * An Async wrapper for UpdateDataSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDataSetAsync(const UpdateDataSetRequestT& request, const UpdateDataSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateDataSet, request, handler, context); } /** *

Updates the permissions on a dataset.

The permissions resource is * arn:aws:quicksight:region:aws-account-id:dataset/data-set-id.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateDataSetPermissionsOutcome UpdateDataSetPermissions(const Model::UpdateDataSetPermissionsRequest& request) const; /** * A Callable wrapper for UpdateDataSetPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDataSetPermissionsOutcomeCallable UpdateDataSetPermissionsCallable(const UpdateDataSetPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateDataSetPermissions, request); } /** * An Async wrapper for UpdateDataSetPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDataSetPermissionsAsync(const UpdateDataSetPermissionsRequestT& request, const UpdateDataSetPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateDataSetPermissions, request, handler, context); } /** *

Updates a data source.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDataSourceOutcome UpdateDataSource(const Model::UpdateDataSourceRequest& request) const; /** * A Callable wrapper for UpdateDataSource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDataSourceOutcomeCallable UpdateDataSourceCallable(const UpdateDataSourceRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateDataSource, request); } /** * An Async wrapper for UpdateDataSource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDataSourceAsync(const UpdateDataSourceRequestT& request, const UpdateDataSourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateDataSource, request, handler, context); } /** *

Updates the permissions to a data source.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDataSourcePermissionsOutcome UpdateDataSourcePermissions(const Model::UpdateDataSourcePermissionsRequest& request) const; /** * A Callable wrapper for UpdateDataSourcePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDataSourcePermissionsOutcomeCallable UpdateDataSourcePermissionsCallable(const UpdateDataSourcePermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateDataSourcePermissions, request); } /** * An Async wrapper for UpdateDataSourcePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDataSourcePermissionsAsync(const UpdateDataSourcePermissionsRequestT& request, const UpdateDataSourcePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateDataSourcePermissions, request, handler, context); } /** *

Updates the name of a folder.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFolderOutcome UpdateFolder(const Model::UpdateFolderRequest& request) const; /** * A Callable wrapper for UpdateFolder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFolderOutcomeCallable UpdateFolderCallable(const UpdateFolderRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateFolder, request); } /** * An Async wrapper for UpdateFolder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFolderAsync(const UpdateFolderRequestT& request, const UpdateFolderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateFolder, request, handler, context); } /** *

Updates permissions of a folder.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFolderPermissionsOutcome UpdateFolderPermissions(const Model::UpdateFolderPermissionsRequest& request) const; /** * A Callable wrapper for UpdateFolderPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFolderPermissionsOutcomeCallable UpdateFolderPermissionsCallable(const UpdateFolderPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateFolderPermissions, request); } /** * An Async wrapper for UpdateFolderPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFolderPermissionsAsync(const UpdateFolderPermissionsRequestT& request, const UpdateFolderPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateFolderPermissions, request, handler, context); } /** *

Changes a group description.

See Also:

AWS * API Reference

*/ virtual Model::UpdateGroupOutcome UpdateGroup(const Model::UpdateGroupRequest& request) const; /** * A Callable wrapper for UpdateGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateGroupOutcomeCallable UpdateGroupCallable(const UpdateGroupRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateGroup, request); } /** * An Async wrapper for UpdateGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateGroupAsync(const UpdateGroupRequestT& request, const UpdateGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateGroup, request, handler, context); } /** *

Updates an existing IAM policy assignment. This operation updates only the * optional parameter or parameters that are specified in the request. This * overwrites all of the users included in Identities.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateIAMPolicyAssignmentOutcome UpdateIAMPolicyAssignment(const Model::UpdateIAMPolicyAssignmentRequest& request) const; /** * A Callable wrapper for UpdateIAMPolicyAssignment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateIAMPolicyAssignmentOutcomeCallable UpdateIAMPolicyAssignmentCallable(const UpdateIAMPolicyAssignmentRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateIAMPolicyAssignment, request); } /** * An Async wrapper for UpdateIAMPolicyAssignment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateIAMPolicyAssignmentAsync(const UpdateIAMPolicyAssignmentRequestT& request, const UpdateIAMPolicyAssignmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateIAMPolicyAssignment, request, handler, context); } /** *

Updates the content and status of IP rules. To use this operation, you must * provide the entire map of rules. You can use the * DescribeIpRestriction operation to get the current rule * map.

See Also:

AWS * API Reference

*/ virtual Model::UpdateIpRestrictionOutcome UpdateIpRestriction(const Model::UpdateIpRestrictionRequest& request) const; /** * A Callable wrapper for UpdateIpRestriction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateIpRestrictionOutcomeCallable UpdateIpRestrictionCallable(const UpdateIpRestrictionRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateIpRestriction, request); } /** * An Async wrapper for UpdateIpRestriction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateIpRestrictionAsync(const UpdateIpRestrictionRequestT& request, const UpdateIpRestrictionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateIpRestriction, request, handler, context); } /** *

Use the UpdatePublicSharingSettings operation to turn on or turn * off the public sharing settings of an Amazon QuickSight dashboard.

To use * this operation, turn on session capacity pricing for your Amazon QuickSight * account.

Before you can turn on public sharing on your account, make sure * to give public sharing permissions to an administrative user in the Identity and * Access Management (IAM) console. For more information on using IAM with Amazon * QuickSight, see Using * Amazon QuickSight with IAM in the Amazon QuickSight User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePublicSharingSettingsOutcome UpdatePublicSharingSettings(const Model::UpdatePublicSharingSettingsRequest& request) const; /** * A Callable wrapper for UpdatePublicSharingSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePublicSharingSettingsOutcomeCallable UpdatePublicSharingSettingsCallable(const UpdatePublicSharingSettingsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdatePublicSharingSettings, request); } /** * An Async wrapper for UpdatePublicSharingSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePublicSharingSettingsAsync(const UpdatePublicSharingSettingsRequestT& request, const UpdatePublicSharingSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdatePublicSharingSettings, request, handler, context); } /** *

Updates a refresh schedule for a dataset.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRefreshScheduleOutcome UpdateRefreshSchedule(const Model::UpdateRefreshScheduleRequest& request) const; /** * A Callable wrapper for UpdateRefreshSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRefreshScheduleOutcomeCallable UpdateRefreshScheduleCallable(const UpdateRefreshScheduleRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateRefreshSchedule, request); } /** * An Async wrapper for UpdateRefreshSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRefreshScheduleAsync(const UpdateRefreshScheduleRequestT& request, const UpdateRefreshScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateRefreshSchedule, request, handler, context); } /** *

Updates a template from an existing Amazon QuickSight analysis or another * template.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTemplateOutcome UpdateTemplate(const Model::UpdateTemplateRequest& request) const; /** * A Callable wrapper for UpdateTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTemplateOutcomeCallable UpdateTemplateCallable(const UpdateTemplateRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateTemplate, request); } /** * An Async wrapper for UpdateTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTemplateAsync(const UpdateTemplateRequestT& request, const UpdateTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateTemplate, request, handler, context); } /** *

Updates the template alias of a template.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTemplateAliasOutcome UpdateTemplateAlias(const Model::UpdateTemplateAliasRequest& request) const; /** * A Callable wrapper for UpdateTemplateAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTemplateAliasOutcomeCallable UpdateTemplateAliasCallable(const UpdateTemplateAliasRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateTemplateAlias, request); } /** * An Async wrapper for UpdateTemplateAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTemplateAliasAsync(const UpdateTemplateAliasRequestT& request, const UpdateTemplateAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateTemplateAlias, request, handler, context); } /** *

Updates the resource permissions for a template.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateTemplatePermissionsOutcome UpdateTemplatePermissions(const Model::UpdateTemplatePermissionsRequest& request) const; /** * A Callable wrapper for UpdateTemplatePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTemplatePermissionsOutcomeCallable UpdateTemplatePermissionsCallable(const UpdateTemplatePermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateTemplatePermissions, request); } /** * An Async wrapper for UpdateTemplatePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTemplatePermissionsAsync(const UpdateTemplatePermissionsRequestT& request, const UpdateTemplatePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateTemplatePermissions, request, handler, context); } /** *

Updates a theme.

See Also:

AWS * API Reference

*/ virtual Model::UpdateThemeOutcome UpdateTheme(const Model::UpdateThemeRequest& request) const; /** * A Callable wrapper for UpdateTheme that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateThemeOutcomeCallable UpdateThemeCallable(const UpdateThemeRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateTheme, request); } /** * An Async wrapper for UpdateTheme that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateThemeAsync(const UpdateThemeRequestT& request, const UpdateThemeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateTheme, request, handler, context); } /** *

Updates an alias of a theme.

See Also:

AWS * API Reference

*/ virtual Model::UpdateThemeAliasOutcome UpdateThemeAlias(const Model::UpdateThemeAliasRequest& request) const; /** * A Callable wrapper for UpdateThemeAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateThemeAliasOutcomeCallable UpdateThemeAliasCallable(const UpdateThemeAliasRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateThemeAlias, request); } /** * An Async wrapper for UpdateThemeAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateThemeAliasAsync(const UpdateThemeAliasRequestT& request, const UpdateThemeAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateThemeAlias, request, handler, context); } /** *

Updates the resource permissions for a theme. Permissions apply to the action * to grant or revoke permissions on, for example * "quicksight:DescribeTheme".

Theme permissions apply in * groupings. Valid groupings include the following for the three levels of * permissions, which are user, owner, or no permissions:

  • *

    User

    • "quicksight:DescribeTheme"

      • *

    • "quicksight:DescribeThemeAlias"

    • * "quicksight:ListThemeAliases"

    • * "quicksight:ListThemeVersions"

  • *

    Owner

    • "quicksight:DescribeTheme"

      • *

    • "quicksight:DescribeThemeAlias"

    • * "quicksight:ListThemeAliases"

    • * "quicksight:ListThemeVersions"

    • * "quicksight:DeleteTheme"

    • * "quicksight:UpdateTheme"

    • * "quicksight:CreateThemeAlias"

    • * "quicksight:DeleteThemeAlias"

    • * "quicksight:UpdateThemeAlias"

    • * "quicksight:UpdateThemePermissions"

    • * "quicksight:DescribeThemePermissions"

  • *

    To specify no permissions, omit the permissions list.

    • *

See Also:

AWS * API Reference

*/ virtual Model::UpdateThemePermissionsOutcome UpdateThemePermissions(const Model::UpdateThemePermissionsRequest& request) const; /** * A Callable wrapper for UpdateThemePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateThemePermissionsOutcomeCallable UpdateThemePermissionsCallable(const UpdateThemePermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateThemePermissions, request); } /** * An Async wrapper for UpdateThemePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateThemePermissionsAsync(const UpdateThemePermissionsRequestT& request, const UpdateThemePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateThemePermissions, request, handler, context); } /** *

Updates a topic.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTopicOutcome UpdateTopic(const Model::UpdateTopicRequest& request) const; /** * A Callable wrapper for UpdateTopic that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTopicOutcomeCallable UpdateTopicCallable(const UpdateTopicRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateTopic, request); } /** * An Async wrapper for UpdateTopic that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTopicAsync(const UpdateTopicRequestT& request, const UpdateTopicResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateTopic, request, handler, context); } /** *

Updates the permissions of a topic.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTopicPermissionsOutcome UpdateTopicPermissions(const Model::UpdateTopicPermissionsRequest& request) const; /** * A Callable wrapper for UpdateTopicPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTopicPermissionsOutcomeCallable UpdateTopicPermissionsCallable(const UpdateTopicPermissionsRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateTopicPermissions, request); } /** * An Async wrapper for UpdateTopicPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTopicPermissionsAsync(const UpdateTopicPermissionsRequestT& request, const UpdateTopicPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateTopicPermissions, request, handler, context); } /** *

Updates a topic refresh schedule.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTopicRefreshScheduleOutcome UpdateTopicRefreshSchedule(const Model::UpdateTopicRefreshScheduleRequest& request) const; /** * A Callable wrapper for UpdateTopicRefreshSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTopicRefreshScheduleOutcomeCallable UpdateTopicRefreshScheduleCallable(const UpdateTopicRefreshScheduleRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateTopicRefreshSchedule, request); } /** * An Async wrapper for UpdateTopicRefreshSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTopicRefreshScheduleAsync(const UpdateTopicRefreshScheduleRequestT& request, const UpdateTopicRefreshScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateTopicRefreshSchedule, request, handler, context); } /** *

Updates an Amazon QuickSight user.

See Also:

AWS * API Reference

*/ virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const; /** * A Callable wrapper for UpdateUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateUser, request); } /** * An Async wrapper for UpdateUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateUserAsync(const UpdateUserRequestT& request, const UpdateUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateUser, request, handler, context); } /** *

Updates a VPC connection.

See Also:

AWS * API Reference

*/ virtual Model::UpdateVPCConnectionOutcome UpdateVPCConnection(const Model::UpdateVPCConnectionRequest& request) const; /** * A Callable wrapper for UpdateVPCConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateVPCConnectionOutcomeCallable UpdateVPCConnectionCallable(const UpdateVPCConnectionRequestT& request) const { return SubmitCallable(&QuickSightClient::UpdateVPCConnection, request); } /** * An Async wrapper for UpdateVPCConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateVPCConnectionAsync(const UpdateVPCConnectionRequestT& request, const UpdateVPCConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&QuickSightClient::UpdateVPCConnection, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const QuickSightClientConfiguration& clientConfiguration); QuickSightClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace QuickSight } // namespace Aws