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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/protocols/Aws_restJson1.js +377 -752
  2. package/dist-es/protocols/Aws_restJson1.js +378 -753
  3. package/package.json +5 -4
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1,40 +1,33 @@
1
- import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
2
- import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
1
+ import { requestBuilder as rb } from "@smithy/core";
2
+ import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
3
3
  import { v4 as generateIdempotencyToken } from "uuid";
4
4
  import { ChimeSDKMessagingServiceException as __BaseException } from "../models/ChimeSDKMessagingServiceException";
5
5
  import { BadRequestException, ConflictException, ForbiddenException, NotFoundException, ResourceLimitExceededException, ServiceFailureException, ServiceUnavailableException, ThrottledClientException, UnauthorizedClientException, } from "../models/models_0";
6
6
  export const se_AssociateChannelFlowCommand = async (input, context) => {
7
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
7
+ const b = rb(input, context);
8
8
  const headers = map({}, isSerializableHeaderValue, {
9
9
  "content-type": "application/json",
10
- "x-amz-chime-bearer": input.ChimeBearer,
10
+ [_xacb]: input[_CB],
11
11
  });
12
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/channel-flow";
13
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
12
+ b.bp("/channels/{ChannelArn}/channel-flow");
13
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
14
14
  let body;
15
15
  body = JSON.stringify(take(input, {
16
16
  ChannelFlowArn: [],
17
17
  }));
18
- return new __HttpRequest({
19
- protocol,
20
- hostname,
21
- port,
22
- method: "PUT",
23
- headers,
24
- path: resolvedPath,
25
- body,
26
- });
18
+ b.m("PUT").h(headers).b(body);
19
+ return b.build();
27
20
  };
28
21
  export const se_BatchCreateChannelMembershipCommand = async (input, context) => {
29
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
22
+ const b = rb(input, context);
30
23
  const headers = map({}, isSerializableHeaderValue, {
31
24
  "content-type": "application/json",
32
- "x-amz-chime-bearer": input.ChimeBearer,
25
+ [_xacb]: input[_CB],
33
26
  });
34
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/memberships";
35
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
27
+ b.bp("/channels/{ChannelArn}/memberships");
28
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
36
29
  const query = map({
37
- operation: [, "batch-create"],
30
+ [_o]: [, "batch-create"],
38
31
  });
39
32
  let body;
40
33
  body = JSON.stringify(take(input, {
@@ -42,26 +35,18 @@ export const se_BatchCreateChannelMembershipCommand = async (input, context) =>
42
35
  SubChannelId: [],
43
36
  Type: [],
44
37
  }));
45
- return new __HttpRequest({
46
- protocol,
47
- hostname,
48
- port,
49
- method: "POST",
50
- headers,
51
- path: resolvedPath,
52
- query,
53
- body,
54
- });
38
+ b.m("POST").h(headers).q(query).b(body);
39
+ return b.build();
55
40
  };
56
41
  export const se_ChannelFlowCallbackCommand = async (input, context) => {
57
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
42
+ const b = rb(input, context);
58
43
  const headers = {
59
44
  "content-type": "application/json",
60
45
  };
61
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
62
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
46
+ b.bp("/channels/{ChannelArn}");
47
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
63
48
  const query = map({
64
- operation: [, "channel-flow-callback"],
49
+ [_o]: [, "channel-flow-callback"],
65
50
  });
66
51
  let body;
67
52
  body = JSON.stringify(take(input, {
@@ -69,24 +54,16 @@ export const se_ChannelFlowCallbackCommand = async (input, context) => {
69
54
  ChannelMessage: (_) => _json(_),
70
55
  DeleteResource: [],
71
56
  }));
72
- return new __HttpRequest({
73
- protocol,
74
- hostname,
75
- port,
76
- method: "POST",
77
- headers,
78
- path: resolvedPath,
79
- query,
80
- body,
81
- });
57
+ b.m("POST").h(headers).q(query).b(body);
58
+ return b.build();
82
59
  };
83
60
  export const se_CreateChannelCommand = async (input, context) => {
84
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
61
+ const b = rb(input, context);
85
62
  const headers = map({}, isSerializableHeaderValue, {
86
63
  "content-type": "application/json",
87
- "x-amz-chime-bearer": input.ChimeBearer,
64
+ [_xacb]: input[_CB],
88
65
  });
89
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
66
+ b.bp("/channels");
90
67
  let body;
91
68
  body = JSON.stringify(take(input, {
92
69
  AppInstanceArn: [],
@@ -102,44 +79,30 @@ export const se_CreateChannelCommand = async (input, context) => {
102
79
  Privacy: [],
103
80
  Tags: (_) => _json(_),
104
81
  }));
105
- return new __HttpRequest({
106
- protocol,
107
- hostname,
108
- port,
109
- method: "POST",
110
- headers,
111
- path: resolvedPath,
112
- body,
113
- });
82
+ b.m("POST").h(headers).b(body);
83
+ return b.build();
114
84
  };
115
85
  export const se_CreateChannelBanCommand = async (input, context) => {
116
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
86
+ const b = rb(input, context);
117
87
  const headers = map({}, isSerializableHeaderValue, {
118
88
  "content-type": "application/json",
119
- "x-amz-chime-bearer": input.ChimeBearer,
89
+ [_xacb]: input[_CB],
120
90
  });
121
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/bans";
122
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
91
+ b.bp("/channels/{ChannelArn}/bans");
92
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
123
93
  let body;
124
94
  body = JSON.stringify(take(input, {
125
95
  MemberArn: [],
126
96
  }));
127
- return new __HttpRequest({
128
- protocol,
129
- hostname,
130
- port,
131
- method: "POST",
132
- headers,
133
- path: resolvedPath,
134
- body,
135
- });
97
+ b.m("POST").h(headers).b(body);
98
+ return b.build();
136
99
  };
137
100
  export const se_CreateChannelFlowCommand = async (input, context) => {
138
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
101
+ const b = rb(input, context);
139
102
  const headers = {
140
103
  "content-type": "application/json",
141
104
  };
142
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channel-flows";
105
+ b.bp("/channel-flows");
143
106
  let body;
144
107
  body = JSON.stringify(take(input, {
145
108
  AppInstanceArn: [],
@@ -148,860 +111,546 @@ export const se_CreateChannelFlowCommand = async (input, context) => {
148
111
  Processors: (_) => _json(_),
149
112
  Tags: (_) => _json(_),
150
113
  }));
151
- return new __HttpRequest({
152
- protocol,
153
- hostname,
154
- port,
155
- method: "POST",
156
- headers,
157
- path: resolvedPath,
158
- body,
159
- });
114
+ b.m("POST").h(headers).b(body);
115
+ return b.build();
160
116
  };
161
117
  export const se_CreateChannelMembershipCommand = async (input, context) => {
162
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
118
+ const b = rb(input, context);
163
119
  const headers = map({}, isSerializableHeaderValue, {
164
120
  "content-type": "application/json",
165
- "x-amz-chime-bearer": input.ChimeBearer,
121
+ [_xacb]: input[_CB],
166
122
  });
167
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/memberships";
168
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
123
+ b.bp("/channels/{ChannelArn}/memberships");
124
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
169
125
  let body;
170
126
  body = JSON.stringify(take(input, {
171
127
  MemberArn: [],
172
128
  SubChannelId: [],
173
129
  Type: [],
174
130
  }));
175
- return new __HttpRequest({
176
- protocol,
177
- hostname,
178
- port,
179
- method: "POST",
180
- headers,
181
- path: resolvedPath,
182
- body,
183
- });
131
+ b.m("POST").h(headers).b(body);
132
+ return b.build();
184
133
  };
185
134
  export const se_CreateChannelModeratorCommand = async (input, context) => {
186
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
135
+ const b = rb(input, context);
187
136
  const headers = map({}, isSerializableHeaderValue, {
188
137
  "content-type": "application/json",
189
- "x-amz-chime-bearer": input.ChimeBearer,
138
+ [_xacb]: input[_CB],
190
139
  });
191
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/moderators";
192
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
140
+ b.bp("/channels/{ChannelArn}/moderators");
141
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
193
142
  let body;
194
143
  body = JSON.stringify(take(input, {
195
144
  ChannelModeratorArn: [],
196
145
  }));
197
- return new __HttpRequest({
198
- protocol,
199
- hostname,
200
- port,
201
- method: "POST",
202
- headers,
203
- path: resolvedPath,
204
- body,
205
- });
146
+ b.m("POST").h(headers).b(body);
147
+ return b.build();
206
148
  };
207
149
  export const se_DeleteChannelCommand = async (input, context) => {
208
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
150
+ const b = rb(input, context);
209
151
  const headers = map({}, isSerializableHeaderValue, {
210
- "x-amz-chime-bearer": input.ChimeBearer,
152
+ [_xacb]: input[_CB],
211
153
  });
212
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
213
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
154
+ b.bp("/channels/{ChannelArn}");
155
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
214
156
  let body;
215
- return new __HttpRequest({
216
- protocol,
217
- hostname,
218
- port,
219
- method: "DELETE",
220
- headers,
221
- path: resolvedPath,
222
- body,
223
- });
157
+ b.m("DELETE").h(headers).b(body);
158
+ return b.build();
224
159
  };
225
160
  export const se_DeleteChannelBanCommand = async (input, context) => {
226
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
161
+ const b = rb(input, context);
227
162
  const headers = map({}, isSerializableHeaderValue, {
228
- "x-amz-chime-bearer": input.ChimeBearer,
163
+ [_xacb]: input[_CB],
229
164
  });
230
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/bans/{MemberArn}";
231
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
232
- resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
165
+ b.bp("/channels/{ChannelArn}/bans/{MemberArn}");
166
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
167
+ b.p("MemberArn", () => input.MemberArn, "{MemberArn}", false);
233
168
  let body;
234
- return new __HttpRequest({
235
- protocol,
236
- hostname,
237
- port,
238
- method: "DELETE",
239
- headers,
240
- path: resolvedPath,
241
- body,
242
- });
169
+ b.m("DELETE").h(headers).b(body);
170
+ return b.build();
243
171
  };
244
172
  export const se_DeleteChannelFlowCommand = async (input, context) => {
245
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
173
+ const b = rb(input, context);
246
174
  const headers = {};
247
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channel-flows/{ChannelFlowArn}";
248
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
175
+ b.bp("/channel-flows/{ChannelFlowArn}");
176
+ b.p("ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
249
177
  let body;
250
- return new __HttpRequest({
251
- protocol,
252
- hostname,
253
- port,
254
- method: "DELETE",
255
- headers,
256
- path: resolvedPath,
257
- body,
258
- });
178
+ b.m("DELETE").h(headers).b(body);
179
+ return b.build();
259
180
  };
260
181
  export const se_DeleteChannelMembershipCommand = async (input, context) => {
261
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
182
+ const b = rb(input, context);
262
183
  const headers = map({}, isSerializableHeaderValue, {
263
- "x-amz-chime-bearer": input.ChimeBearer,
184
+ [_xacb]: input[_CB],
264
185
  });
265
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
266
- "/channels/{ChannelArn}/memberships/{MemberArn}";
267
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
268
- resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
186
+ b.bp("/channels/{ChannelArn}/memberships/{MemberArn}");
187
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
188
+ b.p("MemberArn", () => input.MemberArn, "{MemberArn}", false);
269
189
  const query = map({
270
- "sub-channel-id": [, input.SubChannelId],
190
+ [_sci]: [, input[_SCI]],
271
191
  });
272
192
  let body;
273
- return new __HttpRequest({
274
- protocol,
275
- hostname,
276
- port,
277
- method: "DELETE",
278
- headers,
279
- path: resolvedPath,
280
- query,
281
- body,
282
- });
193
+ b.m("DELETE").h(headers).q(query).b(body);
194
+ return b.build();
283
195
  };
284
196
  export const se_DeleteChannelMessageCommand = async (input, context) => {
285
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
197
+ const b = rb(input, context);
286
198
  const headers = map({}, isSerializableHeaderValue, {
287
- "x-amz-chime-bearer": input.ChimeBearer,
199
+ [_xacb]: input[_CB],
288
200
  });
289
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
290
- "/channels/{ChannelArn}/messages/{MessageId}";
291
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
292
- resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
201
+ b.bp("/channels/{ChannelArn}/messages/{MessageId}");
202
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
203
+ b.p("MessageId", () => input.MessageId, "{MessageId}", false);
293
204
  const query = map({
294
- "sub-channel-id": [, input.SubChannelId],
205
+ [_sci]: [, input[_SCI]],
295
206
  });
296
207
  let body;
297
- return new __HttpRequest({
298
- protocol,
299
- hostname,
300
- port,
301
- method: "DELETE",
302
- headers,
303
- path: resolvedPath,
304
- query,
305
- body,
306
- });
208
+ b.m("DELETE").h(headers).q(query).b(body);
209
+ return b.build();
307
210
  };
308
211
  export const se_DeleteChannelModeratorCommand = async (input, context) => {
309
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
212
+ const b = rb(input, context);
310
213
  const headers = map({}, isSerializableHeaderValue, {
311
- "x-amz-chime-bearer": input.ChimeBearer,
214
+ [_xacb]: input[_CB],
312
215
  });
313
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
314
- "/channels/{ChannelArn}/moderators/{ChannelModeratorArn}";
315
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
316
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelModeratorArn", () => input.ChannelModeratorArn, "{ChannelModeratorArn}", false);
216
+ b.bp("/channels/{ChannelArn}/moderators/{ChannelModeratorArn}");
217
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
218
+ b.p("ChannelModeratorArn", () => input.ChannelModeratorArn, "{ChannelModeratorArn}", false);
317
219
  let body;
318
- return new __HttpRequest({
319
- protocol,
320
- hostname,
321
- port,
322
- method: "DELETE",
323
- headers,
324
- path: resolvedPath,
325
- body,
326
- });
220
+ b.m("DELETE").h(headers).b(body);
221
+ return b.build();
327
222
  };
328
223
  export const se_DeleteMessagingStreamingConfigurationsCommand = async (input, context) => {
329
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
224
+ const b = rb(input, context);
330
225
  const headers = {};
331
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
332
- "/app-instances/{AppInstanceArn}/streaming-configurations";
333
- resolvedPath = __resolvedPath(resolvedPath, input, "AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
226
+ b.bp("/app-instances/{AppInstanceArn}/streaming-configurations");
227
+ b.p("AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
334
228
  let body;
335
- return new __HttpRequest({
336
- protocol,
337
- hostname,
338
- port,
339
- method: "DELETE",
340
- headers,
341
- path: resolvedPath,
342
- body,
343
- });
229
+ b.m("DELETE").h(headers).b(body);
230
+ return b.build();
344
231
  };
345
232
  export const se_DescribeChannelCommand = async (input, context) => {
346
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
233
+ const b = rb(input, context);
347
234
  const headers = map({}, isSerializableHeaderValue, {
348
- "x-amz-chime-bearer": input.ChimeBearer,
235
+ [_xacb]: input[_CB],
349
236
  });
350
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
351
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
237
+ b.bp("/channels/{ChannelArn}");
238
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
352
239
  let body;
353
- return new __HttpRequest({
354
- protocol,
355
- hostname,
356
- port,
357
- method: "GET",
358
- headers,
359
- path: resolvedPath,
360
- body,
361
- });
240
+ b.m("GET").h(headers).b(body);
241
+ return b.build();
362
242
  };
363
243
  export const se_DescribeChannelBanCommand = async (input, context) => {
364
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
244
+ const b = rb(input, context);
365
245
  const headers = map({}, isSerializableHeaderValue, {
366
- "x-amz-chime-bearer": input.ChimeBearer,
246
+ [_xacb]: input[_CB],
367
247
  });
368
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/bans/{MemberArn}";
369
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
370
- resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
248
+ b.bp("/channels/{ChannelArn}/bans/{MemberArn}");
249
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
250
+ b.p("MemberArn", () => input.MemberArn, "{MemberArn}", false);
371
251
  let body;
372
- return new __HttpRequest({
373
- protocol,
374
- hostname,
375
- port,
376
- method: "GET",
377
- headers,
378
- path: resolvedPath,
379
- body,
380
- });
252
+ b.m("GET").h(headers).b(body);
253
+ return b.build();
381
254
  };
382
255
  export const se_DescribeChannelFlowCommand = async (input, context) => {
383
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
256
+ const b = rb(input, context);
384
257
  const headers = {};
385
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channel-flows/{ChannelFlowArn}";
386
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
258
+ b.bp("/channel-flows/{ChannelFlowArn}");
259
+ b.p("ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
387
260
  let body;
388
- return new __HttpRequest({
389
- protocol,
390
- hostname,
391
- port,
392
- method: "GET",
393
- headers,
394
- path: resolvedPath,
395
- body,
396
- });
261
+ b.m("GET").h(headers).b(body);
262
+ return b.build();
397
263
  };
398
264
  export const se_DescribeChannelMembershipCommand = async (input, context) => {
399
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
265
+ const b = rb(input, context);
400
266
  const headers = map({}, isSerializableHeaderValue, {
401
- "x-amz-chime-bearer": input.ChimeBearer,
267
+ [_xacb]: input[_CB],
402
268
  });
403
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
404
- "/channels/{ChannelArn}/memberships/{MemberArn}";
405
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
406
- resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
269
+ b.bp("/channels/{ChannelArn}/memberships/{MemberArn}");
270
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
271
+ b.p("MemberArn", () => input.MemberArn, "{MemberArn}", false);
407
272
  const query = map({
408
- "sub-channel-id": [, input.SubChannelId],
273
+ [_sci]: [, input[_SCI]],
409
274
  });
410
275
  let body;
411
- return new __HttpRequest({
412
- protocol,
413
- hostname,
414
- port,
415
- method: "GET",
416
- headers,
417
- path: resolvedPath,
418
- query,
419
- body,
420
- });
276
+ b.m("GET").h(headers).q(query).b(body);
277
+ return b.build();
421
278
  };
422
279
  export const se_DescribeChannelMembershipForAppInstanceUserCommand = async (input, context) => {
423
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
280
+ const b = rb(input, context);
424
281
  const headers = map({}, isSerializableHeaderValue, {
425
- "x-amz-chime-bearer": input.ChimeBearer,
282
+ [_xacb]: input[_CB],
426
283
  });
427
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
428
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
284
+ b.bp("/channels/{ChannelArn}");
285
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
429
286
  const query = map({
430
- scope: [, "app-instance-user-membership"],
431
- "app-instance-user-arn": [, __expectNonNull(input.AppInstanceUserArn, `AppInstanceUserArn`)],
287
+ [_s]: [, "app-instance-user-membership"],
288
+ [_aiua]: [, __expectNonNull(input[_AIUA], `AppInstanceUserArn`)],
432
289
  });
433
290
  let body;
434
- return new __HttpRequest({
435
- protocol,
436
- hostname,
437
- port,
438
- method: "GET",
439
- headers,
440
- path: resolvedPath,
441
- query,
442
- body,
443
- });
291
+ b.m("GET").h(headers).q(query).b(body);
292
+ return b.build();
444
293
  };
445
294
  export const se_DescribeChannelModeratedByAppInstanceUserCommand = async (input, context) => {
446
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
295
+ const b = rb(input, context);
447
296
  const headers = map({}, isSerializableHeaderValue, {
448
- "x-amz-chime-bearer": input.ChimeBearer,
297
+ [_xacb]: input[_CB],
449
298
  });
450
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
451
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
299
+ b.bp("/channels/{ChannelArn}");
300
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
452
301
  const query = map({
453
- scope: [, "app-instance-user-moderated-channel"],
454
- "app-instance-user-arn": [, __expectNonNull(input.AppInstanceUserArn, `AppInstanceUserArn`)],
302
+ [_s]: [, "app-instance-user-moderated-channel"],
303
+ [_aiua]: [, __expectNonNull(input[_AIUA], `AppInstanceUserArn`)],
455
304
  });
456
305
  let body;
457
- return new __HttpRequest({
458
- protocol,
459
- hostname,
460
- port,
461
- method: "GET",
462
- headers,
463
- path: resolvedPath,
464
- query,
465
- body,
466
- });
306
+ b.m("GET").h(headers).q(query).b(body);
307
+ return b.build();
467
308
  };
468
309
  export const se_DescribeChannelModeratorCommand = async (input, context) => {
469
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
310
+ const b = rb(input, context);
470
311
  const headers = map({}, isSerializableHeaderValue, {
471
- "x-amz-chime-bearer": input.ChimeBearer,
312
+ [_xacb]: input[_CB],
472
313
  });
473
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
474
- "/channels/{ChannelArn}/moderators/{ChannelModeratorArn}";
475
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
476
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelModeratorArn", () => input.ChannelModeratorArn, "{ChannelModeratorArn}", false);
314
+ b.bp("/channels/{ChannelArn}/moderators/{ChannelModeratorArn}");
315
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
316
+ b.p("ChannelModeratorArn", () => input.ChannelModeratorArn, "{ChannelModeratorArn}", false);
477
317
  let body;
478
- return new __HttpRequest({
479
- protocol,
480
- hostname,
481
- port,
482
- method: "GET",
483
- headers,
484
- path: resolvedPath,
485
- body,
486
- });
318
+ b.m("GET").h(headers).b(body);
319
+ return b.build();
487
320
  };
488
321
  export const se_DisassociateChannelFlowCommand = async (input, context) => {
489
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
322
+ const b = rb(input, context);
490
323
  const headers = map({}, isSerializableHeaderValue, {
491
- "x-amz-chime-bearer": input.ChimeBearer,
324
+ [_xacb]: input[_CB],
492
325
  });
493
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
494
- "/channels/{ChannelArn}/channel-flow/{ChannelFlowArn}";
495
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
496
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
326
+ b.bp("/channels/{ChannelArn}/channel-flow/{ChannelFlowArn}");
327
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
328
+ b.p("ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
497
329
  let body;
498
- return new __HttpRequest({
499
- protocol,
500
- hostname,
501
- port,
502
- method: "DELETE",
503
- headers,
504
- path: resolvedPath,
505
- body,
506
- });
330
+ b.m("DELETE").h(headers).b(body);
331
+ return b.build();
507
332
  };
508
333
  export const se_GetChannelMembershipPreferencesCommand = async (input, context) => {
509
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
334
+ const b = rb(input, context);
510
335
  const headers = map({}, isSerializableHeaderValue, {
511
- "x-amz-chime-bearer": input.ChimeBearer,
336
+ [_xacb]: input[_CB],
512
337
  });
513
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
514
- "/channels/{ChannelArn}/memberships/{MemberArn}/preferences";
515
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
516
- resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
338
+ b.bp("/channels/{ChannelArn}/memberships/{MemberArn}/preferences");
339
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
340
+ b.p("MemberArn", () => input.MemberArn, "{MemberArn}", false);
517
341
  let body;
518
- return new __HttpRequest({
519
- protocol,
520
- hostname,
521
- port,
522
- method: "GET",
523
- headers,
524
- path: resolvedPath,
525
- body,
526
- });
342
+ b.m("GET").h(headers).b(body);
343
+ return b.build();
527
344
  };
528
345
  export const se_GetChannelMessageCommand = async (input, context) => {
529
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
346
+ const b = rb(input, context);
530
347
  const headers = map({}, isSerializableHeaderValue, {
531
- "x-amz-chime-bearer": input.ChimeBearer,
348
+ [_xacb]: input[_CB],
532
349
  });
533
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
534
- "/channels/{ChannelArn}/messages/{MessageId}";
535
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
536
- resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
350
+ b.bp("/channels/{ChannelArn}/messages/{MessageId}");
351
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
352
+ b.p("MessageId", () => input.MessageId, "{MessageId}", false);
537
353
  const query = map({
538
- "sub-channel-id": [, input.SubChannelId],
354
+ [_sci]: [, input[_SCI]],
539
355
  });
540
356
  let body;
541
- return new __HttpRequest({
542
- protocol,
543
- hostname,
544
- port,
545
- method: "GET",
546
- headers,
547
- path: resolvedPath,
548
- query,
549
- body,
550
- });
357
+ b.m("GET").h(headers).q(query).b(body);
358
+ return b.build();
551
359
  };
552
360
  export const se_GetChannelMessageStatusCommand = async (input, context) => {
553
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
361
+ const b = rb(input, context);
554
362
  const headers = map({}, isSerializableHeaderValue, {
555
- "x-amz-chime-bearer": input.ChimeBearer,
363
+ [_xacb]: input[_CB],
556
364
  });
557
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
558
- "/channels/{ChannelArn}/messages/{MessageId}";
559
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
560
- resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
365
+ b.bp("/channels/{ChannelArn}/messages/{MessageId}");
366
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
367
+ b.p("MessageId", () => input.MessageId, "{MessageId}", false);
561
368
  const query = map({
562
- scope: [, "message-status"],
563
- "sub-channel-id": [, input.SubChannelId],
369
+ [_s]: [, "message-status"],
370
+ [_sci]: [, input[_SCI]],
564
371
  });
565
372
  let body;
566
- return new __HttpRequest({
567
- protocol,
568
- hostname,
569
- port,
570
- method: "GET",
571
- headers,
572
- path: resolvedPath,
573
- query,
574
- body,
575
- });
373
+ b.m("GET").h(headers).q(query).b(body);
374
+ return b.build();
576
375
  };
577
376
  export const se_GetMessagingSessionEndpointCommand = async (input, context) => {
578
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
377
+ const b = rb(input, context);
579
378
  const headers = {
580
379
  "content-type": "application/json",
581
380
  };
582
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/endpoints/messaging-session";
381
+ b.bp("/endpoints/messaging-session");
583
382
  let body;
584
383
  body = "";
585
- return new __HttpRequest({
586
- protocol,
587
- hostname,
588
- port,
589
- method: "GET",
590
- headers,
591
- path: resolvedPath,
592
- body,
593
- });
384
+ b.m("GET").h(headers).b(body);
385
+ return b.build();
594
386
  };
595
387
  export const se_GetMessagingStreamingConfigurationsCommand = async (input, context) => {
596
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
388
+ const b = rb(input, context);
597
389
  const headers = {};
598
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
599
- "/app-instances/{AppInstanceArn}/streaming-configurations";
600
- resolvedPath = __resolvedPath(resolvedPath, input, "AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
390
+ b.bp("/app-instances/{AppInstanceArn}/streaming-configurations");
391
+ b.p("AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
601
392
  let body;
602
- return new __HttpRequest({
603
- protocol,
604
- hostname,
605
- port,
606
- method: "GET",
607
- headers,
608
- path: resolvedPath,
609
- body,
610
- });
393
+ b.m("GET").h(headers).b(body);
394
+ return b.build();
611
395
  };
612
396
  export const se_ListChannelBansCommand = async (input, context) => {
613
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
397
+ const b = rb(input, context);
614
398
  const headers = map({}, isSerializableHeaderValue, {
615
- "x-amz-chime-bearer": input.ChimeBearer,
399
+ [_xacb]: input[_CB],
616
400
  });
617
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/bans";
618
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
401
+ b.bp("/channels/{ChannelArn}/bans");
402
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
619
403
  const query = map({
620
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
621
- "next-token": [, input.NextToken],
404
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
405
+ [_nt]: [, input[_NT]],
622
406
  });
623
407
  let body;
624
- return new __HttpRequest({
625
- protocol,
626
- hostname,
627
- port,
628
- method: "GET",
629
- headers,
630
- path: resolvedPath,
631
- query,
632
- body,
633
- });
408
+ b.m("GET").h(headers).q(query).b(body);
409
+ return b.build();
634
410
  };
635
411
  export const se_ListChannelFlowsCommand = async (input, context) => {
636
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
412
+ const b = rb(input, context);
637
413
  const headers = {};
638
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channel-flows";
414
+ b.bp("/channel-flows");
639
415
  const query = map({
640
- "app-instance-arn": [, __expectNonNull(input.AppInstanceArn, `AppInstanceArn`)],
641
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
642
- "next-token": [, input.NextToken],
416
+ [_aia]: [, __expectNonNull(input[_AIA], `AppInstanceArn`)],
417
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
418
+ [_nt]: [, input[_NT]],
643
419
  });
644
420
  let body;
645
- return new __HttpRequest({
646
- protocol,
647
- hostname,
648
- port,
649
- method: "GET",
650
- headers,
651
- path: resolvedPath,
652
- query,
653
- body,
654
- });
421
+ b.m("GET").h(headers).q(query).b(body);
422
+ return b.build();
655
423
  };
656
424
  export const se_ListChannelMembershipsCommand = async (input, context) => {
657
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
425
+ const b = rb(input, context);
658
426
  const headers = map({}, isSerializableHeaderValue, {
659
- "x-amz-chime-bearer": input.ChimeBearer,
427
+ [_xacb]: input[_CB],
660
428
  });
661
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/memberships";
662
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
429
+ b.bp("/channels/{ChannelArn}/memberships");
430
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
663
431
  const query = map({
664
- type: [, input.Type],
665
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
666
- "next-token": [, input.NextToken],
667
- "sub-channel-id": [, input.SubChannelId],
432
+ [_t]: [, input[_T]],
433
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
434
+ [_nt]: [, input[_NT]],
435
+ [_sci]: [, input[_SCI]],
668
436
  });
669
437
  let body;
670
- return new __HttpRequest({
671
- protocol,
672
- hostname,
673
- port,
674
- method: "GET",
675
- headers,
676
- path: resolvedPath,
677
- query,
678
- body,
679
- });
438
+ b.m("GET").h(headers).q(query).b(body);
439
+ return b.build();
680
440
  };
681
441
  export const se_ListChannelMembershipsForAppInstanceUserCommand = async (input, context) => {
682
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
442
+ const b = rb(input, context);
683
443
  const headers = map({}, isSerializableHeaderValue, {
684
- "x-amz-chime-bearer": input.ChimeBearer,
444
+ [_xacb]: input[_CB],
685
445
  });
686
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
446
+ b.bp("/channels");
687
447
  const query = map({
688
- scope: [, "app-instance-user-memberships"],
689
- "app-instance-user-arn": [, input.AppInstanceUserArn],
690
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
691
- "next-token": [, input.NextToken],
448
+ [_s]: [, "app-instance-user-memberships"],
449
+ [_aiua]: [, input[_AIUA]],
450
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
451
+ [_nt]: [, input[_NT]],
692
452
  });
693
453
  let body;
694
- return new __HttpRequest({
695
- protocol,
696
- hostname,
697
- port,
698
- method: "GET",
699
- headers,
700
- path: resolvedPath,
701
- query,
702
- body,
703
- });
454
+ b.m("GET").h(headers).q(query).b(body);
455
+ return b.build();
704
456
  };
705
457
  export const se_ListChannelMessagesCommand = async (input, context) => {
706
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
458
+ const b = rb(input, context);
707
459
  const headers = map({}, isSerializableHeaderValue, {
708
- "x-amz-chime-bearer": input.ChimeBearer,
460
+ [_xacb]: input[_CB],
709
461
  });
710
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/messages";
711
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
462
+ b.bp("/channels/{ChannelArn}/messages");
463
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
712
464
  const query = map({
713
- "sort-order": [, input.SortOrder],
714
- "not-before": [
715
- () => input.NotBefore !== void 0,
716
- () => (input.NotBefore.toISOString().split(".")[0] + "Z").toString(),
717
- ],
718
- "not-after": [
719
- () => input.NotAfter !== void 0,
720
- () => (input.NotAfter.toISOString().split(".")[0] + "Z").toString(),
721
- ],
722
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
723
- "next-token": [, input.NextToken],
724
- "sub-channel-id": [, input.SubChannelId],
465
+ [_so]: [, input[_SO]],
466
+ [_nb]: [() => input.NotBefore !== void 0, () => (input[_NB].toISOString().split(".")[0] + "Z").toString()],
467
+ [_na]: [() => input.NotAfter !== void 0, () => (input[_NA].toISOString().split(".")[0] + "Z").toString()],
468
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
469
+ [_nt]: [, input[_NT]],
470
+ [_sci]: [, input[_SCI]],
725
471
  });
726
472
  let body;
727
- return new __HttpRequest({
728
- protocol,
729
- hostname,
730
- port,
731
- method: "GET",
732
- headers,
733
- path: resolvedPath,
734
- query,
735
- body,
736
- });
473
+ b.m("GET").h(headers).q(query).b(body);
474
+ return b.build();
737
475
  };
738
476
  export const se_ListChannelModeratorsCommand = async (input, context) => {
739
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
477
+ const b = rb(input, context);
740
478
  const headers = map({}, isSerializableHeaderValue, {
741
- "x-amz-chime-bearer": input.ChimeBearer,
479
+ [_xacb]: input[_CB],
742
480
  });
743
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/moderators";
744
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
481
+ b.bp("/channels/{ChannelArn}/moderators");
482
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
745
483
  const query = map({
746
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
747
- "next-token": [, input.NextToken],
484
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
485
+ [_nt]: [, input[_NT]],
748
486
  });
749
487
  let body;
750
- return new __HttpRequest({
751
- protocol,
752
- hostname,
753
- port,
754
- method: "GET",
755
- headers,
756
- path: resolvedPath,
757
- query,
758
- body,
759
- });
488
+ b.m("GET").h(headers).q(query).b(body);
489
+ return b.build();
760
490
  };
761
491
  export const se_ListChannelsCommand = async (input, context) => {
762
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
492
+ const b = rb(input, context);
763
493
  const headers = map({}, isSerializableHeaderValue, {
764
- "x-amz-chime-bearer": input.ChimeBearer,
494
+ [_xacb]: input[_CB],
765
495
  });
766
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
496
+ b.bp("/channels");
767
497
  const query = map({
768
- "app-instance-arn": [, __expectNonNull(input.AppInstanceArn, `AppInstanceArn`)],
769
- privacy: [, input.Privacy],
770
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
771
- "next-token": [, input.NextToken],
498
+ [_aia]: [, __expectNonNull(input[_AIA], `AppInstanceArn`)],
499
+ [_p]: [, input[_P]],
500
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
501
+ [_nt]: [, input[_NT]],
772
502
  });
773
503
  let body;
774
- return new __HttpRequest({
775
- protocol,
776
- hostname,
777
- port,
778
- method: "GET",
779
- headers,
780
- path: resolvedPath,
781
- query,
782
- body,
783
- });
504
+ b.m("GET").h(headers).q(query).b(body);
505
+ return b.build();
784
506
  };
785
507
  export const se_ListChannelsAssociatedWithChannelFlowCommand = async (input, context) => {
786
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
508
+ const b = rb(input, context);
787
509
  const headers = {};
788
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
510
+ b.bp("/channels");
789
511
  const query = map({
790
- scope: [, "channel-flow-associations"],
791
- "channel-flow-arn": [, __expectNonNull(input.ChannelFlowArn, `ChannelFlowArn`)],
792
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
793
- "next-token": [, input.NextToken],
512
+ [_s]: [, "channel-flow-associations"],
513
+ [_cfa]: [, __expectNonNull(input[_CFA], `ChannelFlowArn`)],
514
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
515
+ [_nt]: [, input[_NT]],
794
516
  });
795
517
  let body;
796
- return new __HttpRequest({
797
- protocol,
798
- hostname,
799
- port,
800
- method: "GET",
801
- headers,
802
- path: resolvedPath,
803
- query,
804
- body,
805
- });
518
+ b.m("GET").h(headers).q(query).b(body);
519
+ return b.build();
806
520
  };
807
521
  export const se_ListChannelsModeratedByAppInstanceUserCommand = async (input, context) => {
808
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
522
+ const b = rb(input, context);
809
523
  const headers = map({}, isSerializableHeaderValue, {
810
- "x-amz-chime-bearer": input.ChimeBearer,
524
+ [_xacb]: input[_CB],
811
525
  });
812
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
526
+ b.bp("/channels");
813
527
  const query = map({
814
- scope: [, "app-instance-user-moderated-channels"],
815
- "app-instance-user-arn": [, input.AppInstanceUserArn],
816
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
817
- "next-token": [, input.NextToken],
528
+ [_s]: [, "app-instance-user-moderated-channels"],
529
+ [_aiua]: [, input[_AIUA]],
530
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
531
+ [_nt]: [, input[_NT]],
818
532
  });
819
533
  let body;
820
- return new __HttpRequest({
821
- protocol,
822
- hostname,
823
- port,
824
- method: "GET",
825
- headers,
826
- path: resolvedPath,
827
- query,
828
- body,
829
- });
534
+ b.m("GET").h(headers).q(query).b(body);
535
+ return b.build();
830
536
  };
831
537
  export const se_ListSubChannelsCommand = async (input, context) => {
832
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
538
+ const b = rb(input, context);
833
539
  const headers = map({}, isSerializableHeaderValue, {
834
- "x-amz-chime-bearer": input.ChimeBearer,
540
+ [_xacb]: input[_CB],
835
541
  });
836
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/subchannels";
837
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
542
+ b.bp("/channels/{ChannelArn}/subchannels");
543
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
838
544
  const query = map({
839
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
840
- "next-token": [, input.NextToken],
545
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
546
+ [_nt]: [, input[_NT]],
841
547
  });
842
548
  let body;
843
- return new __HttpRequest({
844
- protocol,
845
- hostname,
846
- port,
847
- method: "GET",
848
- headers,
849
- path: resolvedPath,
850
- query,
851
- body,
852
- });
549
+ b.m("GET").h(headers).q(query).b(body);
550
+ return b.build();
853
551
  };
854
552
  export const se_ListTagsForResourceCommand = async (input, context) => {
855
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
553
+ const b = rb(input, context);
856
554
  const headers = {};
857
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
555
+ b.bp("/tags");
858
556
  const query = map({
859
- arn: [, __expectNonNull(input.ResourceARN, `ResourceARN`)],
557
+ [_a]: [, __expectNonNull(input[_RARN], `ResourceARN`)],
860
558
  });
861
559
  let body;
862
- return new __HttpRequest({
863
- protocol,
864
- hostname,
865
- port,
866
- method: "GET",
867
- headers,
868
- path: resolvedPath,
869
- query,
870
- body,
871
- });
560
+ b.m("GET").h(headers).q(query).b(body);
561
+ return b.build();
872
562
  };
873
563
  export const se_PutChannelExpirationSettingsCommand = async (input, context) => {
874
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
564
+ const b = rb(input, context);
875
565
  const headers = map({}, isSerializableHeaderValue, {
876
566
  "content-type": "application/json",
877
- "x-amz-chime-bearer": input.ChimeBearer,
567
+ [_xacb]: input[_CB],
878
568
  });
879
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
880
- "/channels/{ChannelArn}/expiration-settings";
881
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
569
+ b.bp("/channels/{ChannelArn}/expiration-settings");
570
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
882
571
  let body;
883
572
  body = JSON.stringify(take(input, {
884
573
  ExpirationSettings: (_) => _json(_),
885
574
  }));
886
- return new __HttpRequest({
887
- protocol,
888
- hostname,
889
- port,
890
- method: "PUT",
891
- headers,
892
- path: resolvedPath,
893
- body,
894
- });
575
+ b.m("PUT").h(headers).b(body);
576
+ return b.build();
895
577
  };
896
578
  export const se_PutChannelMembershipPreferencesCommand = async (input, context) => {
897
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
579
+ const b = rb(input, context);
898
580
  const headers = map({}, isSerializableHeaderValue, {
899
581
  "content-type": "application/json",
900
- "x-amz-chime-bearer": input.ChimeBearer,
582
+ [_xacb]: input[_CB],
901
583
  });
902
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
903
- "/channels/{ChannelArn}/memberships/{MemberArn}/preferences";
904
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
905
- resolvedPath = __resolvedPath(resolvedPath, input, "MemberArn", () => input.MemberArn, "{MemberArn}", false);
584
+ b.bp("/channels/{ChannelArn}/memberships/{MemberArn}/preferences");
585
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
586
+ b.p("MemberArn", () => input.MemberArn, "{MemberArn}", false);
906
587
  let body;
907
588
  body = JSON.stringify(take(input, {
908
589
  Preferences: (_) => _json(_),
909
590
  }));
910
- return new __HttpRequest({
911
- protocol,
912
- hostname,
913
- port,
914
- method: "PUT",
915
- headers,
916
- path: resolvedPath,
917
- body,
918
- });
591
+ b.m("PUT").h(headers).b(body);
592
+ return b.build();
919
593
  };
920
594
  export const se_PutMessagingStreamingConfigurationsCommand = async (input, context) => {
921
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
595
+ const b = rb(input, context);
922
596
  const headers = {
923
597
  "content-type": "application/json",
924
598
  };
925
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
926
- "/app-instances/{AppInstanceArn}/streaming-configurations";
927
- resolvedPath = __resolvedPath(resolvedPath, input, "AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
599
+ b.bp("/app-instances/{AppInstanceArn}/streaming-configurations");
600
+ b.p("AppInstanceArn", () => input.AppInstanceArn, "{AppInstanceArn}", false);
928
601
  let body;
929
602
  body = JSON.stringify(take(input, {
930
603
  StreamingConfigurations: (_) => _json(_),
931
604
  }));
932
- return new __HttpRequest({
933
- protocol,
934
- hostname,
935
- port,
936
- method: "PUT",
937
- headers,
938
- path: resolvedPath,
939
- body,
940
- });
605
+ b.m("PUT").h(headers).b(body);
606
+ return b.build();
941
607
  };
942
608
  export const se_RedactChannelMessageCommand = async (input, context) => {
943
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
609
+ const b = rb(input, context);
944
610
  const headers = map({}, isSerializableHeaderValue, {
945
611
  "content-type": "application/json",
946
- "x-amz-chime-bearer": input.ChimeBearer,
612
+ [_xacb]: input[_CB],
947
613
  });
948
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
949
- "/channels/{ChannelArn}/messages/{MessageId}";
950
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
951
- resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
614
+ b.bp("/channels/{ChannelArn}/messages/{MessageId}");
615
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
616
+ b.p("MessageId", () => input.MessageId, "{MessageId}", false);
952
617
  const query = map({
953
- operation: [, "redact"],
618
+ [_o]: [, "redact"],
954
619
  });
955
620
  let body;
956
621
  body = JSON.stringify(take(input, {
957
622
  SubChannelId: [],
958
623
  }));
959
- return new __HttpRequest({
960
- protocol,
961
- hostname,
962
- port,
963
- method: "POST",
964
- headers,
965
- path: resolvedPath,
966
- query,
967
- body,
968
- });
624
+ b.m("POST").h(headers).q(query).b(body);
625
+ return b.build();
969
626
  };
970
627
  export const se_SearchChannelsCommand = async (input, context) => {
971
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
628
+ const b = rb(input, context);
972
629
  const headers = map({}, isSerializableHeaderValue, {
973
630
  "content-type": "application/json",
974
- "x-amz-chime-bearer": input.ChimeBearer,
631
+ [_xacb]: input[_CB],
975
632
  });
976
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels";
633
+ b.bp("/channels");
977
634
  const query = map({
978
- operation: [, "search"],
979
- "max-results": [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
980
- "next-token": [, input.NextToken],
635
+ [_o]: [, "search"],
636
+ [_mr]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
637
+ [_nt]: [, input[_NT]],
981
638
  });
982
639
  let body;
983
640
  body = JSON.stringify(take(input, {
984
641
  Fields: (_) => _json(_),
985
642
  }));
986
- return new __HttpRequest({
987
- protocol,
988
- hostname,
989
- port,
990
- method: "POST",
991
- headers,
992
- path: resolvedPath,
993
- query,
994
- body,
995
- });
643
+ b.m("POST").h(headers).q(query).b(body);
644
+ return b.build();
996
645
  };
997
646
  export const se_SendChannelMessageCommand = async (input, context) => {
998
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
647
+ const b = rb(input, context);
999
648
  const headers = map({}, isSerializableHeaderValue, {
1000
649
  "content-type": "application/json",
1001
- "x-amz-chime-bearer": input.ChimeBearer,
650
+ [_xacb]: input[_CB],
1002
651
  });
1003
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/messages";
1004
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
652
+ b.bp("/channels/{ChannelArn}/messages");
653
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
1005
654
  let body;
1006
655
  body = JSON.stringify(take(input, {
1007
656
  ClientRequestToken: [true, (_) => _ ?? generateIdempotencyToken()],
@@ -1015,122 +664,84 @@ export const se_SendChannelMessageCommand = async (input, context) => {
1015
664
  Target: (_) => _json(_),
1016
665
  Type: [],
1017
666
  }));
1018
- return new __HttpRequest({
1019
- protocol,
1020
- hostname,
1021
- port,
1022
- method: "POST",
1023
- headers,
1024
- path: resolvedPath,
1025
- body,
1026
- });
667
+ b.m("POST").h(headers).b(body);
668
+ return b.build();
1027
669
  };
1028
670
  export const se_TagResourceCommand = async (input, context) => {
1029
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
671
+ const b = rb(input, context);
1030
672
  const headers = {
1031
673
  "content-type": "application/json",
1032
674
  };
1033
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
675
+ b.bp("/tags");
1034
676
  const query = map({
1035
- operation: [, "tag-resource"],
677
+ [_o]: [, "tag-resource"],
1036
678
  });
1037
679
  let body;
1038
680
  body = JSON.stringify(take(input, {
1039
681
  ResourceARN: [],
1040
682
  Tags: (_) => _json(_),
1041
683
  }));
1042
- return new __HttpRequest({
1043
- protocol,
1044
- hostname,
1045
- port,
1046
- method: "POST",
1047
- headers,
1048
- path: resolvedPath,
1049
- query,
1050
- body,
1051
- });
684
+ b.m("POST").h(headers).q(query).b(body);
685
+ return b.build();
1052
686
  };
1053
687
  export const se_UntagResourceCommand = async (input, context) => {
1054
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
688
+ const b = rb(input, context);
1055
689
  const headers = {
1056
690
  "content-type": "application/json",
1057
691
  };
1058
- const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags";
692
+ b.bp("/tags");
1059
693
  const query = map({
1060
- operation: [, "untag-resource"],
694
+ [_o]: [, "untag-resource"],
1061
695
  });
1062
696
  let body;
1063
697
  body = JSON.stringify(take(input, {
1064
698
  ResourceARN: [],
1065
699
  TagKeys: (_) => _json(_),
1066
700
  }));
1067
- return new __HttpRequest({
1068
- protocol,
1069
- hostname,
1070
- port,
1071
- method: "POST",
1072
- headers,
1073
- path: resolvedPath,
1074
- query,
1075
- body,
1076
- });
701
+ b.m("POST").h(headers).q(query).b(body);
702
+ return b.build();
1077
703
  };
1078
704
  export const se_UpdateChannelCommand = async (input, context) => {
1079
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
705
+ const b = rb(input, context);
1080
706
  const headers = map({}, isSerializableHeaderValue, {
1081
707
  "content-type": "application/json",
1082
- "x-amz-chime-bearer": input.ChimeBearer,
708
+ [_xacb]: input[_CB],
1083
709
  });
1084
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}";
1085
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
710
+ b.bp("/channels/{ChannelArn}");
711
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
1086
712
  let body;
1087
713
  body = JSON.stringify(take(input, {
1088
714
  Metadata: [],
1089
715
  Mode: [],
1090
716
  Name: [],
1091
717
  }));
1092
- return new __HttpRequest({
1093
- protocol,
1094
- hostname,
1095
- port,
1096
- method: "PUT",
1097
- headers,
1098
- path: resolvedPath,
1099
- body,
1100
- });
718
+ b.m("PUT").h(headers).b(body);
719
+ return b.build();
1101
720
  };
1102
721
  export const se_UpdateChannelFlowCommand = async (input, context) => {
1103
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
722
+ const b = rb(input, context);
1104
723
  const headers = {
1105
724
  "content-type": "application/json",
1106
725
  };
1107
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channel-flows/{ChannelFlowArn}";
1108
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
726
+ b.bp("/channel-flows/{ChannelFlowArn}");
727
+ b.p("ChannelFlowArn", () => input.ChannelFlowArn, "{ChannelFlowArn}", false);
1109
728
  let body;
1110
729
  body = JSON.stringify(take(input, {
1111
730
  Name: [],
1112
731
  Processors: (_) => _json(_),
1113
732
  }));
1114
- return new __HttpRequest({
1115
- protocol,
1116
- hostname,
1117
- port,
1118
- method: "PUT",
1119
- headers,
1120
- path: resolvedPath,
1121
- body,
1122
- });
733
+ b.m("PUT").h(headers).b(body);
734
+ return b.build();
1123
735
  };
1124
736
  export const se_UpdateChannelMessageCommand = async (input, context) => {
1125
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
737
+ const b = rb(input, context);
1126
738
  const headers = map({}, isSerializableHeaderValue, {
1127
739
  "content-type": "application/json",
1128
- "x-amz-chime-bearer": input.ChimeBearer,
740
+ [_xacb]: input[_CB],
1129
741
  });
1130
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
1131
- "/channels/{ChannelArn}/messages/{MessageId}";
1132
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
1133
- resolvedPath = __resolvedPath(resolvedPath, input, "MessageId", () => input.MessageId, "{MessageId}", false);
742
+ b.bp("/channels/{ChannelArn}/messages/{MessageId}");
743
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
744
+ b.p("MessageId", () => input.MessageId, "{MessageId}", false);
1134
745
  let body;
1135
746
  body = JSON.stringify(take(input, {
1136
747
  Content: [],
@@ -1138,33 +749,19 @@ export const se_UpdateChannelMessageCommand = async (input, context) => {
1138
749
  Metadata: [],
1139
750
  SubChannelId: [],
1140
751
  }));
1141
- return new __HttpRequest({
1142
- protocol,
1143
- hostname,
1144
- port,
1145
- method: "PUT",
1146
- headers,
1147
- path: resolvedPath,
1148
- body,
1149
- });
752
+ b.m("PUT").h(headers).b(body);
753
+ return b.build();
1150
754
  };
1151
755
  export const se_UpdateChannelReadMarkerCommand = async (input, context) => {
1152
- const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
756
+ const b = rb(input, context);
1153
757
  const headers = map({}, isSerializableHeaderValue, {
1154
- "x-amz-chime-bearer": input.ChimeBearer,
758
+ [_xacb]: input[_CB],
1155
759
  });
1156
- let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/channels/{ChannelArn}/readMarker";
1157
- resolvedPath = __resolvedPath(resolvedPath, input, "ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
760
+ b.bp("/channels/{ChannelArn}/readMarker");
761
+ b.p("ChannelArn", () => input.ChannelArn, "{ChannelArn}", false);
1158
762
  let body;
1159
- return new __HttpRequest({
1160
- protocol,
1161
- hostname,
1162
- port,
1163
- method: "PUT",
1164
- headers,
1165
- path: resolvedPath,
1166
- body,
1167
- });
763
+ b.m("PUT").h(headers).b(body);
764
+ return b.build();
1168
765
  };
1169
766
  export const de_AssociateChannelFlowCommand = async (output, context) => {
1170
767
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4002,6 +3599,34 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
4002
3599
  value !== "" &&
4003
3600
  (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
4004
3601
  (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
3602
+ const _AIA = "AppInstanceArn";
3603
+ const _AIUA = "AppInstanceUserArn";
3604
+ const _CB = "ChimeBearer";
3605
+ const _CFA = "ChannelFlowArn";
3606
+ const _MR = "MaxResults";
3607
+ const _NA = "NotAfter";
3608
+ const _NB = "NotBefore";
3609
+ const _NT = "NextToken";
3610
+ const _P = "Privacy";
3611
+ const _RARN = "ResourceARN";
3612
+ const _SCI = "SubChannelId";
3613
+ const _SO = "SortOrder";
3614
+ const _T = "Type";
3615
+ const _a = "arn";
3616
+ const _aia = "app-instance-arn";
3617
+ const _aiua = "app-instance-user-arn";
3618
+ const _cfa = "channel-flow-arn";
3619
+ const _mr = "max-results";
3620
+ const _na = "not-after";
3621
+ const _nb = "not-before";
3622
+ const _nt = "next-token";
3623
+ const _o = "operation";
3624
+ const _p = "privacy";
3625
+ const _s = "scope";
3626
+ const _sci = "sub-channel-id";
3627
+ const _so = "sort-order";
3628
+ const _t = "type";
3629
+ const _xacb = "x-amz-chime-bearer";
4005
3630
  const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
4006
3631
  if (encoded.length) {
4007
3632
  return JSON.parse(encoded);