@aws-sdk/client-chime-sdk-meetings 3.476.0 → 3.477.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,88 +1,64 @@
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
+import { requestBuilder as rb } from "@smithy/core";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { ChimeSDKMeetingsServiceException as __BaseException } from "../models/ChimeSDKMeetingsServiceException";
 import { BadRequestException, ConflictException, ForbiddenException, LimitExceededException, NotFoundException, ResourceNotFoundException, ServiceFailureException, ServiceUnavailableException, ThrottlingException, TooManyTagsException, UnauthorizedException, UnprocessableEntityException, } from "../models/models_0";
 export const se_BatchCreateAttendeeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/meetings/{MeetingId}/attendees";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.bp("/meetings/{MeetingId}/attendees");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
     const query = map({
-        operation: [, "batch-create"],
+        [_o]: [, "batch-create"],
     });
     let body;
     body = JSON.stringify(take(input, {
         Attendees: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_BatchUpdateAttendeeCapabilitiesExceptCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/meetings/{MeetingId}/attendees/capabilities";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.bp("/meetings/{MeetingId}/attendees/capabilities");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
     const query = map({
-        operation: [, "batch-update-except"],
+        [_o]: [, "batch-update-except"],
     });
     let body;
     body = JSON.stringify(take(input, {
         Capabilities: (_) => _json(_),
         ExcludedAttendeeIds: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("PUT").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_CreateAttendeeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/meetings/{MeetingId}/attendees";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.bp("/meetings/{MeetingId}/attendees");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
     let body;
     body = JSON.stringify(take(input, {
         Capabilities: (_) => _json(_),
         ExternalUserId: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateMeetingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/meetings";
+    b.bp("/meetings");
     let body;
     body = JSON.stringify(take(input, {
         ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -95,24 +71,17 @@ export const se_CreateMeetingCommand = async (input, context) => {
         Tags: (_) => _json(_),
         TenantIds: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateMeetingWithAttendeesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/meetings";
+    b.bp("/meetings");
     const query = map({
-        operation: [, "create-attendees"],
+        [_o]: [, "create-attendees"],
     });
     let body;
     body = JSON.stringify(take(input, {
@@ -127,242 +96,148 @@ export const se_CreateMeetingWithAttendeesCommand = async (input, context) => {
         Tags: (_) => _json(_),
         TenantIds: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_DeleteAttendeeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/meetings/{MeetingId}/attendees/{AttendeeId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "AttendeeId", () => input.AttendeeId, "{AttendeeId}", false);
+    b.bp("/meetings/{MeetingId}/attendees/{AttendeeId}");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.p("AttendeeId", () => input.AttendeeId, "{AttendeeId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteMeetingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/meetings/{MeetingId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.bp("/meetings/{MeetingId}");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_GetAttendeeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/meetings/{MeetingId}/attendees/{AttendeeId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "AttendeeId", () => input.AttendeeId, "{AttendeeId}", false);
+    b.bp("/meetings/{MeetingId}/attendees/{AttendeeId}");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.p("AttendeeId", () => input.AttendeeId, "{AttendeeId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetMeetingCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/meetings/{MeetingId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.bp("/meetings/{MeetingId}");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_ListAttendeesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/meetings/{MeetingId}/attendees";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.bp("/meetings/{MeetingId}/attendees");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
     const query = map({
-        "next-token": [, input.NextToken],
-        "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        [_nt]: [, input[_NT]],
+        [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListTagsForResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = map({
-        arn: [, __expectNonNull(input.ResourceARN, `ResourceARN`)],
+        [_a]: [, __expectNonNull(input[_RARN], `ResourceARN`)],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_StartMeetingTranscriptionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/meetings/{MeetingId}/transcription";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.bp("/meetings/{MeetingId}/transcription");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
     const query = map({
-        operation: [, "start"],
+        [_o]: [, "start"],
     });
     let body;
     body = JSON.stringify(take(input, {
         TranscriptionConfiguration: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_StopMeetingTranscriptionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/meetings/{MeetingId}/transcription";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.bp("/meetings/{MeetingId}/transcription");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
     const query = map({
-        operation: [, "stop"],
+        [_o]: [, "stop"],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_TagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = map({
-        operation: [, "tag-resource"],
+        [_o]: [, "tag-resource"],
     });
     let body;
     body = JSON.stringify(take(input, {
         ResourceARN: [],
         Tags: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_UntagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
+    b.bp("/tags");
     const query = map({
-        operation: [, "untag-resource"],
+        [_o]: [, "untag-resource"],
     });
     let body;
     body = JSON.stringify(take(input, {
         ResourceARN: [],
         TagKeys: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_UpdateAttendeeCapabilitiesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/meetings/{MeetingId}/attendees/{AttendeeId}/capabilities";
-    resolvedPath = __resolvedPath(resolvedPath, input, "MeetingId", () => input.MeetingId, "{MeetingId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "AttendeeId", () => input.AttendeeId, "{AttendeeId}", false);
+    b.bp("/meetings/{MeetingId}/attendees/{AttendeeId}/capabilities");
+    b.p("MeetingId", () => input.MeetingId, "{MeetingId}", false);
+    b.p("AttendeeId", () => input.AttendeeId, "{AttendeeId}", false);
     let body;
     body = JSON.stringify(take(input, {
         Capabilities: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "PUT",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
 export const de_BatchCreateAttendeeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1310,7 +1185,7 @@ const de_ServiceFailureExceptionRes = async (parsedOutput, context) => {
 };
 const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
     const contents = map({
-        RetryAfterSeconds: [, parsedOutput.headers["retry-after"]],
+        [_RAS]: [, parsedOutput.headers[_ra]],
     });
     const data = parsedOutput.body;
     const doc = take(data, {
@@ -1398,6 +1273,15 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _MR = "MaxResults";
+const _NT = "NextToken";
+const _RARN = "ResourceARN";
+const _RAS = "RetryAfterSeconds";
+const _a = "arn";
+const _mr = "max-results";
+const _nt = "next-token";
+const _o = "operation";
+const _ra = "retry-after";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);

package/dist-types/ChimeSDKMeetings.d.ts

@@ -116,7 +116,7 @@ export interface ChimeSDKMeetings {
 }
 /**
  * @public
- * <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
+ * <p>The Amazon Chime SDK meetings APIs in this section allow software developers to create Amazon Chime SDK meetings, set the Amazon Web Services 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>
  */

package/dist-types/ChimeSDKMeetingsClient.d.ts

@@ -168,7 +168,7 @@ export interface ChimeSDKMeetingsClientResolvedConfig extends ChimeSDKMeetingsCl
 }
 /**
  * @public
- * <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
+ * <p>The Amazon Chime SDK meetings APIs in this section allow software developers to create Amazon Chime SDK meetings, set the Amazon Web Services 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>
  */

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

@@ -31,6 +31,14 @@ export interface BatchUpdateAttendeeCapabilitiesExceptCommandOutput extends __Me
  *          <p>When using capabilities, be aware of these corner cases:</p>
  *          <ul>
  *             <li>
+ *                <p>If you specify <code>MeetingFeatures:Video:MaxResolution:None</code> when you create a meeting, all API requests
+ *                     that include <code>SendReceive</code>, <code>Send</code>, or <code>Receive</code> for <code>AttendeeCapabilities:Video</code> will be rejected with <code>ValidationError 400</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>If you specify <code>MeetingFeatures:Content:MaxResolution:None</code> when you create a meeting, all API requests that include <code>SendReceive</code>, <code>Send</code>, or
+ *                     <code>Receive</code> for <code>AttendeeCapabilities:Content</code> will be rejected with <code>ValidationError 400</code>.</p>
+ *             </li>
+ *             <li>
  *                <p>You can't set <code>content</code> capabilities to <code>SendReceive</code> or <code>Receive</code> unless you also set <code>video</code> capabilities to <code>SendReceive</code>
  *                     or <code>Receive</code>. If you don't set the <code>video</code> capability to receive, the response will contain an HTTP 400 Bad Request status code. However, you can set your <code>video</code> capability
  *                     to receive and you set your <code>content</code> capability to not receive.</p>

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

@@ -50,6 +50,15 @@ export interface CreateMeetingCommandOutput extends CreateMeetingResponse, __Met
  *     Audio: { // AudioFeatures
  *       EchoReduction: "AVAILABLE" || "UNAVAILABLE",
  *     },
+ *     Video: { // VideoFeatures
+ *       MaxResolution: "None" || "HD" || "FHD",
+ *     },
+ *     Content: { // ContentFeatures
+ *       MaxResolution: "None" || "FHD" || "UHD",
+ *     },
+ *     Attendee: { // AttendeeFeatures
+ *       MaxCount: Number("int"),
+ *     },
  *   },
  *   PrimaryMeetingId: "STRING_VALUE",
  *   TenantIds: [ // TenantIdList
@@ -84,6 +93,15 @@ export interface CreateMeetingCommandOutput extends CreateMeetingResponse, __Met
  * //       Audio: { // AudioFeatures
  * //         EchoReduction: "AVAILABLE" || "UNAVAILABLE",
  * //       },
+ * //       Video: { // VideoFeatures
+ * //         MaxResolution: "None" || "HD" || "FHD",
+ * //       },
+ * //       Content: { // ContentFeatures
+ * //         MaxResolution: "None" || "FHD" || "UHD",
+ * //       },
+ * //       Attendee: { // AttendeeFeatures
+ * //         MaxCount: Number("int"),
+ * //       },
  * //     },
  * //     PrimaryMeetingId: "STRING_VALUE",
  * //     TenantIds: [ // TenantIdList

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

@@ -45,6 +45,15 @@ export interface CreateMeetingWithAttendeesCommandOutput extends CreateMeetingWi
  *     Audio: { // AudioFeatures
  *       EchoReduction: "AVAILABLE" || "UNAVAILABLE",
  *     },
+ *     Video: { // VideoFeatures
+ *       MaxResolution: "None" || "HD" || "FHD",
+ *     },
+ *     Content: { // ContentFeatures
+ *       MaxResolution: "None" || "FHD" || "UHD",
+ *     },
+ *     Attendee: { // AttendeeFeatures
+ *       MaxCount: Number("int"),
+ *     },
  *   },
  *   NotificationsConfiguration: { // NotificationsConfiguration
  *     LambdaFunctionArn: "STRING_VALUE",
@@ -94,6 +103,15 @@ export interface CreateMeetingWithAttendeesCommandOutput extends CreateMeetingWi
  * //       Audio: { // AudioFeatures
  * //         EchoReduction: "AVAILABLE" || "UNAVAILABLE",
  * //       },
+ * //       Video: { // VideoFeatures
+ * //         MaxResolution: "None" || "HD" || "FHD",
+ * //       },
+ * //       Content: { // ContentFeatures
+ * //         MaxResolution: "None" || "FHD" || "UHD",
+ * //       },
+ * //       Attendee: { // AttendeeFeatures
+ * //         MaxCount: Number("int"),
+ * //       },
  * //     },
  * //     PrimaryMeetingId: "STRING_VALUE",
  * //     TenantIds: [ // TenantIdList

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

@@ -57,6 +57,15 @@ export interface GetMeetingCommandOutput extends GetMeetingResponse, __MetadataB
  * //       Audio: { // AudioFeatures
  * //         EchoReduction: "AVAILABLE" || "UNAVAILABLE",
  * //       },
+ * //       Video: { // VideoFeatures
+ * //         MaxResolution: "None" || "HD" || "FHD",
+ * //       },
+ * //       Content: { // ContentFeatures
+ * //         MaxResolution: "None" || "FHD" || "UHD",
+ * //       },
+ * //       Attendee: { // AttendeeFeatures
+ * //         MaxCount: Number("int"),
+ * //       },
  * //     },
  * //     PrimaryMeetingId: "STRING_VALUE",
  * //     TenantIds: [ // TenantIdList

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

@@ -30,10 +30,14 @@ export interface StartMeetingTranscriptionCommandOutput extends __MetadataBearer
  *             For more information on each parameter and which combinations are valid, refer to the
  *             <a href="https://docs.aws.amazon.com/transcribe/latest/APIReference/API_streaming_StartStreamTranscription.html">StartStreamTranscription</a> API in the
  *             <i>Amazon Transcribe Developer Guide</i>.</p>
- *          <important>
- *             <p>Amazon Chime SDK live transcription is powered by Amazon Transcribe. Use of Amazon Transcribe is subject to the
- *             <a href="https://aws.amazon.com/service-terms/">AWS Service Terms</a>, including the terms specific to the AWS Machine Learning and Artificial Intelligence Services.</p>
- *          </important>
+ *          <note>
+ *             <p>By default, Amazon Transcribe may use and store audio content processed by the service to develop and improve Amazon Web Services AI/ML services as
+ *             further described in section 50 of the <a href="https://aws.amazon.com/service-terms/">Amazon Web Services Service Terms</a>. Using Amazon Transcribe
+ *             may be subject to federal and state laws or regulations regarding the recording or interception of electronic communications. It is your and your end users’
+ *             responsibility to comply with all applicable laws regarding the recording, including properly notifying all participants in a recorded session or communication
+ *             that the session or communication is being recorded, and obtaining all necessary consents. You can opt out from Amazon Web Services using audio content to develop and
+ *             improve AWS AI/ML services by configuring an AI services opt out policy using Amazon Web Services Organizations.</p>
+ *          </note>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -27,8 +27,12 @@ export interface StopMeetingTranscriptionCommandOutput extends __MetadataBearer
  *             Using Amazon Chime SDK live transcription
  *         </a> in the <i>Amazon Chime SDK Developer Guide</i>.</p>
  *          <important>
- *             <p>Amazon Chime SDK live transcription is powered by Amazon Transcribe. Use of Amazon Transcribe is subject to the
- *             <a href="https://aws.amazon.com/service-terms/">AWS Service Terms</a>, including the terms specific to the AWS Machine Learning and Artificial Intelligence Services.</p>
+ *             <p>By default, Amazon Transcribe may use and store audio content processed by the service to develop and improve Amazon Web Services AI/ML services as
+ *                     further described in section 50 of the <a href="https://aws.amazon.com/service-terms/">Amazon Web Services Service Terms</a>. Using Amazon Transcribe
+ *                     may be subject to federal and state laws or regulations regarding the recording or interception of electronic communications. It is your and your end users’
+ *                     responsibility to comply with all applicable laws regarding the recording, including properly notifying all participants in a recorded session or communication
+ *                     that the session or communication is being recorded, and obtaining all necessary consents. You can opt out from Amazon Web Services using audio content to develop and
+ *                     improve Amazon Web Services AI/ML services by configuring an AI services opt out policy using Amazon Web Services Organizations.</p>
  *          </important>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

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

@@ -31,7 +31,7 @@ export interface UntagResourceCommandOutput extends UntagResourceResponse, __Met
  *                 see the documentation for the service whose resource you want to untag.</p>
  *             </li>
  *             <li>
- *                <p>You can only tag resources that are located in the specified AWS Region for the calling AWS account.</p>
+ *                <p>You can only tag resources that are located in the specified Amazon Web Services Region for the calling Amazon Web Services account.</p>
  *             </li>
  *          </ul>
  *          <p>