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

Welcome to the IoT SiteWise API Reference. IoT SiteWise is an Amazon Web * Services service that connects Industrial * Internet of Things (IIoT) devices to the power of the Amazon Web Services * Cloud. For more information, see the IoT SiteWise * User Guide. For information about IoT SiteWise quotas, see Quotas * in the IoT SiteWise User Guide.

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

Associates a child asset with the given parent asset through a hierarchy * defined in the parent asset's model. For more information, see Associating * assets in the IoT SiteWise User Guide.

See Also:

AWS * API Reference

*/ virtual Model::AssociateAssetsOutcome AssociateAssets(const Model::AssociateAssetsRequest& request) const; /** * A Callable wrapper for AssociateAssets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateAssetsOutcomeCallable AssociateAssetsCallable(const AssociateAssetsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::AssociateAssets, request); } /** * An Async wrapper for AssociateAssets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateAssetsAsync(const AssociateAssetsRequestT& request, const AssociateAssetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::AssociateAssets, request, handler, context); } /** *

Associates a time series (data stream) with an asset property.

See * Also:

AWS * API Reference

*/ virtual Model::AssociateTimeSeriesToAssetPropertyOutcome AssociateTimeSeriesToAssetProperty(const Model::AssociateTimeSeriesToAssetPropertyRequest& request) const; /** * A Callable wrapper for AssociateTimeSeriesToAssetProperty that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateTimeSeriesToAssetPropertyOutcomeCallable AssociateTimeSeriesToAssetPropertyCallable(const AssociateTimeSeriesToAssetPropertyRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::AssociateTimeSeriesToAssetProperty, request); } /** * An Async wrapper for AssociateTimeSeriesToAssetProperty that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateTimeSeriesToAssetPropertyAsync(const AssociateTimeSeriesToAssetPropertyRequestT& request, const AssociateTimeSeriesToAssetPropertyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::AssociateTimeSeriesToAssetProperty, request, handler, context); } /** *

Associates a group (batch) of assets with an IoT SiteWise Monitor * project.

See Also:

AWS * API Reference

*/ virtual Model::BatchAssociateProjectAssetsOutcome BatchAssociateProjectAssets(const Model::BatchAssociateProjectAssetsRequest& request) const; /** * A Callable wrapper for BatchAssociateProjectAssets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchAssociateProjectAssetsOutcomeCallable BatchAssociateProjectAssetsCallable(const BatchAssociateProjectAssetsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::BatchAssociateProjectAssets, request); } /** * An Async wrapper for BatchAssociateProjectAssets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchAssociateProjectAssetsAsync(const BatchAssociateProjectAssetsRequestT& request, const BatchAssociateProjectAssetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::BatchAssociateProjectAssets, request, handler, context); } /** *

Disassociates a group (batch) of assets from an IoT SiteWise Monitor * project.

See Also:

AWS * API Reference

*/ virtual Model::BatchDisassociateProjectAssetsOutcome BatchDisassociateProjectAssets(const Model::BatchDisassociateProjectAssetsRequest& request) const; /** * A Callable wrapper for BatchDisassociateProjectAssets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDisassociateProjectAssetsOutcomeCallable BatchDisassociateProjectAssetsCallable(const BatchDisassociateProjectAssetsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::BatchDisassociateProjectAssets, request); } /** * An Async wrapper for BatchDisassociateProjectAssets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDisassociateProjectAssetsAsync(const BatchDisassociateProjectAssetsRequestT& request, const BatchDisassociateProjectAssetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::BatchDisassociateProjectAssets, request, handler, context); } /** *

Gets aggregated values (for example, average, minimum, and maximum) for one * or more asset properties. For more information, see Querying * aggregates in the IoT SiteWise User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::BatchGetAssetPropertyAggregatesOutcome BatchGetAssetPropertyAggregates(const Model::BatchGetAssetPropertyAggregatesRequest& request) const; /** * A Callable wrapper for BatchGetAssetPropertyAggregates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetAssetPropertyAggregatesOutcomeCallable BatchGetAssetPropertyAggregatesCallable(const BatchGetAssetPropertyAggregatesRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::BatchGetAssetPropertyAggregates, request); } /** * An Async wrapper for BatchGetAssetPropertyAggregates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetAssetPropertyAggregatesAsync(const BatchGetAssetPropertyAggregatesRequestT& request, const BatchGetAssetPropertyAggregatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::BatchGetAssetPropertyAggregates, request, handler, context); } /** *

Gets the current value for one or more asset properties. For more * information, see Querying * current values in the IoT SiteWise User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::BatchGetAssetPropertyValueOutcome BatchGetAssetPropertyValue(const Model::BatchGetAssetPropertyValueRequest& request) const; /** * A Callable wrapper for BatchGetAssetPropertyValue that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetAssetPropertyValueOutcomeCallable BatchGetAssetPropertyValueCallable(const BatchGetAssetPropertyValueRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::BatchGetAssetPropertyValue, request); } /** * An Async wrapper for BatchGetAssetPropertyValue that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetAssetPropertyValueAsync(const BatchGetAssetPropertyValueRequestT& request, const BatchGetAssetPropertyValueResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::BatchGetAssetPropertyValue, request, handler, context); } /** *

Gets the historical values for one or more asset properties. For more * information, see Querying * historical values in the IoT SiteWise User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::BatchGetAssetPropertyValueHistoryOutcome BatchGetAssetPropertyValueHistory(const Model::BatchGetAssetPropertyValueHistoryRequest& request) const; /** * A Callable wrapper for BatchGetAssetPropertyValueHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetAssetPropertyValueHistoryOutcomeCallable BatchGetAssetPropertyValueHistoryCallable(const BatchGetAssetPropertyValueHistoryRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::BatchGetAssetPropertyValueHistory, request); } /** * An Async wrapper for BatchGetAssetPropertyValueHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetAssetPropertyValueHistoryAsync(const BatchGetAssetPropertyValueHistoryRequestT& request, const BatchGetAssetPropertyValueHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::BatchGetAssetPropertyValueHistory, request, handler, context); } /** *

Sends a list of asset property values to IoT SiteWise. Each value is a * timestamp-quality-value (TQV) data point. For more information, see Ingesting * data using the API in the IoT SiteWise User Guide.

To identify * an asset property, you must specify one of the following:

  • The * assetId and propertyId of an asset property.

    • *

  • A propertyAlias, which is a data stream alias (for example, * /company/windfarm/3/turbine/7/temperature). To define an asset * property's alias, see UpdateAssetProperty.

    *

With respect to Unix epoch time, IoT SiteWise accepts * only TQVs that have a timestamp of no more than 7 days in the past and no more * than 10 minutes in the future. IoT SiteWise rejects timestamps outside of the * inclusive range of [-7 days, +10 minutes] and returns a * TimestampOutOfRangeException error.

For each asset property, * IoT SiteWise overwrites TQVs with duplicate timestamps unless the newer TQV has * a different quality. For example, if you store a TQV {T1, GOOD, * V1}, then storing {T1, GOOD, V2} replaces the existing * TQV.

IoT SiteWise authorizes access to each * BatchPutAssetPropertyValue entry individually. For more * information, see BatchPutAssetPropertyValue * authorization in the IoT SiteWise User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::BatchPutAssetPropertyValueOutcome BatchPutAssetPropertyValue(const Model::BatchPutAssetPropertyValueRequest& request) const; /** * A Callable wrapper for BatchPutAssetPropertyValue that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchPutAssetPropertyValueOutcomeCallable BatchPutAssetPropertyValueCallable(const BatchPutAssetPropertyValueRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::BatchPutAssetPropertyValue, request); } /** * An Async wrapper for BatchPutAssetPropertyValue that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchPutAssetPropertyValueAsync(const BatchPutAssetPropertyValueRequestT& request, const BatchPutAssetPropertyValueResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::BatchPutAssetPropertyValue, request, handler, context); } /** *

Creates an access policy that grants the specified identity (IAM Identity * Center user, IAM Identity Center group, or IAM user) access to the specified IoT * SiteWise Monitor portal or project resource.

See Also:

AWS * API Reference

*/ virtual Model::CreateAccessPolicyOutcome CreateAccessPolicy(const Model::CreateAccessPolicyRequest& request) const; /** * A Callable wrapper for CreateAccessPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAccessPolicyOutcomeCallable CreateAccessPolicyCallable(const CreateAccessPolicyRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::CreateAccessPolicy, request); } /** * An Async wrapper for CreateAccessPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAccessPolicyAsync(const CreateAccessPolicyRequestT& request, const CreateAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::CreateAccessPolicy, request, handler, context); } /** *

Creates an asset from an existing asset model. For more information, see Creating * assets in the IoT SiteWise User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateAssetOutcome CreateAsset(const Model::CreateAssetRequest& request) const; /** * A Callable wrapper for CreateAsset that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAssetOutcomeCallable CreateAssetCallable(const CreateAssetRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::CreateAsset, request); } /** * An Async wrapper for CreateAsset that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAssetAsync(const CreateAssetRequestT& request, const CreateAssetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::CreateAsset, request, handler, context); } /** *

Creates an asset model from specified property and hierarchy definitions. You * create assets from asset models. With asset models, you can easily create assets * of the same type that have standardized definitions. Each asset created from a * model inherits the asset model's property and hierarchy definitions. For more * information, see Defining * asset models in the IoT SiteWise User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::CreateAssetModelOutcome CreateAssetModel(const Model::CreateAssetModelRequest& request) const; /** * A Callable wrapper for CreateAssetModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAssetModelOutcomeCallable CreateAssetModelCallable(const CreateAssetModelRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::CreateAssetModel, request); } /** * An Async wrapper for CreateAssetModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAssetModelAsync(const CreateAssetModelRequestT& request, const CreateAssetModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::CreateAssetModel, request, handler, context); } /** *

Defines a job to ingest data to IoT SiteWise from Amazon S3. For more * information, see Create * a bulk import job (CLI) in the Amazon Simple Storage Service User * Guide.

You must enable IoT SiteWise to export data to * Amazon S3 before you create a bulk import job. For more information about how to * configure storage settings, see PutStorageConfiguration.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateBulkImportJobOutcome CreateBulkImportJob(const Model::CreateBulkImportJobRequest& request) const; /** * A Callable wrapper for CreateBulkImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBulkImportJobOutcomeCallable CreateBulkImportJobCallable(const CreateBulkImportJobRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::CreateBulkImportJob, request); } /** * An Async wrapper for CreateBulkImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBulkImportJobAsync(const CreateBulkImportJobRequestT& request, const CreateBulkImportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::CreateBulkImportJob, request, handler, context); } /** *

Creates a dashboard in an IoT SiteWise Monitor project.

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

Creates a gateway, which is a virtual or edge device that delivers industrial * data streams from local servers to IoT SiteWise. For more information, see Ingesting * data using a gateway in the IoT SiteWise User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateGatewayOutcome CreateGateway(const Model::CreateGatewayRequest& request) const; /** * A Callable wrapper for CreateGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGatewayOutcomeCallable CreateGatewayCallable(const CreateGatewayRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::CreateGateway, request); } /** * An Async wrapper for CreateGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGatewayAsync(const CreateGatewayRequestT& request, const CreateGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::CreateGateway, request, handler, context); } /** *

Creates a portal, which can contain projects and dashboards. IoT SiteWise * Monitor uses IAM Identity Center or IAM to authenticate portal users and manage * user permissions.

Before you can sign in to a new portal, you must * add at least one identity to that portal. For more information, see Adding * or removing portal administrators in the IoT SiteWise User Guide.

*

See Also:

AWS * API Reference

*/ virtual Model::CreatePortalOutcome CreatePortal(const Model::CreatePortalRequest& request) const; /** * A Callable wrapper for CreatePortal that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePortalOutcomeCallable CreatePortalCallable(const CreatePortalRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::CreatePortal, request); } /** * An Async wrapper for CreatePortal that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePortalAsync(const CreatePortalRequestT& request, const CreatePortalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::CreatePortal, request, handler, context); } /** *

Creates a project in the specified portal.

Make sure that the * project name and description don't contain confidential information.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const; /** * A Callable wrapper for CreateProject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::CreateProject, request); } /** * An Async wrapper for CreateProject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::CreateProject, request, handler, context); } /** *

Deletes an access policy that grants the specified identity access to the * specified IoT SiteWise Monitor resource. You can use this operation to revoke * access to an IoT SiteWise Monitor resource.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccessPolicyOutcome DeleteAccessPolicy(const Model::DeleteAccessPolicyRequest& request) const; /** * A Callable wrapper for DeleteAccessPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccessPolicyOutcomeCallable DeleteAccessPolicyCallable(const DeleteAccessPolicyRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DeleteAccessPolicy, request); } /** * An Async wrapper for DeleteAccessPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccessPolicyAsync(const DeleteAccessPolicyRequestT& request, const DeleteAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DeleteAccessPolicy, request, handler, context); } /** *

Deletes an asset. This action can't be undone. For more information, see Deleting * assets and models in the IoT SiteWise User Guide.

You * can't delete an asset that's associated to another asset. For more information, * see DisassociateAssets.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteAssetOutcome DeleteAsset(const Model::DeleteAssetRequest& request) const; /** * A Callable wrapper for DeleteAsset that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAssetOutcomeCallable DeleteAssetCallable(const DeleteAssetRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DeleteAsset, request); } /** * An Async wrapper for DeleteAsset that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAssetAsync(const DeleteAssetRequestT& request, const DeleteAssetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DeleteAsset, request, handler, context); } /** *

Deletes an asset model. This action can't be undone. You must delete all * assets created from an asset model before you can delete the model. Also, you * can't delete an asset model if a parent asset model exists that contains a * property formula expression that depends on the asset model that you want to * delete. For more information, see Deleting * assets and models in the IoT SiteWise User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteAssetModelOutcome DeleteAssetModel(const Model::DeleteAssetModelRequest& request) const; /** * A Callable wrapper for DeleteAssetModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAssetModelOutcomeCallable DeleteAssetModelCallable(const DeleteAssetModelRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DeleteAssetModel, request); } /** * An Async wrapper for DeleteAssetModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAssetModelAsync(const DeleteAssetModelRequestT& request, const DeleteAssetModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DeleteAssetModel, request, handler, context); } /** *

Deletes a dashboard from IoT SiteWise Monitor.

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

Deletes a gateway from IoT SiteWise. When you delete a gateway, some of the * gateway's files remain in your gateway's file system.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteGatewayOutcome DeleteGateway(const Model::DeleteGatewayRequest& request) const; /** * A Callable wrapper for DeleteGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteGatewayOutcomeCallable DeleteGatewayCallable(const DeleteGatewayRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DeleteGateway, request); } /** * An Async wrapper for DeleteGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteGatewayAsync(const DeleteGatewayRequestT& request, const DeleteGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DeleteGateway, request, handler, context); } /** *

Deletes a portal from IoT SiteWise Monitor.

See Also:

AWS * API Reference

*/ virtual Model::DeletePortalOutcome DeletePortal(const Model::DeletePortalRequest& request) const; /** * A Callable wrapper for DeletePortal that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePortalOutcomeCallable DeletePortalCallable(const DeletePortalRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DeletePortal, request); } /** * An Async wrapper for DeletePortal that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePortalAsync(const DeletePortalRequestT& request, const DeletePortalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DeletePortal, request, handler, context); } /** *

Deletes a project from IoT SiteWise Monitor.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const; /** * A Callable wrapper for DeleteProject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DeleteProject, request); } /** * An Async wrapper for DeleteProject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DeleteProject, request, handler, context); } /** *

Deletes a time series (data stream). If you delete a time series that's * associated with an asset property, the asset property still exists, but the time * series will no longer be associated with this asset property.

To identify * a time series, do one of the following:

  • If the time series * isn't associated with an asset property, specify the alias of the * time series.

  • If the time series is associated with an asset * property, specify one of the following:

    • The alias * of the time series.

    • The assetId and * propertyId that identifies the asset property.

    *

See Also:

AWS * API Reference

*/ virtual Model::DeleteTimeSeriesOutcome DeleteTimeSeries(const Model::DeleteTimeSeriesRequest& request) const; /** * A Callable wrapper for DeleteTimeSeries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTimeSeriesOutcomeCallable DeleteTimeSeriesCallable(const DeleteTimeSeriesRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DeleteTimeSeries, request); } /** * An Async wrapper for DeleteTimeSeries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTimeSeriesAsync(const DeleteTimeSeriesRequestT& request, const DeleteTimeSeriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DeleteTimeSeries, request, handler, context); } /** *

Describes an access policy, which specifies an identity's access to an IoT * SiteWise Monitor portal or project.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccessPolicyOutcome DescribeAccessPolicy(const Model::DescribeAccessPolicyRequest& request) const; /** * A Callable wrapper for DescribeAccessPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccessPolicyOutcomeCallable DescribeAccessPolicyCallable(const DescribeAccessPolicyRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeAccessPolicy, request); } /** * An Async wrapper for DescribeAccessPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccessPolicyAsync(const DescribeAccessPolicyRequestT& request, const DescribeAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeAccessPolicy, request, handler, context); } /** *

Retrieves information about an asset.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAssetOutcome DescribeAsset(const Model::DescribeAssetRequest& request) const; /** * A Callable wrapper for DescribeAsset that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAssetOutcomeCallable DescribeAssetCallable(const DescribeAssetRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeAsset, request); } /** * An Async wrapper for DescribeAsset that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAssetAsync(const DescribeAssetRequestT& request, const DescribeAssetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeAsset, request, handler, context); } /** *

Retrieves information about an asset model.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAssetModelOutcome DescribeAssetModel(const Model::DescribeAssetModelRequest& request) const; /** * A Callable wrapper for DescribeAssetModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAssetModelOutcomeCallable DescribeAssetModelCallable(const DescribeAssetModelRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeAssetModel, request); } /** * An Async wrapper for DescribeAssetModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAssetModelAsync(const DescribeAssetModelRequestT& request, const DescribeAssetModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeAssetModel, request, handler, context); } /** *

Retrieves information about an asset property.

When you call * this operation for an attribute property, this response includes the default * attribute value that you define in the asset model. If you update the default * value in the model, this operation's response includes the new default * value.

This operation doesn't return the value of the asset * property. To get the value of an asset property, use GetAssetPropertyValue.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAssetPropertyOutcome DescribeAssetProperty(const Model::DescribeAssetPropertyRequest& request) const; /** * A Callable wrapper for DescribeAssetProperty that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAssetPropertyOutcomeCallable DescribeAssetPropertyCallable(const DescribeAssetPropertyRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeAssetProperty, request); } /** * An Async wrapper for DescribeAssetProperty that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAssetPropertyAsync(const DescribeAssetPropertyRequestT& request, const DescribeAssetPropertyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeAssetProperty, request, handler, context); } /** *

Retrieves information about a bulk import job request. For more information, * see Describe * a bulk import job (CLI) in the Amazon Simple Storage Service User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBulkImportJobOutcome DescribeBulkImportJob(const Model::DescribeBulkImportJobRequest& request) const; /** * A Callable wrapper for DescribeBulkImportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBulkImportJobOutcomeCallable DescribeBulkImportJobCallable(const DescribeBulkImportJobRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeBulkImportJob, request); } /** * An Async wrapper for DescribeBulkImportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBulkImportJobAsync(const DescribeBulkImportJobRequestT& request, const DescribeBulkImportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeBulkImportJob, request, handler, context); } /** *

Retrieves information about 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(&IoTSiteWiseClient::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(&IoTSiteWiseClient::DescribeDashboard, request, handler, context); } /** *

Retrieves information about the default encryption configuration for the * Amazon Web Services account in the default or specified Region. For more * information, see Key * management in the IoT SiteWise User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeDefaultEncryptionConfigurationOutcome DescribeDefaultEncryptionConfiguration(const Model::DescribeDefaultEncryptionConfigurationRequest& request) const; /** * A Callable wrapper for DescribeDefaultEncryptionConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDefaultEncryptionConfigurationOutcomeCallable DescribeDefaultEncryptionConfigurationCallable(const DescribeDefaultEncryptionConfigurationRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeDefaultEncryptionConfiguration, request); } /** * An Async wrapper for DescribeDefaultEncryptionConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDefaultEncryptionConfigurationAsync(const DescribeDefaultEncryptionConfigurationRequestT& request, const DescribeDefaultEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeDefaultEncryptionConfiguration, request, handler, context); } /** *

Retrieves information about a gateway.

See Also:

AWS * API Reference

*/ virtual Model::DescribeGatewayOutcome DescribeGateway(const Model::DescribeGatewayRequest& request) const; /** * A Callable wrapper for DescribeGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeGatewayOutcomeCallable DescribeGatewayCallable(const DescribeGatewayRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeGateway, request); } /** * An Async wrapper for DescribeGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeGatewayAsync(const DescribeGatewayRequestT& request, const DescribeGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeGateway, request, handler, context); } /** *

Retrieves information about a gateway capability configuration. Each gateway * capability defines data sources for a gateway. A capability configuration can * contain multiple data source configurations. If you define OPC-UA sources for a * gateway in the IoT SiteWise console, all of your OPC-UA sources are stored in * one capability configuration. To list all capability configurations for a * gateway, use DescribeGateway.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeGatewayCapabilityConfigurationOutcome DescribeGatewayCapabilityConfiguration(const Model::DescribeGatewayCapabilityConfigurationRequest& request) const; /** * A Callable wrapper for DescribeGatewayCapabilityConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeGatewayCapabilityConfigurationOutcomeCallable DescribeGatewayCapabilityConfigurationCallable(const DescribeGatewayCapabilityConfigurationRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeGatewayCapabilityConfiguration, request); } /** * An Async wrapper for DescribeGatewayCapabilityConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeGatewayCapabilityConfigurationAsync(const DescribeGatewayCapabilityConfigurationRequestT& request, const DescribeGatewayCapabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeGatewayCapabilityConfiguration, request, handler, context); } /** *

Retrieves the current IoT SiteWise logging options.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeLoggingOptionsOutcome DescribeLoggingOptions(const Model::DescribeLoggingOptionsRequest& request) const; /** * A Callable wrapper for DescribeLoggingOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLoggingOptionsOutcomeCallable DescribeLoggingOptionsCallable(const DescribeLoggingOptionsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeLoggingOptions, request); } /** * An Async wrapper for DescribeLoggingOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLoggingOptionsAsync(const DescribeLoggingOptionsRequestT& request, const DescribeLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeLoggingOptions, request, handler, context); } /** *

Retrieves information about a portal.

See Also:

AWS * API Reference

*/ virtual Model::DescribePortalOutcome DescribePortal(const Model::DescribePortalRequest& request) const; /** * A Callable wrapper for DescribePortal that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePortalOutcomeCallable DescribePortalCallable(const DescribePortalRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribePortal, request); } /** * An Async wrapper for DescribePortal that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePortalAsync(const DescribePortalRequestT& request, const DescribePortalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribePortal, request, handler, context); } /** *

Retrieves information about a project.

See Also:

AWS * API Reference

*/ virtual Model::DescribeProjectOutcome DescribeProject(const Model::DescribeProjectRequest& request) const; /** * A Callable wrapper for DescribeProject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeProjectOutcomeCallable DescribeProjectCallable(const DescribeProjectRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeProject, request); } /** * An Async wrapper for DescribeProject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeProjectAsync(const DescribeProjectRequestT& request, const DescribeProjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeProject, request, handler, context); } /** *

Retrieves information about the storage configuration for IoT * SiteWise.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStorageConfigurationOutcome DescribeStorageConfiguration(const Model::DescribeStorageConfigurationRequest& request) const; /** * A Callable wrapper for DescribeStorageConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStorageConfigurationOutcomeCallable DescribeStorageConfigurationCallable(const DescribeStorageConfigurationRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeStorageConfiguration, request); } /** * An Async wrapper for DescribeStorageConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStorageConfigurationAsync(const DescribeStorageConfigurationRequestT& request, const DescribeStorageConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeStorageConfiguration, request, handler, context); } /** *

Retrieves information about a time series (data stream).

To identify a * time series, do one of the following:

  • If the time series isn't * associated with an asset property, specify the alias of the time * series.

  • If the time series is associated with an asset * property, specify one of the following:

    • The alias * of the time series.

    • The assetId and * propertyId that identifies the asset property.

    *

See Also:

AWS * API Reference

*/ virtual Model::DescribeTimeSeriesOutcome DescribeTimeSeries(const Model::DescribeTimeSeriesRequest& request) const; /** * A Callable wrapper for DescribeTimeSeries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTimeSeriesOutcomeCallable DescribeTimeSeriesCallable(const DescribeTimeSeriesRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DescribeTimeSeries, request); } /** * An Async wrapper for DescribeTimeSeries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTimeSeriesAsync(const DescribeTimeSeriesRequestT& request, const DescribeTimeSeriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DescribeTimeSeries, request, handler, context); } /** *

Disassociates a child asset from the given parent asset through a hierarchy * defined in the parent asset's model.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateAssetsOutcome DisassociateAssets(const Model::DisassociateAssetsRequest& request) const; /** * A Callable wrapper for DisassociateAssets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateAssetsOutcomeCallable DisassociateAssetsCallable(const DisassociateAssetsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DisassociateAssets, request); } /** * An Async wrapper for DisassociateAssets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateAssetsAsync(const DisassociateAssetsRequestT& request, const DisassociateAssetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DisassociateAssets, request, handler, context); } /** *

Disassociates a time series (data stream) from an asset * property.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateTimeSeriesFromAssetPropertyOutcome DisassociateTimeSeriesFromAssetProperty(const Model::DisassociateTimeSeriesFromAssetPropertyRequest& request) const; /** * A Callable wrapper for DisassociateTimeSeriesFromAssetProperty that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateTimeSeriesFromAssetPropertyOutcomeCallable DisassociateTimeSeriesFromAssetPropertyCallable(const DisassociateTimeSeriesFromAssetPropertyRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::DisassociateTimeSeriesFromAssetProperty, request); } /** * An Async wrapper for DisassociateTimeSeriesFromAssetProperty that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateTimeSeriesFromAssetPropertyAsync(const DisassociateTimeSeriesFromAssetPropertyRequestT& request, const DisassociateTimeSeriesFromAssetPropertyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::DisassociateTimeSeriesFromAssetProperty, request, handler, context); } /** *

Gets aggregated values for an asset property. For more information, see Querying * aggregates in the IoT SiteWise User Guide.

To identify an * asset property, you must specify one of the following:

  • The * assetId and propertyId of an asset property.

    • *

  • A propertyAlias, which is a data stream alias (for example, * /company/windfarm/3/turbine/7/temperature). To define an asset * property's alias, see UpdateAssetProperty.

    *

See Also:

AWS * API Reference

*/ virtual Model::GetAssetPropertyAggregatesOutcome GetAssetPropertyAggregates(const Model::GetAssetPropertyAggregatesRequest& request) const; /** * A Callable wrapper for GetAssetPropertyAggregates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAssetPropertyAggregatesOutcomeCallable GetAssetPropertyAggregatesCallable(const GetAssetPropertyAggregatesRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::GetAssetPropertyAggregates, request); } /** * An Async wrapper for GetAssetPropertyAggregates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAssetPropertyAggregatesAsync(const GetAssetPropertyAggregatesRequestT& request, const GetAssetPropertyAggregatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::GetAssetPropertyAggregates, request, handler, context); } /** *

Gets an asset property's current value. For more information, see Querying * current values in the IoT SiteWise User Guide.

To identify an * asset property, you must specify one of the following:

  • The * assetId and propertyId of an asset property.

    • *

  • A propertyAlias, which is a data stream alias (for example, * /company/windfarm/3/turbine/7/temperature). To define an asset * property's alias, see UpdateAssetProperty.

    *

See Also:

AWS * API Reference

*/ virtual Model::GetAssetPropertyValueOutcome GetAssetPropertyValue(const Model::GetAssetPropertyValueRequest& request) const; /** * A Callable wrapper for GetAssetPropertyValue that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAssetPropertyValueOutcomeCallable GetAssetPropertyValueCallable(const GetAssetPropertyValueRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::GetAssetPropertyValue, request); } /** * An Async wrapper for GetAssetPropertyValue that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAssetPropertyValueAsync(const GetAssetPropertyValueRequestT& request, const GetAssetPropertyValueResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::GetAssetPropertyValue, request, handler, context); } /** *

Gets the history of an asset property's values. For more information, see Querying * historical values in the IoT SiteWise User Guide.

To identify * an asset property, you must specify one of the following:

  • The * assetId and propertyId of an asset property.

    • *

  • A propertyAlias, which is a data stream alias (for example, * /company/windfarm/3/turbine/7/temperature). To define an asset * property's alias, see UpdateAssetProperty.

    *

See Also:

AWS * API Reference

*/ virtual Model::GetAssetPropertyValueHistoryOutcome GetAssetPropertyValueHistory(const Model::GetAssetPropertyValueHistoryRequest& request) const; /** * A Callable wrapper for GetAssetPropertyValueHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAssetPropertyValueHistoryOutcomeCallable GetAssetPropertyValueHistoryCallable(const GetAssetPropertyValueHistoryRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::GetAssetPropertyValueHistory, request); } /** * An Async wrapper for GetAssetPropertyValueHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAssetPropertyValueHistoryAsync(const GetAssetPropertyValueHistoryRequestT& request, const GetAssetPropertyValueHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::GetAssetPropertyValueHistory, request, handler, context); } /** *

Get interpolated values for an asset property for a specified time interval, * during a period of time. If your time series is missing data points during the * specified time interval, you can use interpolation to estimate the missing * data.

For example, you can use this operation to return the interpolated * temperature values for a wind turbine every 24 hours over a duration of 7 * days.

To identify an asset property, you must specify one of the * following:

  • The assetId and propertyId * of an asset property.

  • A propertyAlias, which is a * data stream alias (for example, * /company/windfarm/3/turbine/7/temperature). To define an asset * property's alias, see UpdateAssetProperty.

    *

See Also:

AWS * API Reference

*/ virtual Model::GetInterpolatedAssetPropertyValuesOutcome GetInterpolatedAssetPropertyValues(const Model::GetInterpolatedAssetPropertyValuesRequest& request) const; /** * A Callable wrapper for GetInterpolatedAssetPropertyValues that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInterpolatedAssetPropertyValuesOutcomeCallable GetInterpolatedAssetPropertyValuesCallable(const GetInterpolatedAssetPropertyValuesRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::GetInterpolatedAssetPropertyValues, request); } /** * An Async wrapper for GetInterpolatedAssetPropertyValues that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInterpolatedAssetPropertyValuesAsync(const GetInterpolatedAssetPropertyValuesRequestT& request, const GetInterpolatedAssetPropertyValuesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::GetInterpolatedAssetPropertyValues, request, handler, context); } /** *

Retrieves a paginated list of access policies for an identity (an IAM * Identity Center user, an IAM Identity Center group, or an IAM user) or an IoT * SiteWise Monitor resource (a portal or project).

See Also:

AWS * API Reference

*/ virtual Model::ListAccessPoliciesOutcome ListAccessPolicies(const Model::ListAccessPoliciesRequest& request) const; /** * A Callable wrapper for ListAccessPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAccessPoliciesOutcomeCallable ListAccessPoliciesCallable(const ListAccessPoliciesRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListAccessPolicies, request); } /** * An Async wrapper for ListAccessPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAccessPoliciesAsync(const ListAccessPoliciesRequestT& request, const ListAccessPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListAccessPolicies, request, handler, context); } /** *

Retrieves a paginated list of properties associated with an asset model. If * you update properties associated with the model before you finish listing all * the properties, you need to start all over again.

See Also:

AWS * API Reference

*/ virtual Model::ListAssetModelPropertiesOutcome ListAssetModelProperties(const Model::ListAssetModelPropertiesRequest& request) const; /** * A Callable wrapper for ListAssetModelProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssetModelPropertiesOutcomeCallable ListAssetModelPropertiesCallable(const ListAssetModelPropertiesRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListAssetModelProperties, request); } /** * An Async wrapper for ListAssetModelProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssetModelPropertiesAsync(const ListAssetModelPropertiesRequestT& request, const ListAssetModelPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListAssetModelProperties, request, handler, context); } /** *

Retrieves a paginated list of summaries of all asset models.

See * Also:

AWS * API Reference

*/ virtual Model::ListAssetModelsOutcome ListAssetModels(const Model::ListAssetModelsRequest& request) const; /** * A Callable wrapper for ListAssetModels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssetModelsOutcomeCallable ListAssetModelsCallable(const ListAssetModelsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListAssetModels, request); } /** * An Async wrapper for ListAssetModels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssetModelsAsync(const ListAssetModelsRequestT& request, const ListAssetModelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListAssetModels, request, handler, context); } /** *

Retrieves a paginated list of properties associated with an asset. If you * update properties associated with the model before you finish listing all the * properties, you need to start all over again.

See Also:

AWS * API Reference

*/ virtual Model::ListAssetPropertiesOutcome ListAssetProperties(const Model::ListAssetPropertiesRequest& request) const; /** * A Callable wrapper for ListAssetProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssetPropertiesOutcomeCallable ListAssetPropertiesCallable(const ListAssetPropertiesRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListAssetProperties, request); } /** * An Async wrapper for ListAssetProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssetPropertiesAsync(const ListAssetPropertiesRequestT& request, const ListAssetPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListAssetProperties, request, handler, context); } /** *

Retrieves a paginated list of asset relationships for an asset. You can use * this operation to identify an asset's root asset and all associated assets * between that asset and its root.

See Also:

AWS * API Reference

*/ virtual Model::ListAssetRelationshipsOutcome ListAssetRelationships(const Model::ListAssetRelationshipsRequest& request) const; /** * A Callable wrapper for ListAssetRelationships that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssetRelationshipsOutcomeCallable ListAssetRelationshipsCallable(const ListAssetRelationshipsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListAssetRelationships, request); } /** * An Async wrapper for ListAssetRelationships that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssetRelationshipsAsync(const ListAssetRelationshipsRequestT& request, const ListAssetRelationshipsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListAssetRelationships, request, handler, context); } /** *

Retrieves a paginated list of asset summaries.

You can use this * operation to do the following:

  • List assets based on a specific * asset model.

  • List top-level assets.

You * can't use this operation to list all assets. To retrieve summaries for all of * your assets, use ListAssetModels * to get all of your asset model IDs. Then, use ListAssets to get all assets for * each asset model.

See Also:

AWS * API Reference

*/ virtual Model::ListAssetsOutcome ListAssets(const Model::ListAssetsRequest& request) const; /** * A Callable wrapper for ListAssets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssetsOutcomeCallable ListAssetsCallable(const ListAssetsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListAssets, request); } /** * An Async wrapper for ListAssets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssetsAsync(const ListAssetsRequestT& request, const ListAssetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListAssets, request, handler, context); } /** *

Retrieves a paginated list of associated assets.

You can use this * operation to do the following:

  • List child assets associated to * a parent asset by a hierarchy that you specify.

  • List an * asset's parent asset.

See Also:

AWS * API Reference

*/ virtual Model::ListAssociatedAssetsOutcome ListAssociatedAssets(const Model::ListAssociatedAssetsRequest& request) const; /** * A Callable wrapper for ListAssociatedAssets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssociatedAssetsOutcomeCallable ListAssociatedAssetsCallable(const ListAssociatedAssetsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListAssociatedAssets, request); } /** * An Async wrapper for ListAssociatedAssets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssociatedAssetsAsync(const ListAssociatedAssetsRequestT& request, const ListAssociatedAssetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListAssociatedAssets, request, handler, context); } /** *

Retrieves a paginated list of bulk import job requests. For more information, * see List * bulk import jobs (CLI) in the IoT SiteWise User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ListBulkImportJobsOutcome ListBulkImportJobs(const Model::ListBulkImportJobsRequest& request) const; /** * A Callable wrapper for ListBulkImportJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBulkImportJobsOutcomeCallable ListBulkImportJobsCallable(const ListBulkImportJobsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListBulkImportJobs, request); } /** * An Async wrapper for ListBulkImportJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBulkImportJobsAsync(const ListBulkImportJobsRequestT& request, const ListBulkImportJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListBulkImportJobs, request, handler, context); } /** *

Retrieves a paginated list of dashboards for an IoT SiteWise Monitor * project.

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

Retrieves a paginated list of gateways.

See Also:

AWS * API Reference

*/ virtual Model::ListGatewaysOutcome ListGateways(const Model::ListGatewaysRequest& request) const; /** * A Callable wrapper for ListGateways that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListGatewaysOutcomeCallable ListGatewaysCallable(const ListGatewaysRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListGateways, request); } /** * An Async wrapper for ListGateways that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListGatewaysAsync(const ListGatewaysRequestT& request, const ListGatewaysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListGateways, request, handler, context); } /** *

Retrieves a paginated list of IoT SiteWise Monitor portals.

See * Also:

AWS * API Reference

*/ virtual Model::ListPortalsOutcome ListPortals(const Model::ListPortalsRequest& request) const; /** * A Callable wrapper for ListPortals that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPortalsOutcomeCallable ListPortalsCallable(const ListPortalsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListPortals, request); } /** * An Async wrapper for ListPortals that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPortalsAsync(const ListPortalsRequestT& request, const ListPortalsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListPortals, request, handler, context); } /** *

Retrieves a paginated list of assets associated with an IoT SiteWise Monitor * project.

See Also:

AWS * API Reference

*/ virtual Model::ListProjectAssetsOutcome ListProjectAssets(const Model::ListProjectAssetsRequest& request) const; /** * A Callable wrapper for ListProjectAssets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProjectAssetsOutcomeCallable ListProjectAssetsCallable(const ListProjectAssetsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListProjectAssets, request); } /** * An Async wrapper for ListProjectAssets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProjectAssetsAsync(const ListProjectAssetsRequestT& request, const ListProjectAssetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListProjectAssets, request, handler, context); } /** *

Retrieves a paginated list of projects for an IoT SiteWise Monitor * portal.

See Also:

AWS * API Reference

*/ virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request) const; /** * A Callable wrapper for ListProjects that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListProjects, request); } /** * An Async wrapper for ListProjects that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProjectsAsync(const ListProjectsRequestT& request, const ListProjectsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListProjects, request, handler, context); } /** *

Retrieves the list of tags for an IoT SiteWise 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(&IoTSiteWiseClient::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(&IoTSiteWiseClient::ListTagsForResource, request, handler, context); } /** *

Retrieves a paginated list of time series (data streams).

See * Also:

AWS * API Reference

*/ virtual Model::ListTimeSeriesOutcome ListTimeSeries(const Model::ListTimeSeriesRequest& request) const; /** * A Callable wrapper for ListTimeSeries that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTimeSeriesOutcomeCallable ListTimeSeriesCallable(const ListTimeSeriesRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::ListTimeSeries, request); } /** * An Async wrapper for ListTimeSeries that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTimeSeriesAsync(const ListTimeSeriesRequestT& request, const ListTimeSeriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::ListTimeSeries, request, handler, context); } /** *

Sets the default encryption configuration for the Amazon Web Services * account. For more information, see Key * management in the IoT SiteWise User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::PutDefaultEncryptionConfigurationOutcome PutDefaultEncryptionConfiguration(const Model::PutDefaultEncryptionConfigurationRequest& request) const; /** * A Callable wrapper for PutDefaultEncryptionConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutDefaultEncryptionConfigurationOutcomeCallable PutDefaultEncryptionConfigurationCallable(const PutDefaultEncryptionConfigurationRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::PutDefaultEncryptionConfiguration, request); } /** * An Async wrapper for PutDefaultEncryptionConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutDefaultEncryptionConfigurationAsync(const PutDefaultEncryptionConfigurationRequestT& request, const PutDefaultEncryptionConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::PutDefaultEncryptionConfiguration, request, handler, context); } /** *

Sets logging options for IoT SiteWise.

See Also:

AWS * API Reference

*/ virtual Model::PutLoggingOptionsOutcome PutLoggingOptions(const Model::PutLoggingOptionsRequest& request) const; /** * A Callable wrapper for PutLoggingOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutLoggingOptionsOutcomeCallable PutLoggingOptionsCallable(const PutLoggingOptionsRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::PutLoggingOptions, request); } /** * An Async wrapper for PutLoggingOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutLoggingOptionsAsync(const PutLoggingOptionsRequestT& request, const PutLoggingOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::PutLoggingOptions, request, handler, context); } /** *

Configures storage settings for IoT SiteWise.

See Also:

AWS * API Reference

*/ virtual Model::PutStorageConfigurationOutcome PutStorageConfiguration(const Model::PutStorageConfigurationRequest& request) const; /** * A Callable wrapper for PutStorageConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutStorageConfigurationOutcomeCallable PutStorageConfigurationCallable(const PutStorageConfigurationRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::PutStorageConfiguration, request); } /** * An Async wrapper for PutStorageConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutStorageConfigurationAsync(const PutStorageConfigurationRequestT& request, const PutStorageConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::PutStorageConfiguration, request, handler, context); } /** *

Adds tags to an IoT SiteWise resource. If a tag already exists for the * resource, this operation updates the tag's value.

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

Removes a tag from an IoT SiteWise 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(&IoTSiteWiseClient::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(&IoTSiteWiseClient::UntagResource, request, handler, context); } /** *

Updates an existing access policy that specifies an identity's access to an * IoT SiteWise Monitor portal or project resource.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAccessPolicyOutcome UpdateAccessPolicy(const Model::UpdateAccessPolicyRequest& request) const; /** * A Callable wrapper for UpdateAccessPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAccessPolicyOutcomeCallable UpdateAccessPolicyCallable(const UpdateAccessPolicyRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::UpdateAccessPolicy, request); } /** * An Async wrapper for UpdateAccessPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAccessPolicyAsync(const UpdateAccessPolicyRequestT& request, const UpdateAccessPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::UpdateAccessPolicy, request, handler, context); } /** *

Updates an asset's name. For more information, see Updating * assets and models in the IoT SiteWise User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateAssetOutcome UpdateAsset(const Model::UpdateAssetRequest& request) const; /** * A Callable wrapper for UpdateAsset that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssetOutcomeCallable UpdateAssetCallable(const UpdateAssetRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::UpdateAsset, request); } /** * An Async wrapper for UpdateAsset that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssetAsync(const UpdateAssetRequestT& request, const UpdateAssetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::UpdateAsset, request, handler, context); } /** *

Updates an asset model and all of the assets that were created from the * model. Each asset created from the model inherits the updated asset model's * property and hierarchy definitions. For more information, see Updating * assets and models in the IoT SiteWise User Guide.

*

This operation overwrites the existing model with the provided model. To * avoid deleting your asset model's properties or hierarchies, you must include * their IDs and definitions in the updated asset model payload. For more * information, see DescribeAssetModel.

*

If you remove a property from an asset model, IoT SiteWise deletes all * previous data for that property. If you remove a hierarchy definition from an * asset model, IoT SiteWise disassociates every asset associated with that * hierarchy. You can't change the type or data type of an existing property.

*

See Also:

AWS * API Reference

*/ virtual Model::UpdateAssetModelOutcome UpdateAssetModel(const Model::UpdateAssetModelRequest& request) const; /** * A Callable wrapper for UpdateAssetModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssetModelOutcomeCallable UpdateAssetModelCallable(const UpdateAssetModelRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::UpdateAssetModel, request); } /** * An Async wrapper for UpdateAssetModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssetModelAsync(const UpdateAssetModelRequestT& request, const UpdateAssetModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::UpdateAssetModel, request, handler, context); } /** *

Updates an asset property's alias and notification state.

*

This operation overwrites the property's existing alias and notification * state. To keep your existing property's alias or notification state, you must * include the existing values in the UpdateAssetProperty request. For more * information, see DescribeAssetProperty.

*

See Also:

AWS * API Reference

*/ virtual Model::UpdateAssetPropertyOutcome UpdateAssetProperty(const Model::UpdateAssetPropertyRequest& request) const; /** * A Callable wrapper for UpdateAssetProperty that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAssetPropertyOutcomeCallable UpdateAssetPropertyCallable(const UpdateAssetPropertyRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::UpdateAssetProperty, request); } /** * An Async wrapper for UpdateAssetProperty that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAssetPropertyAsync(const UpdateAssetPropertyRequestT& request, const UpdateAssetPropertyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::UpdateAssetProperty, request, handler, context); } /** *

Updates an IoT SiteWise Monitor dashboard.

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

Updates a gateway's name.

See Also:

AWS * API Reference

*/ virtual Model::UpdateGatewayOutcome UpdateGateway(const Model::UpdateGatewayRequest& request) const; /** * A Callable wrapper for UpdateGateway that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateGatewayOutcomeCallable UpdateGatewayCallable(const UpdateGatewayRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::UpdateGateway, request); } /** * An Async wrapper for UpdateGateway that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateGatewayAsync(const UpdateGatewayRequestT& request, const UpdateGatewayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::UpdateGateway, request, handler, context); } /** *

Updates a gateway capability configuration or defines a new capability * configuration. Each gateway capability defines data sources for a gateway. A * capability configuration can contain multiple data source configurations. If you * define OPC-UA sources for a gateway in the IoT SiteWise console, all of your * OPC-UA sources are stored in one capability configuration. To list all * capability configurations for a gateway, use DescribeGateway.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateGatewayCapabilityConfigurationOutcome UpdateGatewayCapabilityConfiguration(const Model::UpdateGatewayCapabilityConfigurationRequest& request) const; /** * A Callable wrapper for UpdateGatewayCapabilityConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateGatewayCapabilityConfigurationOutcomeCallable UpdateGatewayCapabilityConfigurationCallable(const UpdateGatewayCapabilityConfigurationRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::UpdateGatewayCapabilityConfiguration, request); } /** * An Async wrapper for UpdateGatewayCapabilityConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateGatewayCapabilityConfigurationAsync(const UpdateGatewayCapabilityConfigurationRequestT& request, const UpdateGatewayCapabilityConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::UpdateGatewayCapabilityConfiguration, request, handler, context); } /** *

Updates an IoT SiteWise Monitor portal.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePortalOutcome UpdatePortal(const Model::UpdatePortalRequest& request) const; /** * A Callable wrapper for UpdatePortal that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePortalOutcomeCallable UpdatePortalCallable(const UpdatePortalRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::UpdatePortal, request); } /** * An Async wrapper for UpdatePortal that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePortalAsync(const UpdatePortalRequestT& request, const UpdatePortalResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::UpdatePortal, request, handler, context); } /** *

Updates an IoT SiteWise Monitor project.

See Also:

AWS * API Reference

*/ virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const; /** * A Callable wrapper for UpdateProject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const { return SubmitCallable(&IoTSiteWiseClient::UpdateProject, request); } /** * An Async wrapper for UpdateProject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&IoTSiteWiseClient::UpdateProject, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const IoTSiteWiseClientConfiguration& clientConfiguration); IoTSiteWiseClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace IoTSiteWise } // namespace Aws