@aws-sdk/client-kinesis-video-signaling 3.901.0 → 3.906.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 (2) hide show
  1. package/dist-cjs/index.js +413 -539
  2. package/package.json +5 -5
package/dist-cjs/index.js CHANGED
@@ -1,571 +1,445 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
10
- };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
18
- };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- ClientLimitExceededException: () => ClientLimitExceededException,
25
- GetIceServerConfigCommand: () => GetIceServerConfigCommand,
26
- InvalidArgumentException: () => InvalidArgumentException,
27
- InvalidClientException: () => InvalidClientException,
28
- KinesisVideoSignaling: () => KinesisVideoSignaling,
29
- KinesisVideoSignalingClient: () => KinesisVideoSignalingClient,
30
- KinesisVideoSignalingServiceException: () => KinesisVideoSignalingServiceException,
31
- NotAuthorizedException: () => NotAuthorizedException,
32
- ResourceNotFoundException: () => ResourceNotFoundException,
33
- SendAlexaOfferToMasterCommand: () => SendAlexaOfferToMasterCommand,
34
- Service: () => Service,
35
- SessionExpiredException: () => SessionExpiredException,
36
- __Client: () => import_smithy_client.Client
37
- });
38
- module.exports = __toCommonJS(index_exports);
1
+ 'use strict';
39
2
 
40
- // src/KinesisVideoSignalingClient.ts
41
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
42
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
43
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
44
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
45
- var import_config_resolver = require("@smithy/config-resolver");
46
- var import_core = require("@smithy/core");
47
- var import_middleware_content_length = require("@smithy/middleware-content-length");
48
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
49
- var import_middleware_retry = require("@smithy/middleware-retry");
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
50
19
 
51
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
52
-
53
- // src/endpoint/EndpointParameters.ts
54
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
55
- return Object.assign(options, {
56
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
57
- useFipsEndpoint: options.useFipsEndpoint ?? false,
58
- defaultSigningName: "kinesisvideo"
59
- });
60
- }, "resolveClientEndpointParameters");
61
- var commonParams = {
62
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
63
- Endpoint: { type: "builtInParams", name: "endpoint" },
64
- Region: { type: "builtInParams", name: "region" },
65
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
20
+ const resolveClientEndpointParameters = (options) => {
21
+ return Object.assign(options, {
22
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
23
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
24
+ defaultSigningName: "kinesisvideo",
25
+ });
26
+ };
27
+ const commonParams = {
28
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
29
+ Endpoint: { type: "builtInParams", name: "endpoint" },
30
+ Region: { type: "builtInParams", name: "region" },
31
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
66
32
  };
67
33
 
68
- // src/KinesisVideoSignalingClient.ts
69
- var import_runtimeConfig = require("././runtimeConfig");
34
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
35
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
36
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
37
+ let _credentials = runtimeConfig.credentials;
38
+ return {
39
+ setHttpAuthScheme(httpAuthScheme) {
40
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
41
+ if (index === -1) {
42
+ _httpAuthSchemes.push(httpAuthScheme);
43
+ }
44
+ else {
45
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
46
+ }
47
+ },
48
+ httpAuthSchemes() {
49
+ return _httpAuthSchemes;
50
+ },
51
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
52
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
53
+ },
54
+ httpAuthSchemeProvider() {
55
+ return _httpAuthSchemeProvider;
56
+ },
57
+ setCredentials(credentials) {
58
+ _credentials = credentials;
59
+ },
60
+ credentials() {
61
+ return _credentials;
62
+ },
63
+ };
64
+ };
65
+ const resolveHttpAuthRuntimeConfig = (config) => {
66
+ return {
67
+ httpAuthSchemes: config.httpAuthSchemes(),
68
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
69
+ credentials: config.credentials(),
70
+ };
71
+ };
70
72
 
71
- // src/runtimeExtensions.ts
72
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
73
- var import_protocol_http = require("@smithy/protocol-http");
74
- var import_smithy_client = require("@smithy/smithy-client");
73
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
74
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
75
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
76
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
77
+ };
75
78
 
76
- // src/auth/httpAuthExtensionConfiguration.ts
77
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
78
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
79
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
80
- let _credentials = runtimeConfig.credentials;
81
- return {
82
- setHttpAuthScheme(httpAuthScheme) {
83
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
84
- if (index === -1) {
85
- _httpAuthSchemes.push(httpAuthScheme);
86
- } else {
87
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
88
- }
89
- },
90
- httpAuthSchemes() {
91
- return _httpAuthSchemes;
92
- },
93
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
94
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
95
- },
96
- httpAuthSchemeProvider() {
97
- return _httpAuthSchemeProvider;
98
- },
99
- setCredentials(credentials) {
100
- _credentials = credentials;
101
- },
102
- credentials() {
103
- return _credentials;
79
+ class KinesisVideoSignalingClient extends smithyClient.Client {
80
+ config;
81
+ constructor(...[configuration]) {
82
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
83
+ super(_config_0);
84
+ this.initConfig = _config_0;
85
+ const _config_1 = resolveClientEndpointParameters(_config_0);
86
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
87
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
88
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
89
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
90
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
91
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
92
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
93
+ this.config = _config_8;
94
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
95
+ this.middlewareStack.use(middlewareRetry.getOmitRetryHeadersPlugin(this.config));
96
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
97
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
98
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
99
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
100
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
101
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
102
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultKinesisVideoSignalingHttpAuthSchemeParametersProvider,
103
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
104
+ "aws.auth#sigv4": config.credentials,
105
+ }),
106
+ }));
107
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
104
108
  }
105
- };
106
- }, "getHttpAuthExtensionConfiguration");
107
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
108
- return {
109
- httpAuthSchemes: config.httpAuthSchemes(),
110
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
111
- credentials: config.credentials()
112
- };
113
- }, "resolveHttpAuthRuntimeConfig");
109
+ destroy() {
110
+ super.destroy();
111
+ }
112
+ }
114
113
 
115
- // src/runtimeExtensions.ts
116
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
117
- const extensionConfiguration = Object.assign(
118
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
119
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
120
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
121
- getHttpAuthExtensionConfiguration(runtimeConfig)
122
- );
123
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
124
- return Object.assign(
125
- runtimeConfig,
126
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
127
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
128
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
129
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
130
- );
131
- }, "resolveRuntimeExtensions");
114
+ class KinesisVideoSignalingServiceException extends smithyClient.ServiceException {
115
+ constructor(options) {
116
+ super(options);
117
+ Object.setPrototypeOf(this, KinesisVideoSignalingServiceException.prototype);
118
+ }
119
+ }
132
120
 
133
- // src/KinesisVideoSignalingClient.ts
134
- var KinesisVideoSignalingClient = class extends import_smithy_client.Client {
135
- static {
136
- __name(this, "KinesisVideoSignalingClient");
137
- }
138
- /**
139
- * The resolved configuration of KinesisVideoSignalingClient class. This is resolved and normalized from the {@link KinesisVideoSignalingClientConfig | constructor configuration interface}.
140
- */
141
- config;
142
- constructor(...[configuration]) {
143
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
144
- super(_config_0);
145
- this.initConfig = _config_0;
146
- const _config_1 = resolveClientEndpointParameters(_config_0);
147
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
148
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
149
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
150
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
151
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
152
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
153
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
154
- this.config = _config_8;
155
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
156
- this.middlewareStack.use((0, import_middleware_retry.getOmitRetryHeadersPlugin)(this.config));
157
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
158
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
159
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
160
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
161
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
162
- this.middlewareStack.use(
163
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
164
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultKinesisVideoSignalingHttpAuthSchemeParametersProvider,
165
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
166
- "aws.auth#sigv4": config.credentials
167
- }), "identityProviderConfigProvider")
168
- })
169
- );
170
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
171
- }
172
- /**
173
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
174
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
175
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
176
- */
177
- destroy() {
178
- super.destroy();
179
- }
121
+ class ClientLimitExceededException extends KinesisVideoSignalingServiceException {
122
+ name = "ClientLimitExceededException";
123
+ $fault = "client";
124
+ Message;
125
+ constructor(opts) {
126
+ super({
127
+ name: "ClientLimitExceededException",
128
+ $fault: "client",
129
+ ...opts,
130
+ });
131
+ Object.setPrototypeOf(this, ClientLimitExceededException.prototype);
132
+ this.Message = opts.Message;
133
+ }
134
+ }
135
+ const Service = {
136
+ TURN: "TURN",
180
137
  };
138
+ class InvalidArgumentException extends KinesisVideoSignalingServiceException {
139
+ name = "InvalidArgumentException";
140
+ $fault = "client";
141
+ Message;
142
+ constructor(opts) {
143
+ super({
144
+ name: "InvalidArgumentException",
145
+ $fault: "client",
146
+ ...opts,
147
+ });
148
+ Object.setPrototypeOf(this, InvalidArgumentException.prototype);
149
+ this.Message = opts.Message;
150
+ }
151
+ }
152
+ class InvalidClientException extends KinesisVideoSignalingServiceException {
153
+ name = "InvalidClientException";
154
+ $fault = "client";
155
+ constructor(opts) {
156
+ super({
157
+ name: "InvalidClientException",
158
+ $fault: "client",
159
+ ...opts,
160
+ });
161
+ Object.setPrototypeOf(this, InvalidClientException.prototype);
162
+ }
163
+ }
164
+ class NotAuthorizedException extends KinesisVideoSignalingServiceException {
165
+ name = "NotAuthorizedException";
166
+ $fault = "client";
167
+ Message;
168
+ constructor(opts) {
169
+ super({
170
+ name: "NotAuthorizedException",
171
+ $fault: "client",
172
+ ...opts,
173
+ });
174
+ Object.setPrototypeOf(this, NotAuthorizedException.prototype);
175
+ this.Message = opts.Message;
176
+ }
177
+ }
178
+ class ResourceNotFoundException extends KinesisVideoSignalingServiceException {
179
+ name = "ResourceNotFoundException";
180
+ $fault = "client";
181
+ Message;
182
+ constructor(opts) {
183
+ super({
184
+ name: "ResourceNotFoundException",
185
+ $fault: "client",
186
+ ...opts,
187
+ });
188
+ Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
189
+ this.Message = opts.Message;
190
+ }
191
+ }
192
+ class SessionExpiredException extends KinesisVideoSignalingServiceException {
193
+ name = "SessionExpiredException";
194
+ $fault = "client";
195
+ constructor(opts) {
196
+ super({
197
+ name: "SessionExpiredException",
198
+ $fault: "client",
199
+ ...opts,
200
+ });
201
+ Object.setPrototypeOf(this, SessionExpiredException.prototype);
202
+ }
203
+ }
181
204
 
182
- // src/KinesisVideoSignaling.ts
183
-
184
-
185
- // src/commands/GetIceServerConfigCommand.ts
186
-
187
- var import_middleware_serde = require("@smithy/middleware-serde");
188
-
189
-
190
- // src/protocols/Aws_restJson1.ts
191
- var import_core2 = require("@aws-sdk/core");
192
-
193
-
194
-
195
- // src/models/KinesisVideoSignalingServiceException.ts
196
-
197
- var KinesisVideoSignalingServiceException = class _KinesisVideoSignalingServiceException extends import_smithy_client.ServiceException {
198
- static {
199
- __name(this, "KinesisVideoSignalingServiceException");
200
- }
201
- /**
202
- * @internal
203
- */
204
- constructor(options) {
205
- super(options);
206
- Object.setPrototypeOf(this, _KinesisVideoSignalingServiceException.prototype);
207
- }
205
+ const se_GetIceServerConfigCommand = async (input, context) => {
206
+ const b = core.requestBuilder(input, context);
207
+ const headers = {
208
+ "content-type": "application/json",
209
+ };
210
+ b.bp("/v1/get-ice-server-config");
211
+ let body;
212
+ body = JSON.stringify(smithyClient.take(input, {
213
+ ChannelARN: [],
214
+ ClientId: [],
215
+ Service: [],
216
+ Username: [],
217
+ }));
218
+ b.m("POST").h(headers).b(body);
219
+ return b.build();
208
220
  };
209
-
210
- // src/models/models_0.ts
211
- var ClientLimitExceededException = class _ClientLimitExceededException extends KinesisVideoSignalingServiceException {
212
- static {
213
- __name(this, "ClientLimitExceededException");
214
- }
215
- name = "ClientLimitExceededException";
216
- $fault = "client";
217
- Message;
218
- /**
219
- * @internal
220
- */
221
- constructor(opts) {
222
- super({
223
- name: "ClientLimitExceededException",
224
- $fault: "client",
225
- ...opts
221
+ const se_SendAlexaOfferToMasterCommand = async (input, context) => {
222
+ const b = core.requestBuilder(input, context);
223
+ const headers = {
224
+ "content-type": "application/json",
225
+ };
226
+ b.bp("/v1/send-alexa-offer-to-master");
227
+ let body;
228
+ body = JSON.stringify(smithyClient.take(input, {
229
+ ChannelARN: [],
230
+ MessagePayload: [],
231
+ SenderClientId: [],
232
+ }));
233
+ b.m("POST").h(headers).b(body);
234
+ return b.build();
235
+ };
236
+ const de_GetIceServerConfigCommand = async (output, context) => {
237
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
238
+ return de_CommandError(output, context);
239
+ }
240
+ const contents = smithyClient.map({
241
+ $metadata: deserializeMetadata(output),
226
242
  });
227
- Object.setPrototypeOf(this, _ClientLimitExceededException.prototype);
228
- this.Message = opts.Message;
229
- }
243
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
244
+ const doc = smithyClient.take(data, {
245
+ IceServerList: smithyClient._json,
246
+ });
247
+ Object.assign(contents, doc);
248
+ return contents;
230
249
  };
231
- var Service = {
232
- TURN: "TURN"
250
+ const de_SendAlexaOfferToMasterCommand = async (output, context) => {
251
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
252
+ return de_CommandError(output, context);
253
+ }
254
+ const contents = smithyClient.map({
255
+ $metadata: deserializeMetadata(output),
256
+ });
257
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
258
+ const doc = smithyClient.take(data, {
259
+ Answer: smithyClient.expectString,
260
+ });
261
+ Object.assign(contents, doc);
262
+ return contents;
263
+ };
264
+ const de_CommandError = async (output, context) => {
265
+ const parsedOutput = {
266
+ ...output,
267
+ body: await core$1.parseJsonErrorBody(output.body, context),
268
+ };
269
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
270
+ switch (errorCode) {
271
+ case "ClientLimitExceededException":
272
+ case "com.amazonaws.kinesisvideosignaling#ClientLimitExceededException":
273
+ throw await de_ClientLimitExceededExceptionRes(parsedOutput);
274
+ case "InvalidArgumentException":
275
+ case "com.amazonaws.kinesisvideosignaling#InvalidArgumentException":
276
+ throw await de_InvalidArgumentExceptionRes(parsedOutput);
277
+ case "InvalidClientException":
278
+ case "com.amazonaws.kinesisvideosignaling#InvalidClientException":
279
+ throw await de_InvalidClientExceptionRes(parsedOutput);
280
+ case "NotAuthorizedException":
281
+ case "com.amazonaws.kinesisvideosignaling#NotAuthorizedException":
282
+ throw await de_NotAuthorizedExceptionRes(parsedOutput);
283
+ case "ResourceNotFoundException":
284
+ case "com.amazonaws.kinesisvideosignaling#ResourceNotFoundException":
285
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput);
286
+ case "SessionExpiredException":
287
+ case "com.amazonaws.kinesisvideosignaling#SessionExpiredException":
288
+ throw await de_SessionExpiredExceptionRes(parsedOutput);
289
+ default:
290
+ const parsedBody = parsedOutput.body;
291
+ return throwDefaultError({
292
+ output,
293
+ parsedBody,
294
+ errorCode,
295
+ });
296
+ }
233
297
  };
234
- var InvalidArgumentException = class _InvalidArgumentException extends KinesisVideoSignalingServiceException {
235
- static {
236
- __name(this, "InvalidArgumentException");
237
- }
238
- name = "InvalidArgumentException";
239
- $fault = "client";
240
- Message;
241
- /**
242
- * @internal
243
- */
244
- constructor(opts) {
245
- super({
246
- name: "InvalidArgumentException",
247
- $fault: "client",
248
- ...opts
298
+ const throwDefaultError = smithyClient.withBaseException(KinesisVideoSignalingServiceException);
299
+ const de_ClientLimitExceededExceptionRes = async (parsedOutput, context) => {
300
+ const contents = smithyClient.map({});
301
+ const data = parsedOutput.body;
302
+ const doc = smithyClient.take(data, {
303
+ Message: smithyClient.expectString,
249
304
  });
250
- Object.setPrototypeOf(this, _InvalidArgumentException.prototype);
251
- this.Message = opts.Message;
252
- }
305
+ Object.assign(contents, doc);
306
+ const exception = new ClientLimitExceededException({
307
+ $metadata: deserializeMetadata(parsedOutput),
308
+ ...contents,
309
+ });
310
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
253
311
  };
254
- var InvalidClientException = class _InvalidClientException extends KinesisVideoSignalingServiceException {
255
- static {
256
- __name(this, "InvalidClientException");
257
- }
258
- name = "InvalidClientException";
259
- $fault = "client";
260
- /**
261
- * @internal
262
- */
263
- constructor(opts) {
264
- super({
265
- name: "InvalidClientException",
266
- $fault: "client",
267
- ...opts
312
+ const de_InvalidArgumentExceptionRes = async (parsedOutput, context) => {
313
+ const contents = smithyClient.map({});
314
+ const data = parsedOutput.body;
315
+ const doc = smithyClient.take(data, {
316
+ Message: smithyClient.expectString,
317
+ });
318
+ Object.assign(contents, doc);
319
+ const exception = new InvalidArgumentException({
320
+ $metadata: deserializeMetadata(parsedOutput),
321
+ ...contents,
268
322
  });
269
- Object.setPrototypeOf(this, _InvalidClientException.prototype);
270
- }
323
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
271
324
  };
272
- var NotAuthorizedException = class _NotAuthorizedException extends KinesisVideoSignalingServiceException {
273
- static {
274
- __name(this, "NotAuthorizedException");
275
- }
276
- name = "NotAuthorizedException";
277
- $fault = "client";
278
- Message;
279
- /**
280
- * @internal
281
- */
282
- constructor(opts) {
283
- super({
284
- name: "NotAuthorizedException",
285
- $fault: "client",
286
- ...opts
325
+ const de_InvalidClientExceptionRes = async (parsedOutput, context) => {
326
+ const contents = smithyClient.map({});
327
+ const data = parsedOutput.body;
328
+ const doc = smithyClient.take(data, {
329
+ message: smithyClient.expectString,
330
+ });
331
+ Object.assign(contents, doc);
332
+ const exception = new InvalidClientException({
333
+ $metadata: deserializeMetadata(parsedOutput),
334
+ ...contents,
287
335
  });
288
- Object.setPrototypeOf(this, _NotAuthorizedException.prototype);
289
- this.Message = opts.Message;
290
- }
336
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
291
337
  };
292
- var ResourceNotFoundException = class _ResourceNotFoundException extends KinesisVideoSignalingServiceException {
293
- static {
294
- __name(this, "ResourceNotFoundException");
295
- }
296
- name = "ResourceNotFoundException";
297
- $fault = "client";
298
- Message;
299
- /**
300
- * @internal
301
- */
302
- constructor(opts) {
303
- super({
304
- name: "ResourceNotFoundException",
305
- $fault: "client",
306
- ...opts
338
+ const de_NotAuthorizedExceptionRes = async (parsedOutput, context) => {
339
+ const contents = smithyClient.map({});
340
+ const data = parsedOutput.body;
341
+ const doc = smithyClient.take(data, {
342
+ Message: smithyClient.expectString,
307
343
  });
308
- Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
309
- this.Message = opts.Message;
310
- }
344
+ Object.assign(contents, doc);
345
+ const exception = new NotAuthorizedException({
346
+ $metadata: deserializeMetadata(parsedOutput),
347
+ ...contents,
348
+ });
349
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
311
350
  };
312
- var SessionExpiredException = class _SessionExpiredException extends KinesisVideoSignalingServiceException {
313
- static {
314
- __name(this, "SessionExpiredException");
315
- }
316
- name = "SessionExpiredException";
317
- $fault = "client";
318
- /**
319
- * @internal
320
- */
321
- constructor(opts) {
322
- super({
323
- name: "SessionExpiredException",
324
- $fault: "client",
325
- ...opts
351
+ const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
352
+ const contents = smithyClient.map({});
353
+ const data = parsedOutput.body;
354
+ const doc = smithyClient.take(data, {
355
+ Message: smithyClient.expectString,
356
+ });
357
+ Object.assign(contents, doc);
358
+ const exception = new ResourceNotFoundException({
359
+ $metadata: deserializeMetadata(parsedOutput),
360
+ ...contents,
326
361
  });
327
- Object.setPrototypeOf(this, _SessionExpiredException.prototype);
328
- }
362
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
329
363
  };
330
-
331
- // src/protocols/Aws_restJson1.ts
332
- var se_GetIceServerConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
333
- const b = (0, import_core.requestBuilder)(input, context);
334
- const headers = {
335
- "content-type": "application/json"
336
- };
337
- b.bp("/v1/get-ice-server-config");
338
- let body;
339
- body = JSON.stringify(
340
- (0, import_smithy_client.take)(input, {
341
- ChannelARN: [],
342
- ClientId: [],
343
- Service: [],
344
- Username: []
345
- })
346
- );
347
- b.m("POST").h(headers).b(body);
348
- return b.build();
349
- }, "se_GetIceServerConfigCommand");
350
- var se_SendAlexaOfferToMasterCommand = /* @__PURE__ */ __name(async (input, context) => {
351
- const b = (0, import_core.requestBuilder)(input, context);
352
- const headers = {
353
- "content-type": "application/json"
354
- };
355
- b.bp("/v1/send-alexa-offer-to-master");
356
- let body;
357
- body = JSON.stringify(
358
- (0, import_smithy_client.take)(input, {
359
- ChannelARN: [],
360
- MessagePayload: [],
361
- SenderClientId: []
362
- })
363
- );
364
- b.m("POST").h(headers).b(body);
365
- return b.build();
366
- }, "se_SendAlexaOfferToMasterCommand");
367
- var de_GetIceServerConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
368
- if (output.statusCode !== 200 && output.statusCode >= 300) {
369
- return de_CommandError(output, context);
370
- }
371
- const contents = (0, import_smithy_client.map)({
372
- $metadata: deserializeMetadata(output)
373
- });
374
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
375
- const doc = (0, import_smithy_client.take)(data, {
376
- IceServerList: import_smithy_client._json
377
- });
378
- Object.assign(contents, doc);
379
- return contents;
380
- }, "de_GetIceServerConfigCommand");
381
- var de_SendAlexaOfferToMasterCommand = /* @__PURE__ */ __name(async (output, context) => {
382
- if (output.statusCode !== 200 && output.statusCode >= 300) {
383
- return de_CommandError(output, context);
384
- }
385
- const contents = (0, import_smithy_client.map)({
386
- $metadata: deserializeMetadata(output)
387
- });
388
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
389
- const doc = (0, import_smithy_client.take)(data, {
390
- Answer: import_smithy_client.expectString
391
- });
392
- Object.assign(contents, doc);
393
- return contents;
394
- }, "de_SendAlexaOfferToMasterCommand");
395
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
396
- const parsedOutput = {
397
- ...output,
398
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
399
- };
400
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
401
- switch (errorCode) {
402
- case "ClientLimitExceededException":
403
- case "com.amazonaws.kinesisvideosignaling#ClientLimitExceededException":
404
- throw await de_ClientLimitExceededExceptionRes(parsedOutput, context);
405
- case "InvalidArgumentException":
406
- case "com.amazonaws.kinesisvideosignaling#InvalidArgumentException":
407
- throw await de_InvalidArgumentExceptionRes(parsedOutput, context);
408
- case "InvalidClientException":
409
- case "com.amazonaws.kinesisvideosignaling#InvalidClientException":
410
- throw await de_InvalidClientExceptionRes(parsedOutput, context);
411
- case "NotAuthorizedException":
412
- case "com.amazonaws.kinesisvideosignaling#NotAuthorizedException":
413
- throw await de_NotAuthorizedExceptionRes(parsedOutput, context);
414
- case "ResourceNotFoundException":
415
- case "com.amazonaws.kinesisvideosignaling#ResourceNotFoundException":
416
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
417
- case "SessionExpiredException":
418
- case "com.amazonaws.kinesisvideosignaling#SessionExpiredException":
419
- throw await de_SessionExpiredExceptionRes(parsedOutput, context);
420
- default:
421
- const parsedBody = parsedOutput.body;
422
- return throwDefaultError({
423
- output,
424
- parsedBody,
425
- errorCode
426
- });
427
- }
428
- }, "de_CommandError");
429
- var throwDefaultError = (0, import_smithy_client.withBaseException)(KinesisVideoSignalingServiceException);
430
- var de_ClientLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
431
- const contents = (0, import_smithy_client.map)({});
432
- const data = parsedOutput.body;
433
- const doc = (0, import_smithy_client.take)(data, {
434
- Message: import_smithy_client.expectString
435
- });
436
- Object.assign(contents, doc);
437
- const exception = new ClientLimitExceededException({
438
- $metadata: deserializeMetadata(parsedOutput),
439
- ...contents
440
- });
441
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
442
- }, "de_ClientLimitExceededExceptionRes");
443
- var de_InvalidArgumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
444
- const contents = (0, import_smithy_client.map)({});
445
- const data = parsedOutput.body;
446
- const doc = (0, import_smithy_client.take)(data, {
447
- Message: import_smithy_client.expectString
448
- });
449
- Object.assign(contents, doc);
450
- const exception = new InvalidArgumentException({
451
- $metadata: deserializeMetadata(parsedOutput),
452
- ...contents
453
- });
454
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
455
- }, "de_InvalidArgumentExceptionRes");
456
- var de_InvalidClientExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
457
- const contents = (0, import_smithy_client.map)({});
458
- const data = parsedOutput.body;
459
- const doc = (0, import_smithy_client.take)(data, {
460
- message: import_smithy_client.expectString
461
- });
462
- Object.assign(contents, doc);
463
- const exception = new InvalidClientException({
464
- $metadata: deserializeMetadata(parsedOutput),
465
- ...contents
466
- });
467
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
468
- }, "de_InvalidClientExceptionRes");
469
- var de_NotAuthorizedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
470
- const contents = (0, import_smithy_client.map)({});
471
- const data = parsedOutput.body;
472
- const doc = (0, import_smithy_client.take)(data, {
473
- Message: import_smithy_client.expectString
474
- });
475
- Object.assign(contents, doc);
476
- const exception = new NotAuthorizedException({
477
- $metadata: deserializeMetadata(parsedOutput),
478
- ...contents
479
- });
480
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
481
- }, "de_NotAuthorizedExceptionRes");
482
- var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
483
- const contents = (0, import_smithy_client.map)({});
484
- const data = parsedOutput.body;
485
- const doc = (0, import_smithy_client.take)(data, {
486
- Message: import_smithy_client.expectString
487
- });
488
- Object.assign(contents, doc);
489
- const exception = new ResourceNotFoundException({
490
- $metadata: deserializeMetadata(parsedOutput),
491
- ...contents
492
- });
493
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
494
- }, "de_ResourceNotFoundExceptionRes");
495
- var de_SessionExpiredExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
496
- const contents = (0, import_smithy_client.map)({});
497
- const data = parsedOutput.body;
498
- const doc = (0, import_smithy_client.take)(data, {
499
- message: import_smithy_client.expectString
500
- });
501
- Object.assign(contents, doc);
502
- const exception = new SessionExpiredException({
503
- $metadata: deserializeMetadata(parsedOutput),
504
- ...contents
505
- });
506
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
507
- }, "de_SessionExpiredExceptionRes");
508
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
509
- httpStatusCode: output.statusCode,
510
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
511
- extendedRequestId: output.headers["x-amz-id-2"],
512
- cfId: output.headers["x-amz-cf-id"]
513
- }), "deserializeMetadata");
514
-
515
- // src/commands/GetIceServerConfigCommand.ts
516
- var GetIceServerConfigCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
517
- return [
518
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
519
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
520
- ];
521
- }).s("AWSAcuitySignalingService", "GetIceServerConfig", {}).n("KinesisVideoSignalingClient", "GetIceServerConfigCommand").f(void 0, void 0).ser(se_GetIceServerConfigCommand).de(de_GetIceServerConfigCommand).build() {
522
- static {
523
- __name(this, "GetIceServerConfigCommand");
524
- }
364
+ const de_SessionExpiredExceptionRes = async (parsedOutput, context) => {
365
+ const contents = smithyClient.map({});
366
+ const data = parsedOutput.body;
367
+ const doc = smithyClient.take(data, {
368
+ message: smithyClient.expectString,
369
+ });
370
+ Object.assign(contents, doc);
371
+ const exception = new SessionExpiredException({
372
+ $metadata: deserializeMetadata(parsedOutput),
373
+ ...contents,
374
+ });
375
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
525
376
  };
377
+ const deserializeMetadata = (output) => ({
378
+ httpStatusCode: output.statusCode,
379
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
380
+ extendedRequestId: output.headers["x-amz-id-2"],
381
+ cfId: output.headers["x-amz-cf-id"],
382
+ });
526
383
 
527
- // src/commands/SendAlexaOfferToMasterCommand.ts
528
-
529
-
384
+ class GetIceServerConfigCommand extends smithyClient.Command
385
+ .classBuilder()
386
+ .ep(commonParams)
387
+ .m(function (Command, cs, config, o) {
388
+ return [
389
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
390
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
391
+ ];
392
+ })
393
+ .s("AWSAcuitySignalingService", "GetIceServerConfig", {})
394
+ .n("KinesisVideoSignalingClient", "GetIceServerConfigCommand")
395
+ .f(void 0, void 0)
396
+ .ser(se_GetIceServerConfigCommand)
397
+ .de(de_GetIceServerConfigCommand)
398
+ .build() {
399
+ }
530
400
 
531
- var SendAlexaOfferToMasterCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
532
- return [
533
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
534
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
535
- ];
536
- }).s("AWSAcuitySignalingService", "SendAlexaOfferToMaster", {}).n("KinesisVideoSignalingClient", "SendAlexaOfferToMasterCommand").f(void 0, void 0).ser(se_SendAlexaOfferToMasterCommand).de(de_SendAlexaOfferToMasterCommand).build() {
537
- static {
538
- __name(this, "SendAlexaOfferToMasterCommand");
539
- }
540
- };
401
+ class SendAlexaOfferToMasterCommand extends smithyClient.Command
402
+ .classBuilder()
403
+ .ep(commonParams)
404
+ .m(function (Command, cs, config, o) {
405
+ return [
406
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
407
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
408
+ ];
409
+ })
410
+ .s("AWSAcuitySignalingService", "SendAlexaOfferToMaster", {})
411
+ .n("KinesisVideoSignalingClient", "SendAlexaOfferToMasterCommand")
412
+ .f(void 0, void 0)
413
+ .ser(se_SendAlexaOfferToMasterCommand)
414
+ .de(de_SendAlexaOfferToMasterCommand)
415
+ .build() {
416
+ }
541
417
 
542
- // src/KinesisVideoSignaling.ts
543
- var commands = {
544
- GetIceServerConfigCommand,
545
- SendAlexaOfferToMasterCommand
418
+ const commands = {
419
+ GetIceServerConfigCommand,
420
+ SendAlexaOfferToMasterCommand,
546
421
  };
547
- var KinesisVideoSignaling = class extends KinesisVideoSignalingClient {
548
- static {
549
- __name(this, "KinesisVideoSignaling");
550
- }
551
- };
552
- (0, import_smithy_client.createAggregatedClient)(commands, KinesisVideoSignaling);
553
- // Annotate the CommonJS export names for ESM import in node:
422
+ class KinesisVideoSignaling extends KinesisVideoSignalingClient {
423
+ }
424
+ smithyClient.createAggregatedClient(commands, KinesisVideoSignaling);
554
425
 
555
- 0 && (module.exports = {
556
- KinesisVideoSignalingServiceException,
557
- __Client,
558
- KinesisVideoSignalingClient,
559
- KinesisVideoSignaling,
560
- $Command,
561
- GetIceServerConfigCommand,
562
- SendAlexaOfferToMasterCommand,
563
- ClientLimitExceededException,
564
- Service,
565
- InvalidArgumentException,
566
- InvalidClientException,
567
- NotAuthorizedException,
568
- ResourceNotFoundException,
569
- SessionExpiredException
426
+ Object.defineProperty(exports, "$Command", {
427
+ enumerable: true,
428
+ get: function () { return smithyClient.Command; }
570
429
  });
571
-
430
+ Object.defineProperty(exports, "__Client", {
431
+ enumerable: true,
432
+ get: function () { return smithyClient.Client; }
433
+ });
434
+ exports.ClientLimitExceededException = ClientLimitExceededException;
435
+ exports.GetIceServerConfigCommand = GetIceServerConfigCommand;
436
+ exports.InvalidArgumentException = InvalidArgumentException;
437
+ exports.InvalidClientException = InvalidClientException;
438
+ exports.KinesisVideoSignaling = KinesisVideoSignaling;
439
+ exports.KinesisVideoSignalingClient = KinesisVideoSignalingClient;
440
+ exports.KinesisVideoSignalingServiceException = KinesisVideoSignalingServiceException;
441
+ exports.NotAuthorizedException = NotAuthorizedException;
442
+ exports.ResourceNotFoundException = ResourceNotFoundException;
443
+ exports.SendAlexaOfferToMasterCommand = SendAlexaOfferToMasterCommand;
444
+ exports.Service = Service;
445
+ exports.SessionExpiredException = SessionExpiredException;
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@aws-sdk/client-kinesis-video-signaling",
3
3
  "description": "AWS SDK for JavaScript Kinesis Video Signaling Client for Node.js, Browser and React Native",
4
- "version": "3.901.0",
4
+ "version": "3.906.0",
5
5
  "scripts": {
6
6
  "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
7
7
  "build:cjs": "node ../../scripts/compilation/inline client-kinesis-video-signaling",
@@ -20,17 +20,17 @@
20
20
  "dependencies": {
21
21
  "@aws-crypto/sha256-browser": "5.2.0",
22
22
  "@aws-crypto/sha256-js": "5.2.0",
23
- "@aws-sdk/core": "3.901.0",
24
- "@aws-sdk/credential-provider-node": "3.901.0",
23
+ "@aws-sdk/core": "3.906.0",
24
+ "@aws-sdk/credential-provider-node": "3.906.0",
25
25
  "@aws-sdk/middleware-host-header": "3.901.0",
26
26
  "@aws-sdk/middleware-logger": "3.901.0",
27
27
  "@aws-sdk/middleware-recursion-detection": "3.901.0",
28
- "@aws-sdk/middleware-user-agent": "3.901.0",
28
+ "@aws-sdk/middleware-user-agent": "3.906.0",
29
29
  "@aws-sdk/region-config-resolver": "3.901.0",
30
30
  "@aws-sdk/types": "3.901.0",
31
31
  "@aws-sdk/util-endpoints": "3.901.0",
32
32
  "@aws-sdk/util-user-agent-browser": "3.901.0",
33
- "@aws-sdk/util-user-agent-node": "3.901.0",
33
+ "@aws-sdk/util-user-agent-node": "3.906.0",
34
34
  "@smithy/config-resolver": "^4.3.0",
35
35
  "@smithy/core": "^3.14.0",
36
36
  "@smithy/fetch-http-handler": "^5.3.0",