@aws-sdk/client-iot-data-plane 3.181.0 → 3.183.0

package/dist-es/commands/UpdateThingShadowCommand.js

@@ -1,39 +1,32 @@
-import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateThingShadowRequestFilterSensitiveLog, UpdateThingShadowResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateThingShadowCommand, serializeAws_restJson1UpdateThingShadowCommand, } from "../protocols/Aws_restJson1";
-var UpdateThingShadowCommand = (function (_super) {
-    __extends(UpdateThingShadowCommand, _super);
-    function UpdateThingShadowCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class UpdateThingShadowCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    UpdateThingShadowCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "IoTDataPlaneClient";
-        var commandName = "UpdateThingShadowCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "IoTDataPlaneClient";
+        const commandName = "UpdateThingShadowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: UpdateThingShadowRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateThingShadowResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    UpdateThingShadowCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1UpdateThingShadowCommand(input, context);
-    };
-    UpdateThingShadowCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1UpdateThingShadowCommand(output, context);
-    };
-    return UpdateThingShadowCommand;
-}($Command));
-export { UpdateThingShadowCommand };
+    }
+}

package/dist-es/endpoints.js

@@ -1,6 +1,5 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { getRegionInfo } from "@aws-sdk/config-resolver";
-var regionHash = {
+const regionHash = {
     "ca-central-1": {
         variants: [
             {
@@ -58,7 +57,7 @@ var regionHash = {
         ],
     },
 };
-var partitionHash = {
+const partitionHash = {
     aws: {
         regions: [
             "af-south-1",
@@ -183,8 +182,9 @@ var partitionHash = {
         ],
     },
 };
-export var defaultRegionInfoProvider = function (region, options) { return __awaiter(void 0, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-        return [2, getRegionInfo(region, __assign(__assign({}, options), { signingService: "iotdata", regionHash: regionHash, partitionHash: partitionHash }))];
-    });
-}); };
+export const defaultRegionInfoProvider = async (region, options) => getRegionInfo(region, {
+    ...options,
+    signingService: "iotdata",
+    regionHash,
+    partitionHash,
+});

package/dist-es/models/IoTDataPlaneServiceException.js

@@ -1,12 +1,7 @@
-import { __extends } from "tslib";
 import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
-var IoTDataPlaneServiceException = (function (_super) {
-    __extends(IoTDataPlaneServiceException, _super);
-    function IoTDataPlaneServiceException(options) {
-        var _this = _super.call(this, options) || this;
-        Object.setPrototypeOf(_this, IoTDataPlaneServiceException.prototype);
-        return _this;
+export class IoTDataPlaneServiceException extends __ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, IoTDataPlaneServiceException.prototype);
     }
-    return IoTDataPlaneServiceException;
-}(__ServiceException));
-export { IoTDataPlaneServiceException };
+}

package/dist-es/models/models_0.js

@@ -1,136 +1,163 @@
-import { __assign, __extends } from "tslib";
 import { IoTDataPlaneServiceException as __BaseException } from "./IoTDataPlaneServiceException";
-var ConflictException = (function (_super) {
-    __extends(ConflictException, _super);
-    function ConflictException(opts) {
-        var _this = _super.call(this, __assign({ name: "ConflictException", $fault: "client" }, opts)) || this;
-        _this.name = "ConflictException";
-        _this.$fault = "client";
-        Object.setPrototypeOf(_this, ConflictException.prototype);
-        return _this;
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
     }
-    return ConflictException;
-}(__BaseException));
-export { ConflictException };
-var InternalFailureException = (function (_super) {
-    __extends(InternalFailureException, _super);
-    function InternalFailureException(opts) {
-        var _this = _super.call(this, __assign({ name: "InternalFailureException", $fault: "server" }, opts)) || this;
-        _this.name = "InternalFailureException";
-        _this.$fault = "server";
-        Object.setPrototypeOf(_this, InternalFailureException.prototype);
-        return _this;
+}
+export class InternalFailureException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalFailureException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalFailureException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalFailureException.prototype);
     }
-    return InternalFailureException;
-}(__BaseException));
-export { InternalFailureException };
-var InvalidRequestException = (function (_super) {
-    __extends(InvalidRequestException, _super);
-    function InvalidRequestException(opts) {
-        var _this = _super.call(this, __assign({ name: "InvalidRequestException", $fault: "client" }, opts)) || this;
-        _this.name = "InvalidRequestException";
-        _this.$fault = "client";
-        Object.setPrototypeOf(_this, InvalidRequestException.prototype);
-        return _this;
+}
+export class InvalidRequestException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "InvalidRequestException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, InvalidRequestException.prototype);
     }
-    return InvalidRequestException;
-}(__BaseException));
-export { InvalidRequestException };
-var MethodNotAllowedException = (function (_super) {
-    __extends(MethodNotAllowedException, _super);
-    function MethodNotAllowedException(opts) {
-        var _this = _super.call(this, __assign({ name: "MethodNotAllowedException", $fault: "client" }, opts)) || this;
-        _this.name = "MethodNotAllowedException";
-        _this.$fault = "client";
-        Object.setPrototypeOf(_this, MethodNotAllowedException.prototype);
-        return _this;
+}
+export class MethodNotAllowedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "MethodNotAllowedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "MethodNotAllowedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, MethodNotAllowedException.prototype);
     }
-    return MethodNotAllowedException;
-}(__BaseException));
-export { MethodNotAllowedException };
-var ResourceNotFoundException = (function (_super) {
-    __extends(ResourceNotFoundException, _super);
-    function ResourceNotFoundException(opts) {
-        var _this = _super.call(this, __assign({ name: "ResourceNotFoundException", $fault: "client" }, opts)) || this;
-        _this.name = "ResourceNotFoundException";
-        _this.$fault = "client";
-        Object.setPrototypeOf(_this, ResourceNotFoundException.prototype);
-        return _this;
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-    return ResourceNotFoundException;
-}(__BaseException));
-export { ResourceNotFoundException };
-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;
+}
+export class ServiceUnavailableException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceUnavailableException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "ServiceUnavailableException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
     }
-    return ServiceUnavailableException;
-}(__BaseException));
-export { ServiceUnavailableException };
-var ThrottlingException = (function (_super) {
-    __extends(ThrottlingException, _super);
-    function ThrottlingException(opts) {
-        var _this = _super.call(this, __assign({ name: "ThrottlingException", $fault: "client" }, opts)) || this;
-        _this.name = "ThrottlingException";
-        _this.$fault = "client";
-        Object.setPrototypeOf(_this, ThrottlingException.prototype);
-        return _this;
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-    return ThrottlingException;
-}(__BaseException));
-export { ThrottlingException };
-var UnauthorizedException = (function (_super) {
-    __extends(UnauthorizedException, _super);
-    function UnauthorizedException(opts) {
-        var _this = _super.call(this, __assign({ name: "UnauthorizedException", $fault: "client" }, opts)) || this;
-        _this.name = "UnauthorizedException";
-        _this.$fault = "client";
-        Object.setPrototypeOf(_this, UnauthorizedException.prototype);
-        return _this;
+}
+export class UnauthorizedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "UnauthorizedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "UnauthorizedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, UnauthorizedException.prototype);
     }
-    return UnauthorizedException;
-}(__BaseException));
-export { UnauthorizedException };
-var UnsupportedDocumentEncodingException = (function (_super) {
-    __extends(UnsupportedDocumentEncodingException, _super);
-    function UnsupportedDocumentEncodingException(opts) {
-        var _this = _super.call(this, __assign({ name: "UnsupportedDocumentEncodingException", $fault: "client" }, opts)) || this;
-        _this.name = "UnsupportedDocumentEncodingException";
-        _this.$fault = "client";
-        Object.setPrototypeOf(_this, UnsupportedDocumentEncodingException.prototype);
-        return _this;
+}
+export class UnsupportedDocumentEncodingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "UnsupportedDocumentEncodingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "UnsupportedDocumentEncodingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, UnsupportedDocumentEncodingException.prototype);
     }
-    return UnsupportedDocumentEncodingException;
-}(__BaseException));
-export { UnsupportedDocumentEncodingException };
-var RequestEntityTooLargeException = (function (_super) {
-    __extends(RequestEntityTooLargeException, _super);
-    function RequestEntityTooLargeException(opts) {
-        var _this = _super.call(this, __assign({ name: "RequestEntityTooLargeException", $fault: "client" }, opts)) || this;
-        _this.name = "RequestEntityTooLargeException";
-        _this.$fault = "client";
-        Object.setPrototypeOf(_this, RequestEntityTooLargeException.prototype);
-        return _this;
+}
+export class RequestEntityTooLargeException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "RequestEntityTooLargeException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "RequestEntityTooLargeException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, RequestEntityTooLargeException.prototype);
     }
-    return RequestEntityTooLargeException;
-}(__BaseException));
-export { RequestEntityTooLargeException };
-export var DeleteThingShadowRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var DeleteThingShadowResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var GetRetainedMessageRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var GetRetainedMessageResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var GetThingShadowRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var GetThingShadowResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var ListNamedShadowsForThingRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var ListNamedShadowsForThingResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var ListRetainedMessagesRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var RetainedMessageSummaryFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var ListRetainedMessagesResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var PublishRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var UpdateThingShadowRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-export var UpdateThingShadowResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+}
+export const DeleteThingShadowRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteThingShadowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetRetainedMessageRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetRetainedMessageResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetThingShadowRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetThingShadowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListNamedShadowsForThingRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListNamedShadowsForThingResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListRetainedMessagesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RetainedMessageSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListRetainedMessagesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PublishRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateThingShadowRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateThingShadowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});

package/dist-es/pagination/ListRetainedMessagesPaginator.js

@@ -1,75 +1,32 @@
-import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
 import { ListRetainedMessagesCommand, } from "../commands/ListRetainedMessagesCommand";
 import { IoTDataPlane } from "../IoTDataPlane";
 import { IoTDataPlaneClient } from "../IoTDataPlaneClient";
-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 ListRetainedMessagesCommand(input)], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListRetainedMessagesCommand(input), ...args);
 };
-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.listRetainedMessages.apply(client, __spreadArray([input], __read(args), false))];
-                case 1: return [2, _a.sent()];
-            }
-        });
-    });
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listRetainedMessages(input, ...args);
 };
-export function paginateListRetainedMessages(config, input) {
-    var additionalArguments = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        additionalArguments[_i - 2] = arguments[_i];
+export async function* paginateListRetainedMessages(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof IoTDataPlane) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof IoTDataPlaneClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected IoTDataPlane | IoTDataPlaneClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
     }
-    return __asyncGenerator(this, arguments, function paginateListRetainedMessages_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 IoTDataPlane)) 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 IoTDataPlaneClient)) 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 IoTDataPlane | IoTDataPlaneClient");
-                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()];
-            }
-        });
-    });
+    return undefined;
 }