@aws-sdk/client-iotsitewise 3.74.0 → 3.78.0

package/dist-es/IoTSiteWise.js

@@ -3,6 +3,9 @@ import { AssociateAssetsCommand, } from "./commands/AssociateAssetsCommand";
 import { AssociateTimeSeriesToAssetPropertyCommand, } from "./commands/AssociateTimeSeriesToAssetPropertyCommand";
 import { BatchAssociateProjectAssetsCommand, } from "./commands/BatchAssociateProjectAssetsCommand";
 import { BatchDisassociateProjectAssetsCommand, } from "./commands/BatchDisassociateProjectAssetsCommand";
+import { BatchGetAssetPropertyAggregatesCommand, } from "./commands/BatchGetAssetPropertyAggregatesCommand";
+import { BatchGetAssetPropertyValueCommand, } from "./commands/BatchGetAssetPropertyValueCommand";
+import { BatchGetAssetPropertyValueHistoryCommand, } from "./commands/BatchGetAssetPropertyValueHistoryCommand";
 import { BatchPutAssetPropertyValueCommand, } from "./commands/BatchPutAssetPropertyValueCommand";
 import { CreateAccessPolicyCommand, } from "./commands/CreateAccessPolicyCommand";
 import { CreateAssetCommand } from "./commands/CreateAssetCommand";
@@ -126,6 +129,48 @@ var IoTSiteWise = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    IoTSiteWise.prototype.batchGetAssetPropertyAggregates = function (args, optionsOrCb, cb) {
+        var command = new BatchGetAssetPropertyAggregatesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    IoTSiteWise.prototype.batchGetAssetPropertyValue = function (args, optionsOrCb, cb) {
+        var command = new BatchGetAssetPropertyValueCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    IoTSiteWise.prototype.batchGetAssetPropertyValueHistory = function (args, optionsOrCb, cb) {
+        var command = new BatchGetAssetPropertyValueHistoryCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     IoTSiteWise.prototype.batchPutAssetPropertyValue = function (args, optionsOrCb, cb) {
         var command = new BatchPutAssetPropertyValueCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/BatchGetAssetPropertyAggregatesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchGetAssetPropertyAggregatesRequest, BatchGetAssetPropertyAggregatesResponse } from "../models/models_0";
+import { deserializeAws_restJson1BatchGetAssetPropertyAggregatesCommand, serializeAws_restJson1BatchGetAssetPropertyAggregatesCommand, } from "../protocols/Aws_restJson1";
+var BatchGetAssetPropertyAggregatesCommand = (function (_super) {
+    __extends(BatchGetAssetPropertyAggregatesCommand, _super);
+    function BatchGetAssetPropertyAggregatesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchGetAssetPropertyAggregatesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTSiteWiseClient";
+        var commandName = "BatchGetAssetPropertyAggregatesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchGetAssetPropertyAggregatesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchGetAssetPropertyAggregatesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchGetAssetPropertyAggregatesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1BatchGetAssetPropertyAggregatesCommand(input, context);
+    };
+    BatchGetAssetPropertyAggregatesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1BatchGetAssetPropertyAggregatesCommand(output, context);
+    };
+    return BatchGetAssetPropertyAggregatesCommand;
+}($Command));
+export { BatchGetAssetPropertyAggregatesCommand };

package/dist-es/commands/BatchGetAssetPropertyValueCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchGetAssetPropertyValueRequest, BatchGetAssetPropertyValueResponse } from "../models/models_0";
+import { deserializeAws_restJson1BatchGetAssetPropertyValueCommand, serializeAws_restJson1BatchGetAssetPropertyValueCommand, } from "../protocols/Aws_restJson1";
+var BatchGetAssetPropertyValueCommand = (function (_super) {
+    __extends(BatchGetAssetPropertyValueCommand, _super);
+    function BatchGetAssetPropertyValueCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchGetAssetPropertyValueCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTSiteWiseClient";
+        var commandName = "BatchGetAssetPropertyValueCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchGetAssetPropertyValueRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchGetAssetPropertyValueResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchGetAssetPropertyValueCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1BatchGetAssetPropertyValueCommand(input, context);
+    };
+    BatchGetAssetPropertyValueCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1BatchGetAssetPropertyValueCommand(output, context);
+    };
+    return BatchGetAssetPropertyValueCommand;
+}($Command));
+export { BatchGetAssetPropertyValueCommand };

package/dist-es/commands/BatchGetAssetPropertyValueHistoryCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchGetAssetPropertyValueHistoryRequest, BatchGetAssetPropertyValueHistoryResponse, } from "../models/models_0";
+import { deserializeAws_restJson1BatchGetAssetPropertyValueHistoryCommand, serializeAws_restJson1BatchGetAssetPropertyValueHistoryCommand, } from "../protocols/Aws_restJson1";
+var BatchGetAssetPropertyValueHistoryCommand = (function (_super) {
+    __extends(BatchGetAssetPropertyValueHistoryCommand, _super);
+    function BatchGetAssetPropertyValueHistoryCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchGetAssetPropertyValueHistoryCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTSiteWiseClient";
+        var commandName = "BatchGetAssetPropertyValueHistoryCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchGetAssetPropertyValueHistoryRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchGetAssetPropertyValueHistoryResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchGetAssetPropertyValueHistoryCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1BatchGetAssetPropertyValueHistoryCommand(input, context);
+    };
+    BatchGetAssetPropertyValueHistoryCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1BatchGetAssetPropertyValueHistoryCommand(output, context);
+    };
+    return BatchGetAssetPropertyValueHistoryCommand;
+}($Command));
+export { BatchGetAssetPropertyValueHistoryCommand };

package/dist-es/commands/index.js

@@ -2,6 +2,9 @@ export * from "./AssociateAssetsCommand";
 export * from "./AssociateTimeSeriesToAssetPropertyCommand";
 export * from "./BatchAssociateProjectAssetsCommand";
 export * from "./BatchDisassociateProjectAssetsCommand";
+export * from "./BatchGetAssetPropertyAggregatesCommand";
+export * from "./BatchGetAssetPropertyValueCommand";
+export * from "./BatchGetAssetPropertyValueHistoryCommand";
 export * from "./BatchPutAssetPropertyValueCommand";
 export * from "./CreateAccessPolicyCommand";
 export * from "./CreateAssetCommand";

package/dist-es/models/models_0.js

@@ -373,6 +373,130 @@ export var BatchDisassociateProjectAssetsResponse;
 (function (BatchDisassociateProjectAssetsResponse) {
     BatchDisassociateProjectAssetsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(BatchDisassociateProjectAssetsResponse || (BatchDisassociateProjectAssetsResponse = {}));
+export var TimeOrdering;
+(function (TimeOrdering) {
+    TimeOrdering["ASCENDING"] = "ASCENDING";
+    TimeOrdering["DESCENDING"] = "DESCENDING";
+})(TimeOrdering || (TimeOrdering = {}));
+export var BatchGetAssetPropertyAggregatesEntry;
+(function (BatchGetAssetPropertyAggregatesEntry) {
+    BatchGetAssetPropertyAggregatesEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyAggregatesEntry || (BatchGetAssetPropertyAggregatesEntry = {}));
+export var BatchGetAssetPropertyAggregatesRequest;
+(function (BatchGetAssetPropertyAggregatesRequest) {
+    BatchGetAssetPropertyAggregatesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyAggregatesRequest || (BatchGetAssetPropertyAggregatesRequest = {}));
+export var BatchGetAssetPropertyAggregatesErrorCode;
+(function (BatchGetAssetPropertyAggregatesErrorCode) {
+    BatchGetAssetPropertyAggregatesErrorCode["AccessDeniedException"] = "AccessDeniedException";
+    BatchGetAssetPropertyAggregatesErrorCode["InvalidRequestException"] = "InvalidRequestException";
+    BatchGetAssetPropertyAggregatesErrorCode["ResourceNotFoundException"] = "ResourceNotFoundException";
+})(BatchGetAssetPropertyAggregatesErrorCode || (BatchGetAssetPropertyAggregatesErrorCode = {}));
+export var BatchGetAssetPropertyAggregatesErrorEntry;
+(function (BatchGetAssetPropertyAggregatesErrorEntry) {
+    BatchGetAssetPropertyAggregatesErrorEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyAggregatesErrorEntry || (BatchGetAssetPropertyAggregatesErrorEntry = {}));
+export var BatchEntryCompletionStatus;
+(function (BatchEntryCompletionStatus) {
+    BatchEntryCompletionStatus["ERROR"] = "ERROR";
+    BatchEntryCompletionStatus["SUCCESS"] = "SUCCESS";
+})(BatchEntryCompletionStatus || (BatchEntryCompletionStatus = {}));
+export var BatchGetAssetPropertyAggregatesErrorInfo;
+(function (BatchGetAssetPropertyAggregatesErrorInfo) {
+    BatchGetAssetPropertyAggregatesErrorInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyAggregatesErrorInfo || (BatchGetAssetPropertyAggregatesErrorInfo = {}));
+export var BatchGetAssetPropertyAggregatesSkippedEntry;
+(function (BatchGetAssetPropertyAggregatesSkippedEntry) {
+    BatchGetAssetPropertyAggregatesSkippedEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyAggregatesSkippedEntry || (BatchGetAssetPropertyAggregatesSkippedEntry = {}));
+export var BatchGetAssetPropertyAggregatesSuccessEntry;
+(function (BatchGetAssetPropertyAggregatesSuccessEntry) {
+    BatchGetAssetPropertyAggregatesSuccessEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyAggregatesSuccessEntry || (BatchGetAssetPropertyAggregatesSuccessEntry = {}));
+export var BatchGetAssetPropertyAggregatesResponse;
+(function (BatchGetAssetPropertyAggregatesResponse) {
+    BatchGetAssetPropertyAggregatesResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyAggregatesResponse || (BatchGetAssetPropertyAggregatesResponse = {}));
+var ServiceUnavailableException = (function (_super) {
+    __extends(ServiceUnavailableException, _super);
+    function ServiceUnavailableException(opts) {
+        var _this = _super.call(this, __assign({ name: "ServiceUnavailableException", $fault: "server" }, opts)) || this;
+        _this.name = "ServiceUnavailableException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, ServiceUnavailableException.prototype);
+        return _this;
+    }
+    return ServiceUnavailableException;
+}(__BaseException));
+export { ServiceUnavailableException };
+export var BatchGetAssetPropertyValueEntry;
+(function (BatchGetAssetPropertyValueEntry) {
+    BatchGetAssetPropertyValueEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueEntry || (BatchGetAssetPropertyValueEntry = {}));
+export var BatchGetAssetPropertyValueRequest;
+(function (BatchGetAssetPropertyValueRequest) {
+    BatchGetAssetPropertyValueRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueRequest || (BatchGetAssetPropertyValueRequest = {}));
+export var BatchGetAssetPropertyValueErrorCode;
+(function (BatchGetAssetPropertyValueErrorCode) {
+    BatchGetAssetPropertyValueErrorCode["AccessDeniedException"] = "AccessDeniedException";
+    BatchGetAssetPropertyValueErrorCode["InvalidRequestException"] = "InvalidRequestException";
+    BatchGetAssetPropertyValueErrorCode["ResourceNotFoundException"] = "ResourceNotFoundException";
+})(BatchGetAssetPropertyValueErrorCode || (BatchGetAssetPropertyValueErrorCode = {}));
+export var BatchGetAssetPropertyValueErrorEntry;
+(function (BatchGetAssetPropertyValueErrorEntry) {
+    BatchGetAssetPropertyValueErrorEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueErrorEntry || (BatchGetAssetPropertyValueErrorEntry = {}));
+export var BatchGetAssetPropertyValueErrorInfo;
+(function (BatchGetAssetPropertyValueErrorInfo) {
+    BatchGetAssetPropertyValueErrorInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueErrorInfo || (BatchGetAssetPropertyValueErrorInfo = {}));
+export var BatchGetAssetPropertyValueSkippedEntry;
+(function (BatchGetAssetPropertyValueSkippedEntry) {
+    BatchGetAssetPropertyValueSkippedEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueSkippedEntry || (BatchGetAssetPropertyValueSkippedEntry = {}));
+export var BatchGetAssetPropertyValueSuccessEntry;
+(function (BatchGetAssetPropertyValueSuccessEntry) {
+    BatchGetAssetPropertyValueSuccessEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueSuccessEntry || (BatchGetAssetPropertyValueSuccessEntry = {}));
+export var BatchGetAssetPropertyValueResponse;
+(function (BatchGetAssetPropertyValueResponse) {
+    BatchGetAssetPropertyValueResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueResponse || (BatchGetAssetPropertyValueResponse = {}));
+export var BatchGetAssetPropertyValueHistoryEntry;
+(function (BatchGetAssetPropertyValueHistoryEntry) {
+    BatchGetAssetPropertyValueHistoryEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueHistoryEntry || (BatchGetAssetPropertyValueHistoryEntry = {}));
+export var BatchGetAssetPropertyValueHistoryRequest;
+(function (BatchGetAssetPropertyValueHistoryRequest) {
+    BatchGetAssetPropertyValueHistoryRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueHistoryRequest || (BatchGetAssetPropertyValueHistoryRequest = {}));
+export var BatchGetAssetPropertyValueHistoryErrorCode;
+(function (BatchGetAssetPropertyValueHistoryErrorCode) {
+    BatchGetAssetPropertyValueHistoryErrorCode["AccessDeniedException"] = "AccessDeniedException";
+    BatchGetAssetPropertyValueHistoryErrorCode["InvalidRequestException"] = "InvalidRequestException";
+    BatchGetAssetPropertyValueHistoryErrorCode["ResourceNotFoundException"] = "ResourceNotFoundException";
+})(BatchGetAssetPropertyValueHistoryErrorCode || (BatchGetAssetPropertyValueHistoryErrorCode = {}));
+export var BatchGetAssetPropertyValueHistoryErrorEntry;
+(function (BatchGetAssetPropertyValueHistoryErrorEntry) {
+    BatchGetAssetPropertyValueHistoryErrorEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueHistoryErrorEntry || (BatchGetAssetPropertyValueHistoryErrorEntry = {}));
+export var BatchGetAssetPropertyValueHistoryErrorInfo;
+(function (BatchGetAssetPropertyValueHistoryErrorInfo) {
+    BatchGetAssetPropertyValueHistoryErrorInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueHistoryErrorInfo || (BatchGetAssetPropertyValueHistoryErrorInfo = {}));
+export var BatchGetAssetPropertyValueHistorySkippedEntry;
+(function (BatchGetAssetPropertyValueHistorySkippedEntry) {
+    BatchGetAssetPropertyValueHistorySkippedEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueHistorySkippedEntry || (BatchGetAssetPropertyValueHistorySkippedEntry = {}));
+export var BatchGetAssetPropertyValueHistorySuccessEntry;
+(function (BatchGetAssetPropertyValueHistorySuccessEntry) {
+    BatchGetAssetPropertyValueHistorySuccessEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueHistorySuccessEntry || (BatchGetAssetPropertyValueHistorySuccessEntry = {}));
+export var BatchGetAssetPropertyValueHistoryResponse;
+(function (BatchGetAssetPropertyValueHistoryResponse) {
+    BatchGetAssetPropertyValueHistoryResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchGetAssetPropertyValueHistoryResponse || (BatchGetAssetPropertyValueHistoryResponse = {}));
 export var PutAssetPropertyValueEntry;
 (function (PutAssetPropertyValueEntry) {
     PutAssetPropertyValueEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -405,18 +529,6 @@ export var BatchPutAssetPropertyValueResponse;
 (function (BatchPutAssetPropertyValueResponse) {
     BatchPutAssetPropertyValueResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(BatchPutAssetPropertyValueResponse || (BatchPutAssetPropertyValueResponse = {}));
-var ServiceUnavailableException = (function (_super) {
-    __extends(ServiceUnavailableException, _super);
-    function ServiceUnavailableException(opts) {
-        var _this = _super.call(this, __assign({ name: "ServiceUnavailableException", $fault: "server" }, opts)) || this;
-        _this.name = "ServiceUnavailableException";
-        _this.$fault = "server";
-        Object.setPrototypeOf(_this, ServiceUnavailableException.prototype);
-        return _this;
-    }
-    return ServiceUnavailableException;
-}(__BaseException));
-export { ServiceUnavailableException };
 export var CreateAccessPolicyRequest;
 (function (CreateAccessPolicyRequest) {
     CreateAccessPolicyRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -771,11 +883,6 @@ export var DisassociateTimeSeriesFromAssetPropertyRequest;
 (function (DisassociateTimeSeriesFromAssetPropertyRequest) {
     DisassociateTimeSeriesFromAssetPropertyRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DisassociateTimeSeriesFromAssetPropertyRequest || (DisassociateTimeSeriesFromAssetPropertyRequest = {}));
-export var TimeOrdering;
-(function (TimeOrdering) {
-    TimeOrdering["ASCENDING"] = "ASCENDING";
-    TimeOrdering["DESCENDING"] = "DESCENDING";
-})(TimeOrdering || (TimeOrdering = {}));
 export var GetAssetPropertyAggregatesRequest;
 (function (GetAssetPropertyAggregatesRequest) {
     GetAssetPropertyAggregatesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/BatchGetAssetPropertyAggregatesPaginator.js

@@ -0,0 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { BatchGetAssetPropertyAggregatesCommand, } from "../commands/BatchGetAssetPropertyAggregatesCommand";
+import { IoTSiteWise } from "../IoTSiteWise";
+import { IoTSiteWiseClient } from "../IoTSiteWiseClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new BatchGetAssetPropertyAggregatesCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.batchGetAssetPropertyAggregates.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateBatchGetAssetPropertyAggregates(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateBatchGetAssetPropertyAggregates_1() {
+        var token, hasNext, page, prevToken;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    input["maxResults"] = config.pageSize;
+                    if (!(config.client instanceof IoTSiteWise)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof IoTSiteWiseClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected IoTSiteWise | IoTSiteWiseClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.nextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/BatchGetAssetPropertyValueHistoryPaginator.js

@@ -0,0 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { BatchGetAssetPropertyValueHistoryCommand, } from "../commands/BatchGetAssetPropertyValueHistoryCommand";
+import { IoTSiteWise } from "../IoTSiteWise";
+import { IoTSiteWiseClient } from "../IoTSiteWiseClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new BatchGetAssetPropertyValueHistoryCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.batchGetAssetPropertyValueHistory.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateBatchGetAssetPropertyValueHistory(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateBatchGetAssetPropertyValueHistory_1() {
+        var token, hasNext, page, prevToken;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    input["maxResults"] = config.pageSize;
+                    if (!(config.client instanceof IoTSiteWise)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof IoTSiteWiseClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected IoTSiteWise | IoTSiteWiseClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.nextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/BatchGetAssetPropertyValuePaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { BatchGetAssetPropertyValueCommand, } from "../commands/BatchGetAssetPropertyValueCommand";
+import { IoTSiteWise } from "../IoTSiteWise";
+import { IoTSiteWiseClient } from "../IoTSiteWiseClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new BatchGetAssetPropertyValueCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.batchGetAssetPropertyValue.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateBatchGetAssetPropertyValue(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateBatchGetAssetPropertyValue_1() {
+        var token, hasNext, page, prevToken;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    if (!(config.client instanceof IoTSiteWise)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof IoTSiteWiseClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected IoTSiteWise | IoTSiteWiseClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.nextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/GetAssetPropertyAggregatesPaginator.js

@@ -36,7 +36,7 @@ export function paginateGetAssetPropertyAggregates(config, input) {
         additionalArguments[_i - 2] = arguments[_i];
     }
     return __asyncGenerator(this, arguments, function paginateGetAssetPropertyAggregates_1() {
-        var token, hasNext, page;
+        var token, hasNext, page, prevToken;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -63,8 +63,9 @@ export function paginateGetAssetPropertyAggregates(config, input) {
                 case 7: return [4, _a.sent()];
                 case 8:
                     _a.sent();
+                    prevToken = token;
                     token = page.nextToken;
-                    hasNext = !!token;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
                     return [3, 1];
                 case 9: return [4, __await(undefined)];
                 case 10: return [2, _a.sent()];

package/dist-es/pagination/GetAssetPropertyValueHistoryPaginator.js

@@ -36,7 +36,7 @@ export function paginateGetAssetPropertyValueHistory(config, input) {
         additionalArguments[_i - 2] = arguments[_i];
     }
     return __asyncGenerator(this, arguments, function paginateGetAssetPropertyValueHistory_1() {
-        var token, hasNext, page;
+        var token, hasNext, page, prevToken;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -63,8 +63,9 @@ export function paginateGetAssetPropertyValueHistory(config, input) {
                 case 7: return [4, _a.sent()];
                 case 8:
                     _a.sent();
+                    prevToken = token;
                     token = page.nextToken;
-                    hasNext = !!token;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
                     return [3, 1];
                 case 9: return [4, __await(undefined)];
                 case 10: return [2, _a.sent()];

package/dist-es/pagination/GetInterpolatedAssetPropertyValuesPaginator.js

@@ -36,7 +36,7 @@ export function paginateGetInterpolatedAssetPropertyValues(config, input) {
         additionalArguments[_i - 2] = arguments[_i];
     }
     return __asyncGenerator(this, arguments, function paginateGetInterpolatedAssetPropertyValues_1() {
-        var token, hasNext, page;
+        var token, hasNext, page, prevToken;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -63,8 +63,9 @@ export function paginateGetInterpolatedAssetPropertyValues(config, input) {
                 case 7: return [4, _a.sent()];
                 case 8:
                     _a.sent();
+                    prevToken = token;
                     token = page.nextToken;
-                    hasNext = !!token;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
                     return [3, 1];
                 case 9: return [4, __await(undefined)];
                 case 10: return [2, _a.sent()];