@aws-sdk/client-chime-sdk-meetings 3.95.0 → 3.103.0

package/dist-es/commands/BatchUpdateAttendeeCapabilitiesExceptCommand.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 { BatchUpdateAttendeeCapabilitiesExceptRequest } from "../models/models_0";
+import { deserializeAws_restJson1BatchUpdateAttendeeCapabilitiesExceptCommand, serializeAws_restJson1BatchUpdateAttendeeCapabilitiesExceptCommand, } from "../protocols/Aws_restJson1";
+var BatchUpdateAttendeeCapabilitiesExceptCommand = (function (_super) {
+    __extends(BatchUpdateAttendeeCapabilitiesExceptCommand, _super);
+    function BatchUpdateAttendeeCapabilitiesExceptCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchUpdateAttendeeCapabilitiesExceptCommand.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 = "ChimeSDKMeetingsClient";
+        var commandName = "BatchUpdateAttendeeCapabilitiesExceptCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchUpdateAttendeeCapabilitiesExceptRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchUpdateAttendeeCapabilitiesExceptCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1BatchUpdateAttendeeCapabilitiesExceptCommand(input, context);
+    };
+    BatchUpdateAttendeeCapabilitiesExceptCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1BatchUpdateAttendeeCapabilitiesExceptCommand(output, context);
+    };
+    return BatchUpdateAttendeeCapabilitiesExceptCommand;
+}($Command));
+export { BatchUpdateAttendeeCapabilitiesExceptCommand };

package/dist-es/commands/UpdateAttendeeCapabilitiesCommand.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 { UpdateAttendeeCapabilitiesRequest, UpdateAttendeeCapabilitiesResponse } from "../models/models_0";
+import { deserializeAws_restJson1UpdateAttendeeCapabilitiesCommand, serializeAws_restJson1UpdateAttendeeCapabilitiesCommand, } from "../protocols/Aws_restJson1";
+var UpdateAttendeeCapabilitiesCommand = (function (_super) {
+    __extends(UpdateAttendeeCapabilitiesCommand, _super);
+    function UpdateAttendeeCapabilitiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateAttendeeCapabilitiesCommand.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 = "ChimeSDKMeetingsClient";
+        var commandName = "UpdateAttendeeCapabilitiesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateAttendeeCapabilitiesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateAttendeeCapabilitiesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateAttendeeCapabilitiesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateAttendeeCapabilitiesCommand(input, context);
+    };
+    UpdateAttendeeCapabilitiesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateAttendeeCapabilitiesCommand(output, context);
+    };
+    return UpdateAttendeeCapabilitiesCommand;
+}($Command));
+export { UpdateAttendeeCapabilitiesCommand };

package/dist-es/commands/index.js

@@ -1,4 +1,5 @@
 export * from "./BatchCreateAttendeeCommand";
+export * from "./BatchUpdateAttendeeCapabilitiesExceptCommand";
 export * from "./CreateAttendeeCommand";
 export * from "./CreateMeetingCommand";
 export * from "./CreateMeetingWithAttendeesCommand";
@@ -9,3 +10,4 @@ export * from "./GetMeetingCommand";
 export * from "./ListAttendeesCommand";
 export * from "./StartMeetingTranscriptionCommand";
 export * from "./StopMeetingTranscriptionCommand";
+export * from "./UpdateAttendeeCapabilitiesCommand";

package/dist-es/models/models_0.js

@@ -1,10 +1,25 @@
 import { __assign, __extends } from "tslib";
 import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
 import { ChimeSDKMeetingsServiceException as __BaseException } from "./ChimeSDKMeetingsServiceException";
+export var MediaCapabilities;
+(function (MediaCapabilities) {
+    MediaCapabilities["NONE"] = "None";
+    MediaCapabilities["RECEIVE"] = "Receive";
+    MediaCapabilities["SEND"] = "Send";
+    MediaCapabilities["SEND_RECEIVE"] = "SendReceive";
+})(MediaCapabilities || (MediaCapabilities = {}));
+export var AttendeeCapabilities;
+(function (AttendeeCapabilities) {
+    AttendeeCapabilities.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(AttendeeCapabilities || (AttendeeCapabilities = {}));
 export var Attendee;
 (function (Attendee) {
     Attendee.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.ExternalUserId && { ExternalUserId: SENSITIVE_STRING })), (obj.JoinToken && { JoinToken: SENSITIVE_STRING }))); };
 })(Attendee || (Attendee = {}));
+export var AttendeeIdItem;
+(function (AttendeeIdItem) {
+    AttendeeIdItem.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(AttendeeIdItem || (AttendeeIdItem = {}));
 export var MeetingFeatureStatus;
 (function (MeetingFeatureStatus) {
     MeetingFeatureStatus["AVAILABLE"] = "AVAILABLE";
@@ -168,6 +183,25 @@ var UnprocessableEntityException = (function (_super) {
     return UnprocessableEntityException;
 }(__BaseException));
 export { UnprocessableEntityException };
+export var BatchUpdateAttendeeCapabilitiesExceptRequest;
+(function (BatchUpdateAttendeeCapabilitiesExceptRequest) {
+    BatchUpdateAttendeeCapabilitiesExceptRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchUpdateAttendeeCapabilitiesExceptRequest || (BatchUpdateAttendeeCapabilitiesExceptRequest = {}));
+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);
+        _this.Code = opts.Code;
+        _this.Message = opts.Message;
+        _this.RequestId = opts.RequestId;
+        return _this;
+    }
+    return ConflictException;
+}(__BaseException));
+export { ConflictException };
 export var CreateAttendeeRequest;
 (function (CreateAttendeeRequest) {
     CreateAttendeeRequest.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.ExternalUserId && { ExternalUserId: SENSITIVE_STRING }))); };
@@ -348,3 +382,11 @@ export var StopMeetingTranscriptionRequest;
 (function (StopMeetingTranscriptionRequest) {
     StopMeetingTranscriptionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(StopMeetingTranscriptionRequest || (StopMeetingTranscriptionRequest = {}));
+export var UpdateAttendeeCapabilitiesRequest;
+(function (UpdateAttendeeCapabilitiesRequest) {
+    UpdateAttendeeCapabilitiesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateAttendeeCapabilitiesRequest || (UpdateAttendeeCapabilitiesRequest = {}));
+export var UpdateAttendeeCapabilitiesResponse;
+(function (UpdateAttendeeCapabilitiesResponse) {
+    UpdateAttendeeCapabilitiesResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Attendee && { Attendee: Attendee.filterSensitiveLog(obj.Attendee) }))); };
+})(UpdateAttendeeCapabilitiesResponse || (UpdateAttendeeCapabilitiesResponse = {}));

package/dist-es/protocols/Aws_restJson1.js

@@ -3,7 +3,7 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, extendedEncodeURIComponent as __extendedEncodeURIComponent, } from "@aws-sdk/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { ChimeSDKMeetingsServiceException as __BaseException } from "../models/ChimeSDKMeetingsServiceException";
-import { BadRequestException, ForbiddenException, LimitExceededException, NotFoundException, ServiceFailureException, ServiceUnavailableException, ThrottlingException, UnauthorizedException, UnprocessableEntityException, } from "../models/models_0";
+import { BadRequestException, ConflictException, ForbiddenException, LimitExceededException, NotFoundException, ServiceFailureException, ServiceUnavailableException, ThrottlingException, UnauthorizedException, UnprocessableEntityException, } from "../models/models_0";
 export var serializeAws_restJson1BatchCreateAttendeeCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, labelValue, query, body;
     return __generator(this, function (_c) {
@@ -45,6 +45,51 @@ export var serializeAws_restJson1BatchCreateAttendeeCommand = function (input, c
         }
     });
 }); };
+export var serializeAws_restJson1BatchUpdateAttendeeCapabilitiesExceptCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, labelValue, query, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") +
+                    "/meetings/{MeetingId}/attendees/capabilities";
+                if (input.MeetingId !== undefined) {
+                    labelValue = input.MeetingId;
+                    if (labelValue.length <= 0) {
+                        throw new Error("Empty value provided for input HTTP label: MeetingId.");
+                    }
+                    resolvedPath = resolvedPath.replace("{MeetingId}", __extendedEncodeURIComponent(labelValue));
+                }
+                else {
+                    throw new Error("No value provided for input HTTP label: MeetingId.");
+                }
+                query = {
+                    operation: "batch-update-except",
+                };
+                body = JSON.stringify(__assign(__assign({}, (input.Capabilities !== undefined &&
+                    input.Capabilities !== null && {
+                    Capabilities: serializeAws_restJson1AttendeeCapabilities(input.Capabilities, context),
+                })), (input.ExcludedAttendeeIds !== undefined &&
+                    input.ExcludedAttendeeIds !== null && {
+                    ExcludedAttendeeIds: serializeAws_restJson1AttendeeIdsList(input.ExcludedAttendeeIds, context),
+                })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "PUT",
+                        headers: headers,
+                        path: resolvedPath,
+                        query: query,
+                        body: body,
+                    })];
+        }
+    });
+}); };
 export var serializeAws_restJson1CreateAttendeeCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, labelValue, body;
     return __generator(this, function (_c) {
@@ -66,7 +111,10 @@ export var serializeAws_restJson1CreateAttendeeCommand = function (input, contex
                 else {
                     throw new Error("No value provided for input HTTP label: MeetingId.");
                 }
-                body = JSON.stringify(__assign({}, (input.ExternalUserId !== undefined &&
+                body = JSON.stringify(__assign(__assign({}, (input.Capabilities !== undefined &&
+                    input.Capabilities !== null && {
+                    Capabilities: serializeAws_restJson1AttendeeCapabilities(input.Capabilities, context),
+                })), (input.ExternalUserId !== undefined &&
                     input.ExternalUserId !== null && { ExternalUserId: input.ExternalUserId })));
                 return [2, new __HttpRequest({
                         protocol: protocol,
@@ -408,6 +456,54 @@ export var serializeAws_restJson1StopMeetingTranscriptionCommand = function (inp
         }
     });
 }); };
+export var serializeAws_restJson1UpdateAttendeeCapabilitiesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, labelValue, labelValue, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") +
+                    "/meetings/{MeetingId}/attendees/{AttendeeId}/capabilities";
+                if (input.MeetingId !== undefined) {
+                    labelValue = input.MeetingId;
+                    if (labelValue.length <= 0) {
+                        throw new Error("Empty value provided for input HTTP label: MeetingId.");
+                    }
+                    resolvedPath = resolvedPath.replace("{MeetingId}", __extendedEncodeURIComponent(labelValue));
+                }
+                else {
+                    throw new Error("No value provided for input HTTP label: MeetingId.");
+                }
+                if (input.AttendeeId !== undefined) {
+                    labelValue = input.AttendeeId;
+                    if (labelValue.length <= 0) {
+                        throw new Error("Empty value provided for input HTTP label: AttendeeId.");
+                    }
+                    resolvedPath = resolvedPath.replace("{AttendeeId}", __extendedEncodeURIComponent(labelValue));
+                }
+                else {
+                    throw new Error("No value provided for input HTTP label: AttendeeId.");
+                }
+                body = JSON.stringify(__assign({}, (input.Capabilities !== undefined &&
+                    input.Capabilities !== null && {
+                    Capabilities: serializeAws_restJson1AttendeeCapabilities(input.Capabilities, context),
+                })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "PUT",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
+    });
+}); };
 export var deserializeAws_restJson1BatchCreateAttendeeCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var contents, data, _a, _b;
     return __generator(this, function (_c) {
@@ -500,6 +596,76 @@ var deserializeAws_restJson1BatchCreateAttendeeCommandError = function (output,
         }
     });
 }); };
+export var deserializeAws_restJson1BatchUpdateAttendeeCapabilitiesExceptCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1BatchUpdateAttendeeCapabilitiesExceptCommandError(output, context)];
+                }
+                contents = {
+                    $metadata: deserializeMetadata(output),
+                };
+                return [4, collectBody(output.body, context)];
+            case 1:
+                _a.sent();
+                return [2, Promise.resolve(contents)];
+        }
+    });
+}); };
+var deserializeAws_restJson1BatchUpdateAttendeeCapabilitiesExceptCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "BadRequestException": return [3, 2];
+                    case "com.amazonaws.chimesdkmeetings#BadRequestException": return [3, 2];
+                    case "ConflictException": return [3, 4];
+                    case "com.amazonaws.chimesdkmeetings#ConflictException": return [3, 4];
+                    case "ForbiddenException": return [3, 6];
+                    case "com.amazonaws.chimesdkmeetings#ForbiddenException": return [3, 6];
+                    case "NotFoundException": return [3, 8];
+                    case "com.amazonaws.chimesdkmeetings#NotFoundException": return [3, 8];
+                    case "ServiceUnavailableException": return [3, 10];
+                    case "com.amazonaws.chimesdkmeetings#ServiceUnavailableException": return [3, 10];
+                    case "UnauthorizedException": return [3, 12];
+                    case "com.amazonaws.chimesdkmeetings#UnauthorizedException": return [3, 12];
+                }
+                return [3, 14];
+            case 2: return [4, deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14:
+                parsedBody = parsedOutput.body;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode,
+                    $fault: "client",
+                    $metadata: deserializeMetadata(output),
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
 export var deserializeAws_restJson1CreateAttendeeCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var contents, data, _a, _b;
     return __generator(this, function (_c) {
@@ -1308,6 +1474,82 @@ var deserializeAws_restJson1StopMeetingTranscriptionCommandError = function (out
         }
     });
 }); };
+export var deserializeAws_restJson1UpdateAttendeeCapabilitiesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1UpdateAttendeeCapabilitiesCommandError(output, context)];
+                }
+                contents = {
+                    $metadata: deserializeMetadata(output),
+                    Attendee: undefined,
+                };
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.Attendee !== undefined && data.Attendee !== null) {
+                    contents.Attendee = deserializeAws_restJson1Attendee(data.Attendee, context);
+                }
+                return [2, Promise.resolve(contents)];
+        }
+    });
+}); };
+var deserializeAws_restJson1UpdateAttendeeCapabilitiesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = "UnknownError";
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "BadRequestException": return [3, 2];
+                    case "com.amazonaws.chimesdkmeetings#BadRequestException": return [3, 2];
+                    case "ConflictException": return [3, 4];
+                    case "com.amazonaws.chimesdkmeetings#ConflictException": return [3, 4];
+                    case "ForbiddenException": return [3, 6];
+                    case "com.amazonaws.chimesdkmeetings#ForbiddenException": return [3, 6];
+                    case "NotFoundException": return [3, 8];
+                    case "com.amazonaws.chimesdkmeetings#NotFoundException": return [3, 8];
+                    case "ServiceUnavailableException": return [3, 10];
+                    case "com.amazonaws.chimesdkmeetings#ServiceUnavailableException": return [3, 10];
+                    case "UnauthorizedException": return [3, 12];
+                    case "com.amazonaws.chimesdkmeetings#UnauthorizedException": return [3, 12];
+                }
+                return [3, 14];
+            case 2: return [4, deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_restJson1ForbiddenExceptionResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_restJson1NotFoundExceptionResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_restJson1UnauthorizedExceptionResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14:
+                parsedBody = parsedOutput.body;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode,
+                    $fault: "client",
+                    $metadata: deserializeMetadata(output),
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
 var deserializeAws_restJson1BadRequestExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
     var contents, data, exception;
     return __generator(this, function (_a) {
@@ -1326,6 +1568,24 @@ var deserializeAws_restJson1BadRequestExceptionResponse = function (parsedOutput
         return [2, __decorateServiceException(exception, parsedOutput.body)];
     });
 }); };
+var deserializeAws_restJson1ConflictExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, exception;
+    return __generator(this, function (_a) {
+        contents = {};
+        data = parsedOutput.body;
+        if (data.Code !== undefined && data.Code !== null) {
+            contents.Code = __expectString(data.Code);
+        }
+        if (data.Message !== undefined && data.Message !== null) {
+            contents.Message = __expectString(data.Message);
+        }
+        if (data.RequestId !== undefined && data.RequestId !== null) {
+            contents.RequestId = __expectString(data.RequestId);
+        }
+        exception = new ConflictException(__assign({ $metadata: deserializeMetadata(parsedOutput) }, contents));
+        return [2, __decorateServiceException(exception, parsedOutput.body)];
+    });
+}); };
 var deserializeAws_restJson1ForbiddenExceptionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
     var contents, data, exception;
     return __generator(this, function (_a) {
@@ -1473,11 +1733,30 @@ var deserializeAws_restJson1UnprocessableEntityExceptionResponse = function (par
         return [2, __decorateServiceException(exception, parsedOutput.body)];
     });
 }); };
+var serializeAws_restJson1AttendeeCapabilities = function (input, context) {
+    return __assign(__assign(__assign({}, (input.Audio !== undefined && input.Audio !== null && { Audio: input.Audio })), (input.Content !== undefined && input.Content !== null && { Content: input.Content })), (input.Video !== undefined && input.Video !== null && { Video: input.Video }));
+};
+var serializeAws_restJson1AttendeeIdItem = function (input, context) {
+    return __assign({}, (input.AttendeeId !== undefined && input.AttendeeId !== null && { AttendeeId: input.AttendeeId }));
+};
+var serializeAws_restJson1AttendeeIdsList = function (input, context) {
+    return input
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1AttendeeIdItem(entry, context);
+    });
+};
 var serializeAws_restJson1AudioFeatures = function (input, context) {
     return __assign({}, (input.EchoReduction !== undefined && input.EchoReduction !== null && { EchoReduction: input.EchoReduction }));
 };
 var serializeAws_restJson1CreateAttendeeRequestItem = function (input, context) {
-    return __assign({}, (input.ExternalUserId !== undefined &&
+    return __assign(__assign({}, (input.Capabilities !== undefined &&
+        input.Capabilities !== null && {
+        Capabilities: serializeAws_restJson1AttendeeCapabilities(input.Capabilities, context),
+    })), (input.ExternalUserId !== undefined &&
         input.ExternalUserId !== null && { ExternalUserId: input.ExternalUserId }));
 };
 var serializeAws_restJson1CreateAttendeeRequestItemList = function (input, context) {
@@ -1542,10 +1821,20 @@ var serializeAws_restJson1TranscriptionConfiguration = function (input, context)
 var deserializeAws_restJson1Attendee = function (output, context) {
     return {
         AttendeeId: __expectString(output.AttendeeId),
+        Capabilities: output.Capabilities !== undefined && output.Capabilities !== null
+            ? deserializeAws_restJson1AttendeeCapabilities(output.Capabilities, context)
+            : undefined,
         ExternalUserId: __expectString(output.ExternalUserId),
         JoinToken: __expectString(output.JoinToken),
     };
 };
+var deserializeAws_restJson1AttendeeCapabilities = function (output, context) {
+    return {
+        Audio: __expectString(output.Audio),
+        Content: __expectString(output.Content),
+        Video: __expectString(output.Video),
+    };
+};
 var deserializeAws_restJson1AttendeeList = function (output, context) {
     var retVal = (output || [])
         .filter(function (e) { return e != null; })

package/dist-es/runtimeConfig.js

@@ -14,8 +14,10 @@ import { fromUtf8, toUtf8 } from "@aws-sdk/util-utf8-node";
 import { getRuntimeConfig as getSharedRuntimeConfig } from "./runtimeConfig.shared";
 import { loadConfigsForDefaultMode } from "@aws-sdk/smithy-client";
 import { resolveDefaultsModeConfig } from "@aws-sdk/util-defaults-mode-node";
+import { emitWarningIfUnsupportedVersion } from "@aws-sdk/smithy-client";
 export var getRuntimeConfig = function (config) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+    emitWarningIfUnsupportedVersion(process.version);
     var defaultsMode = resolveDefaultsModeConfig(config);
     var defaultConfigProvider = function () { return defaultsMode().then(loadConfigsForDefaultMode); };
     var clientSharedValues = getSharedRuntimeConfig(config);

package/dist-types/ChimeSDKMeetings.d.ts

@@ -1,6 +1,7 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
 import { ChimeSDKMeetingsClient } from "./ChimeSDKMeetingsClient";
 import { BatchCreateAttendeeCommandInput, BatchCreateAttendeeCommandOutput } from "./commands/BatchCreateAttendeeCommand";
+import { BatchUpdateAttendeeCapabilitiesExceptCommandInput, BatchUpdateAttendeeCapabilitiesExceptCommandOutput } from "./commands/BatchUpdateAttendeeCapabilitiesExceptCommand";
 import { CreateAttendeeCommandInput, CreateAttendeeCommandOutput } from "./commands/CreateAttendeeCommand";
 import { CreateMeetingCommandInput, CreateMeetingCommandOutput } from "./commands/CreateMeetingCommand";
 import { CreateMeetingWithAttendeesCommandInput, CreateMeetingWithAttendeesCommandOutput } from "./commands/CreateMeetingWithAttendeesCommand";
@@ -11,6 +12,7 @@ import { GetMeetingCommandInput, GetMeetingCommandOutput } from "./commands/GetM
 import { ListAttendeesCommandInput, ListAttendeesCommandOutput } from "./commands/ListAttendeesCommand";
 import { StartMeetingTranscriptionCommandInput, StartMeetingTranscriptionCommandOutput } from "./commands/StartMeetingTranscriptionCommand";
 import { StopMeetingTranscriptionCommandInput, StopMeetingTranscriptionCommandOutput } from "./commands/StopMeetingTranscriptionCommand";
+import { UpdateAttendeeCapabilitiesCommandInput, UpdateAttendeeCapabilitiesCommandOutput } from "./commands/UpdateAttendeeCapabilitiesCommand";
 /**
  * <p>The Amazon Chime SDK meetings APIs in this section allow software developers to create Amazon Chime SDK meetings, set the AWS Regions for meetings, create and manage users, and send and
  *             receive meeting notifications. For more information about the meeting APIs, see <a href="https://docs.aws.amazon.com/chime/latest/APIReference/API_Operations_Amazon_Chime_SDK_Meetings.html">Amazon Chime SDK meetings</a>.</p>
@@ -23,6 +25,12 @@ export declare class ChimeSDKMeetings extends ChimeSDKMeetingsClient {
     batchCreateAttendee(args: BatchCreateAttendeeCommandInput, options?: __HttpHandlerOptions): Promise<BatchCreateAttendeeCommandOutput>;
     batchCreateAttendee(args: BatchCreateAttendeeCommandInput, cb: (err: any, data?: BatchCreateAttendeeCommandOutput) => void): void;
     batchCreateAttendee(args: BatchCreateAttendeeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchCreateAttendeeCommandOutput) => void): void;
+    /**
+     * <p>Updates <code>AttendeeCapabilities</code> except the capabilities listed in an <code>ExcludedAttendeeIds</code> table.</p>
+     */
+    batchUpdateAttendeeCapabilitiesExcept(args: BatchUpdateAttendeeCapabilitiesExceptCommandInput, options?: __HttpHandlerOptions): Promise<BatchUpdateAttendeeCapabilitiesExceptCommandOutput>;
+    batchUpdateAttendeeCapabilitiesExcept(args: BatchUpdateAttendeeCapabilitiesExceptCommandInput, cb: (err: any, data?: BatchUpdateAttendeeCapabilitiesExceptCommandOutput) => void): void;
+    batchUpdateAttendeeCapabilitiesExcept(args: BatchUpdateAttendeeCapabilitiesExceptCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchUpdateAttendeeCapabilitiesExceptCommandOutput) => void): void;
     /**
      * <p>
      *            Creates a new attendee for an active Amazon Chime SDK meeting. For more information about the Amazon Chime SDK, see
@@ -116,4 +124,10 @@ export declare class ChimeSDKMeetings extends ChimeSDKMeetingsClient {
     stopMeetingTranscription(args: StopMeetingTranscriptionCommandInput, options?: __HttpHandlerOptions): Promise<StopMeetingTranscriptionCommandOutput>;
     stopMeetingTranscription(args: StopMeetingTranscriptionCommandInput, cb: (err: any, data?: StopMeetingTranscriptionCommandOutput) => void): void;
     stopMeetingTranscription(args: StopMeetingTranscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StopMeetingTranscriptionCommandOutput) => void): void;
+    /**
+     * <p>The capabilties that you want to update.</p>
+     */
+    updateAttendeeCapabilities(args: UpdateAttendeeCapabilitiesCommandInput, options?: __HttpHandlerOptions): Promise<UpdateAttendeeCapabilitiesCommandOutput>;
+    updateAttendeeCapabilities(args: UpdateAttendeeCapabilitiesCommandInput, cb: (err: any, data?: UpdateAttendeeCapabilitiesCommandOutput) => void): void;
+    updateAttendeeCapabilities(args: UpdateAttendeeCapabilitiesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateAttendeeCapabilitiesCommandOutput) => void): void;
 }

package/dist-types/ChimeSDKMeetingsClient.d.ts

@@ -7,6 +7,7 @@ import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
 import { Client as __Client, DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
 import { BodyLengthCalculator as __BodyLengthCalculator, Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@aws-sdk/types";
 import { BatchCreateAttendeeCommandInput, BatchCreateAttendeeCommandOutput } from "./commands/BatchCreateAttendeeCommand";
+import { BatchUpdateAttendeeCapabilitiesExceptCommandInput, BatchUpdateAttendeeCapabilitiesExceptCommandOutput } from "./commands/BatchUpdateAttendeeCapabilitiesExceptCommand";
 import { CreateAttendeeCommandInput, CreateAttendeeCommandOutput } from "./commands/CreateAttendeeCommand";
 import { CreateMeetingCommandInput, CreateMeetingCommandOutput } from "./commands/CreateMeetingCommand";
 import { CreateMeetingWithAttendeesCommandInput, CreateMeetingWithAttendeesCommandOutput } from "./commands/CreateMeetingWithAttendeesCommand";
@@ -17,8 +18,9 @@ import { GetMeetingCommandInput, GetMeetingCommandOutput } from "./commands/GetM
 import { ListAttendeesCommandInput, ListAttendeesCommandOutput } from "./commands/ListAttendeesCommand";
 import { StartMeetingTranscriptionCommandInput, StartMeetingTranscriptionCommandOutput } from "./commands/StartMeetingTranscriptionCommand";
 import { StopMeetingTranscriptionCommandInput, StopMeetingTranscriptionCommandOutput } from "./commands/StopMeetingTranscriptionCommand";
-export declare type ServiceInputTypes = BatchCreateAttendeeCommandInput | CreateAttendeeCommandInput | CreateMeetingCommandInput | CreateMeetingWithAttendeesCommandInput | DeleteAttendeeCommandInput | DeleteMeetingCommandInput | GetAttendeeCommandInput | GetMeetingCommandInput | ListAttendeesCommandInput | StartMeetingTranscriptionCommandInput | StopMeetingTranscriptionCommandInput;
-export declare type ServiceOutputTypes = BatchCreateAttendeeCommandOutput | CreateAttendeeCommandOutput | CreateMeetingCommandOutput | CreateMeetingWithAttendeesCommandOutput | DeleteAttendeeCommandOutput | DeleteMeetingCommandOutput | GetAttendeeCommandOutput | GetMeetingCommandOutput | ListAttendeesCommandOutput | StartMeetingTranscriptionCommandOutput | StopMeetingTranscriptionCommandOutput;
+import { UpdateAttendeeCapabilitiesCommandInput, UpdateAttendeeCapabilitiesCommandOutput } from "./commands/UpdateAttendeeCapabilitiesCommand";
+export declare type ServiceInputTypes = BatchCreateAttendeeCommandInput | BatchUpdateAttendeeCapabilitiesExceptCommandInput | CreateAttendeeCommandInput | CreateMeetingCommandInput | CreateMeetingWithAttendeesCommandInput | DeleteAttendeeCommandInput | DeleteMeetingCommandInput | GetAttendeeCommandInput | GetMeetingCommandInput | ListAttendeesCommandInput | StartMeetingTranscriptionCommandInput | StopMeetingTranscriptionCommandInput | UpdateAttendeeCapabilitiesCommandInput;
+export declare type ServiceOutputTypes = BatchCreateAttendeeCommandOutput | BatchUpdateAttendeeCapabilitiesExceptCommandOutput | CreateAttendeeCommandOutput | CreateMeetingCommandOutput | CreateMeetingWithAttendeesCommandOutput | DeleteAttendeeCommandOutput | DeleteMeetingCommandOutput | GetAttendeeCommandOutput | GetMeetingCommandOutput | ListAttendeesCommandOutput | StartMeetingTranscriptionCommandOutput | StopMeetingTranscriptionCommandOutput | UpdateAttendeeCapabilitiesCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
     /**
      * The HTTP handler to use. Fetch in browser and Https in Nodejs.

package/dist-types/commands/BatchUpdateAttendeeCapabilitiesExceptCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ChimeSDKMeetingsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ChimeSDKMeetingsClient";
+import { BatchUpdateAttendeeCapabilitiesExceptRequest } from "../models/models_0";
+export interface BatchUpdateAttendeeCapabilitiesExceptCommandInput extends BatchUpdateAttendeeCapabilitiesExceptRequest {
+}
+export interface BatchUpdateAttendeeCapabilitiesExceptCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Updates <code>AttendeeCapabilities</code> except the capabilities listed in an <code>ExcludedAttendeeIds</code> table.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ChimeSDKMeetingsClient, BatchUpdateAttendeeCapabilitiesExceptCommand } from "@aws-sdk/client-chime-sdk-meetings"; // ES Modules import
+ * // const { ChimeSDKMeetingsClient, BatchUpdateAttendeeCapabilitiesExceptCommand } = require("@aws-sdk/client-chime-sdk-meetings"); // CommonJS import
+ * const client = new ChimeSDKMeetingsClient(config);
+ * const command = new BatchUpdateAttendeeCapabilitiesExceptCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BatchUpdateAttendeeCapabilitiesExceptCommandInput} for command's `input` shape.
+ * @see {@link BatchUpdateAttendeeCapabilitiesExceptCommandOutput} for command's `response` shape.
+ * @see {@link ChimeSDKMeetingsClientResolvedConfig | config} for ChimeSDKMeetingsClient's `config` shape.
+ *
+ */
+export declare class BatchUpdateAttendeeCapabilitiesExceptCommand extends $Command<BatchUpdateAttendeeCapabilitiesExceptCommandInput, BatchUpdateAttendeeCapabilitiesExceptCommandOutput, ChimeSDKMeetingsClientResolvedConfig> {
+    readonly input: BatchUpdateAttendeeCapabilitiesExceptCommandInput;
+    constructor(input: BatchUpdateAttendeeCapabilitiesExceptCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ChimeSDKMeetingsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchUpdateAttendeeCapabilitiesExceptCommandInput, BatchUpdateAttendeeCapabilitiesExceptCommandOutput>;
+    private serialize;
+    private deserialize;
+}