@aws-sdk/client-chime-sdk-meetings 3.100.0 → 3.108.0

package/dist-es/ChimeSDKMeetings.js

@@ -1,6 +1,7 @@
 import { __extends } from "tslib";
 import { ChimeSDKMeetingsClient } from "./ChimeSDKMeetingsClient";
 import { BatchCreateAttendeeCommand, } from "./commands/BatchCreateAttendeeCommand";
+import { BatchUpdateAttendeeCapabilitiesExceptCommand, } from "./commands/BatchUpdateAttendeeCapabilitiesExceptCommand";
 import { CreateAttendeeCommand, } from "./commands/CreateAttendeeCommand";
 import { CreateMeetingCommand, } from "./commands/CreateMeetingCommand";
 import { CreateMeetingWithAttendeesCommand, } from "./commands/CreateMeetingWithAttendeesCommand";
@@ -11,6 +12,7 @@ import { GetMeetingCommand } from "./commands/GetMeetingCommand";
 import { ListAttendeesCommand, } from "./commands/ListAttendeesCommand";
 import { StartMeetingTranscriptionCommand, } from "./commands/StartMeetingTranscriptionCommand";
 import { StopMeetingTranscriptionCommand, } from "./commands/StopMeetingTranscriptionCommand";
+import { UpdateAttendeeCapabilitiesCommand, } from "./commands/UpdateAttendeeCapabilitiesCommand";
 var ChimeSDKMeetings = (function (_super) {
     __extends(ChimeSDKMeetings, _super);
     function ChimeSDKMeetings() {
@@ -30,6 +32,20 @@ var ChimeSDKMeetings = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    ChimeSDKMeetings.prototype.batchUpdateAttendeeCapabilitiesExcept = function (args, optionsOrCb, cb) {
+        var command = new BatchUpdateAttendeeCapabilitiesExceptCommand(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);
+        }
+    };
     ChimeSDKMeetings.prototype.createAttendee = function (args, optionsOrCb, cb) {
         var command = new CreateAttendeeCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -170,6 +186,20 @@ var ChimeSDKMeetings = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    ChimeSDKMeetings.prototype.updateAttendeeCapabilities = function (args, optionsOrCb, cb) {
+        var command = new UpdateAttendeeCapabilitiesCommand(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);
+        }
+    };
     return ChimeSDKMeetings;
 }(ChimeSDKMeetingsClient));
 export { ChimeSDKMeetings };

package/dist-es/ChimeSDKMeetingsClient.js

@@ -3,6 +3,7 @@ import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-re
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
 import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRecursionDetectionPlugin } from "@aws-sdk/middleware-recursion-detection";
 import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
 import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
@@ -25,6 +26,7 @@ var ChimeSDKMeetingsClient = (function (_super) {
         _this.middlewareStack.use(getContentLengthPlugin(_this.config));
         _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
         _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
         _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
         _this.middlewareStack.use(getUserAgentPlugin(_this.config));
         return _this;

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 }))); };
@@ -324,6 +358,7 @@ export var TranscribeRegion;
     TranscribeRegion["SA_EAST_1"] = "sa-east-1";
     TranscribeRegion["US_EAST_1"] = "us-east-1";
     TranscribeRegion["US_EAST_2"] = "us-east-2";
+    TranscribeRegion["US_GOV_WEST_1"] = "us-gov-west-1";
     TranscribeRegion["US_WEST_2"] = "us-west-2";
 })(TranscribeRegion || (TranscribeRegion = {}));
 export var TranscribeVocabularyFilterMethod;
@@ -348,3 +383,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-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;
 }