@aws-sdk/client-sso-oidc 3.901.0 → 3.907.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 +885 -1227
  2. package/package.json +6 -6
package/dist-cjs/index.js CHANGED
@@ -1,1276 +1,934 @@
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 });
1
+ 'use strict';
2
+
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');
19
+
20
+ const resolveClientEndpointParameters = (options) => {
21
+ return Object.assign(options, {
22
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
23
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
24
+ defaultSigningName: "sso-oauth",
25
+ });
10
26
  };
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;
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" },
18
32
  };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- AccessDeniedException: () => AccessDeniedException,
25
- AccessDeniedExceptionReason: () => AccessDeniedExceptionReason,
26
- AuthorizationPendingException: () => AuthorizationPendingException,
27
- CreateTokenCommand: () => CreateTokenCommand,
28
- CreateTokenRequestFilterSensitiveLog: () => CreateTokenRequestFilterSensitiveLog,
29
- CreateTokenResponseFilterSensitiveLog: () => CreateTokenResponseFilterSensitiveLog,
30
- CreateTokenWithIAMCommand: () => CreateTokenWithIAMCommand,
31
- CreateTokenWithIAMRequestFilterSensitiveLog: () => CreateTokenWithIAMRequestFilterSensitiveLog,
32
- CreateTokenWithIAMResponseFilterSensitiveLog: () => CreateTokenWithIAMResponseFilterSensitiveLog,
33
- ExpiredTokenException: () => ExpiredTokenException,
34
- InternalServerException: () => InternalServerException,
35
- InvalidClientException: () => InvalidClientException,
36
- InvalidClientMetadataException: () => InvalidClientMetadataException,
37
- InvalidGrantException: () => InvalidGrantException,
38
- InvalidRedirectUriException: () => InvalidRedirectUriException,
39
- InvalidRequestException: () => InvalidRequestException,
40
- InvalidRequestExceptionReason: () => InvalidRequestExceptionReason,
41
- InvalidRequestRegionException: () => InvalidRequestRegionException,
42
- InvalidScopeException: () => InvalidScopeException,
43
- RegisterClientCommand: () => RegisterClientCommand,
44
- RegisterClientResponseFilterSensitiveLog: () => RegisterClientResponseFilterSensitiveLog,
45
- SSOOIDC: () => SSOOIDC,
46
- SSOOIDCClient: () => SSOOIDCClient,
47
- SSOOIDCServiceException: () => SSOOIDCServiceException,
48
- SlowDownException: () => SlowDownException,
49
- StartDeviceAuthorizationCommand: () => StartDeviceAuthorizationCommand,
50
- StartDeviceAuthorizationRequestFilterSensitiveLog: () => StartDeviceAuthorizationRequestFilterSensitiveLog,
51
- UnauthorizedClientException: () => UnauthorizedClientException,
52
- UnsupportedGrantTypeException: () => UnsupportedGrantTypeException,
53
- __Client: () => import_smithy_client.Client
54
- });
55
- module.exports = __toCommonJS(index_exports);
56
33
 
57
- // src/SSOOIDCClient.ts
58
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
59
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
60
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
61
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
62
- var import_config_resolver = require("@smithy/config-resolver");
63
- var import_core = require("@smithy/core");
64
- var import_middleware_content_length = require("@smithy/middleware-content-length");
65
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
66
- var import_middleware_retry = require("@smithy/middleware-retry");
67
-
68
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
69
-
70
- // src/endpoint/EndpointParameters.ts
71
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
72
- return Object.assign(options, {
73
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
74
- useFipsEndpoint: options.useFipsEndpoint ?? false,
75
- defaultSigningName: "sso-oauth"
76
- });
77
- }, "resolveClientEndpointParameters");
78
- var commonParams = {
79
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
80
- Endpoint: { type: "builtInParams", name: "endpoint" },
81
- Region: { type: "builtInParams", name: "region" },
82
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
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
+ };
83
71
  };
84
72
 
85
- // src/SSOOIDCClient.ts
86
- var import_runtimeConfig = require("././runtimeConfig");
87
-
88
- // src/runtimeExtensions.ts
89
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
90
- var import_protocol_http = require("@smithy/protocol-http");
91
- 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
+ };
92
78
 
93
- // src/auth/httpAuthExtensionConfiguration.ts
94
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
95
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
96
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
97
- let _credentials = runtimeConfig.credentials;
98
- return {
99
- setHttpAuthScheme(httpAuthScheme) {
100
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
101
- if (index === -1) {
102
- _httpAuthSchemes.push(httpAuthScheme);
103
- } else {
104
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
105
- }
106
- },
107
- httpAuthSchemes() {
108
- return _httpAuthSchemes;
109
- },
110
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
111
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
112
- },
113
- httpAuthSchemeProvider() {
114
- return _httpAuthSchemeProvider;
115
- },
116
- setCredentials(credentials) {
117
- _credentials = credentials;
118
- },
119
- credentials() {
120
- return _credentials;
79
+ class SSOOIDCClient 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.getRetryPlugin(this.config));
96
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
97
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
98
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
99
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
100
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
101
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultSSOOIDCHttpAuthSchemeParametersProvider,
102
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
103
+ "aws.auth#sigv4": config.credentials,
104
+ }),
105
+ }));
106
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
107
+ }
108
+ destroy() {
109
+ super.destroy();
121
110
  }
122
- };
123
- }, "getHttpAuthExtensionConfiguration");
124
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
125
- return {
126
- httpAuthSchemes: config.httpAuthSchemes(),
127
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
128
- credentials: config.credentials()
129
- };
130
- }, "resolveHttpAuthRuntimeConfig");
111
+ }
131
112
 
132
- // src/runtimeExtensions.ts
133
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
134
- const extensionConfiguration = Object.assign(
135
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
136
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
137
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
138
- getHttpAuthExtensionConfiguration(runtimeConfig)
139
- );
140
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
141
- return Object.assign(
142
- runtimeConfig,
143
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
144
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
145
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
146
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
147
- );
148
- }, "resolveRuntimeExtensions");
113
+ class SSOOIDCServiceException extends smithyClient.ServiceException {
114
+ constructor(options) {
115
+ super(options);
116
+ Object.setPrototypeOf(this, SSOOIDCServiceException.prototype);
117
+ }
118
+ }
149
119
 
150
- // src/SSOOIDCClient.ts
151
- var SSOOIDCClient = class extends import_smithy_client.Client {
152
- static {
153
- __name(this, "SSOOIDCClient");
154
- }
155
- /**
156
- * The resolved configuration of SSOOIDCClient class. This is resolved and normalized from the {@link SSOOIDCClientConfig | constructor configuration interface}.
157
- */
158
- config;
159
- constructor(...[configuration]) {
160
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
161
- super(_config_0);
162
- this.initConfig = _config_0;
163
- const _config_1 = resolveClientEndpointParameters(_config_0);
164
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
165
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
166
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
167
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
168
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
169
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
170
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
171
- this.config = _config_8;
172
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
173
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
174
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
175
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
176
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
177
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
178
- this.middlewareStack.use(
179
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
180
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultSSOOIDCHttpAuthSchemeParametersProvider,
181
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
182
- "aws.auth#sigv4": config.credentials
183
- }), "identityProviderConfigProvider")
184
- })
185
- );
186
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
187
- }
188
- /**
189
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
190
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
191
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
192
- */
193
- destroy() {
194
- super.destroy();
195
- }
120
+ const AccessDeniedExceptionReason = {
121
+ KMS_ACCESS_DENIED: "KMS_AccessDeniedException",
196
122
  };
197
-
198
- // src/SSOOIDC.ts
199
-
200
-
201
- // src/commands/CreateTokenCommand.ts
202
-
203
- var import_middleware_serde = require("@smithy/middleware-serde");
204
-
205
-
206
- // src/models/models_0.ts
207
-
208
-
209
- // src/models/SSOOIDCServiceException.ts
210
-
211
- var SSOOIDCServiceException = class _SSOOIDCServiceException extends import_smithy_client.ServiceException {
212
- static {
213
- __name(this, "SSOOIDCServiceException");
214
- }
215
- /**
216
- * @internal
217
- */
218
- constructor(options) {
219
- super(options);
220
- Object.setPrototypeOf(this, _SSOOIDCServiceException.prototype);
221
- }
123
+ class AccessDeniedException extends SSOOIDCServiceException {
124
+ name = "AccessDeniedException";
125
+ $fault = "client";
126
+ error;
127
+ reason;
128
+ error_description;
129
+ constructor(opts) {
130
+ super({
131
+ name: "AccessDeniedException",
132
+ $fault: "client",
133
+ ...opts,
134
+ });
135
+ Object.setPrototypeOf(this, AccessDeniedException.prototype);
136
+ this.error = opts.error;
137
+ this.reason = opts.reason;
138
+ this.error_description = opts.error_description;
139
+ }
140
+ }
141
+ class AuthorizationPendingException extends SSOOIDCServiceException {
142
+ name = "AuthorizationPendingException";
143
+ $fault = "client";
144
+ error;
145
+ error_description;
146
+ constructor(opts) {
147
+ super({
148
+ name: "AuthorizationPendingException",
149
+ $fault: "client",
150
+ ...opts,
151
+ });
152
+ Object.setPrototypeOf(this, AuthorizationPendingException.prototype);
153
+ this.error = opts.error;
154
+ this.error_description = opts.error_description;
155
+ }
156
+ }
157
+ class ExpiredTokenException extends SSOOIDCServiceException {
158
+ name = "ExpiredTokenException";
159
+ $fault = "client";
160
+ error;
161
+ error_description;
162
+ constructor(opts) {
163
+ super({
164
+ name: "ExpiredTokenException",
165
+ $fault: "client",
166
+ ...opts,
167
+ });
168
+ Object.setPrototypeOf(this, ExpiredTokenException.prototype);
169
+ this.error = opts.error;
170
+ this.error_description = opts.error_description;
171
+ }
172
+ }
173
+ class InternalServerException extends SSOOIDCServiceException {
174
+ name = "InternalServerException";
175
+ $fault = "server";
176
+ error;
177
+ error_description;
178
+ constructor(opts) {
179
+ super({
180
+ name: "InternalServerException",
181
+ $fault: "server",
182
+ ...opts,
183
+ });
184
+ Object.setPrototypeOf(this, InternalServerException.prototype);
185
+ this.error = opts.error;
186
+ this.error_description = opts.error_description;
187
+ }
188
+ }
189
+ class InvalidClientException extends SSOOIDCServiceException {
190
+ name = "InvalidClientException";
191
+ $fault = "client";
192
+ error;
193
+ error_description;
194
+ constructor(opts) {
195
+ super({
196
+ name: "InvalidClientException",
197
+ $fault: "client",
198
+ ...opts,
199
+ });
200
+ Object.setPrototypeOf(this, InvalidClientException.prototype);
201
+ this.error = opts.error;
202
+ this.error_description = opts.error_description;
203
+ }
204
+ }
205
+ class InvalidGrantException extends SSOOIDCServiceException {
206
+ name = "InvalidGrantException";
207
+ $fault = "client";
208
+ error;
209
+ error_description;
210
+ constructor(opts) {
211
+ super({
212
+ name: "InvalidGrantException",
213
+ $fault: "client",
214
+ ...opts,
215
+ });
216
+ Object.setPrototypeOf(this, InvalidGrantException.prototype);
217
+ this.error = opts.error;
218
+ this.error_description = opts.error_description;
219
+ }
220
+ }
221
+ const InvalidRequestExceptionReason = {
222
+ KMS_DISABLED_KEY: "KMS_DisabledException",
223
+ KMS_INVALID_KEY_USAGE: "KMS_InvalidKeyUsageException",
224
+ KMS_INVALID_STATE: "KMS_InvalidStateException",
225
+ KMS_KEY_NOT_FOUND: "KMS_NotFoundException",
222
226
  };
227
+ class InvalidRequestException extends SSOOIDCServiceException {
228
+ name = "InvalidRequestException";
229
+ $fault = "client";
230
+ error;
231
+ reason;
232
+ error_description;
233
+ constructor(opts) {
234
+ super({
235
+ name: "InvalidRequestException",
236
+ $fault: "client",
237
+ ...opts,
238
+ });
239
+ Object.setPrototypeOf(this, InvalidRequestException.prototype);
240
+ this.error = opts.error;
241
+ this.reason = opts.reason;
242
+ this.error_description = opts.error_description;
243
+ }
244
+ }
245
+ class InvalidScopeException extends SSOOIDCServiceException {
246
+ name = "InvalidScopeException";
247
+ $fault = "client";
248
+ error;
249
+ error_description;
250
+ constructor(opts) {
251
+ super({
252
+ name: "InvalidScopeException",
253
+ $fault: "client",
254
+ ...opts,
255
+ });
256
+ Object.setPrototypeOf(this, InvalidScopeException.prototype);
257
+ this.error = opts.error;
258
+ this.error_description = opts.error_description;
259
+ }
260
+ }
261
+ class SlowDownException extends SSOOIDCServiceException {
262
+ name = "SlowDownException";
263
+ $fault = "client";
264
+ error;
265
+ error_description;
266
+ constructor(opts) {
267
+ super({
268
+ name: "SlowDownException",
269
+ $fault: "client",
270
+ ...opts,
271
+ });
272
+ Object.setPrototypeOf(this, SlowDownException.prototype);
273
+ this.error = opts.error;
274
+ this.error_description = opts.error_description;
275
+ }
276
+ }
277
+ class UnauthorizedClientException extends SSOOIDCServiceException {
278
+ name = "UnauthorizedClientException";
279
+ $fault = "client";
280
+ error;
281
+ error_description;
282
+ constructor(opts) {
283
+ super({
284
+ name: "UnauthorizedClientException",
285
+ $fault: "client",
286
+ ...opts,
287
+ });
288
+ Object.setPrototypeOf(this, UnauthorizedClientException.prototype);
289
+ this.error = opts.error;
290
+ this.error_description = opts.error_description;
291
+ }
292
+ }
293
+ class UnsupportedGrantTypeException extends SSOOIDCServiceException {
294
+ name = "UnsupportedGrantTypeException";
295
+ $fault = "client";
296
+ error;
297
+ error_description;
298
+ constructor(opts) {
299
+ super({
300
+ name: "UnsupportedGrantTypeException",
301
+ $fault: "client",
302
+ ...opts,
303
+ });
304
+ Object.setPrototypeOf(this, UnsupportedGrantTypeException.prototype);
305
+ this.error = opts.error;
306
+ this.error_description = opts.error_description;
307
+ }
308
+ }
309
+ class InvalidRequestRegionException extends SSOOIDCServiceException {
310
+ name = "InvalidRequestRegionException";
311
+ $fault = "client";
312
+ error;
313
+ error_description;
314
+ endpoint;
315
+ region;
316
+ constructor(opts) {
317
+ super({
318
+ name: "InvalidRequestRegionException",
319
+ $fault: "client",
320
+ ...opts,
321
+ });
322
+ Object.setPrototypeOf(this, InvalidRequestRegionException.prototype);
323
+ this.error = opts.error;
324
+ this.error_description = opts.error_description;
325
+ this.endpoint = opts.endpoint;
326
+ this.region = opts.region;
327
+ }
328
+ }
329
+ class InvalidClientMetadataException extends SSOOIDCServiceException {
330
+ name = "InvalidClientMetadataException";
331
+ $fault = "client";
332
+ error;
333
+ error_description;
334
+ constructor(opts) {
335
+ super({
336
+ name: "InvalidClientMetadataException",
337
+ $fault: "client",
338
+ ...opts,
339
+ });
340
+ Object.setPrototypeOf(this, InvalidClientMetadataException.prototype);
341
+ this.error = opts.error;
342
+ this.error_description = opts.error_description;
343
+ }
344
+ }
345
+ class InvalidRedirectUriException extends SSOOIDCServiceException {
346
+ name = "InvalidRedirectUriException";
347
+ $fault = "client";
348
+ error;
349
+ error_description;
350
+ constructor(opts) {
351
+ super({
352
+ name: "InvalidRedirectUriException",
353
+ $fault: "client",
354
+ ...opts,
355
+ });
356
+ Object.setPrototypeOf(this, InvalidRedirectUriException.prototype);
357
+ this.error = opts.error;
358
+ this.error_description = opts.error_description;
359
+ }
360
+ }
361
+ const CreateTokenRequestFilterSensitiveLog = (obj) => ({
362
+ ...obj,
363
+ ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
364
+ ...(obj.refreshToken && { refreshToken: smithyClient.SENSITIVE_STRING }),
365
+ ...(obj.codeVerifier && { codeVerifier: smithyClient.SENSITIVE_STRING }),
366
+ });
367
+ const CreateTokenResponseFilterSensitiveLog = (obj) => ({
368
+ ...obj,
369
+ ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
370
+ ...(obj.refreshToken && { refreshToken: smithyClient.SENSITIVE_STRING }),
371
+ ...(obj.idToken && { idToken: smithyClient.SENSITIVE_STRING }),
372
+ });
373
+ const CreateTokenWithIAMRequestFilterSensitiveLog = (obj) => ({
374
+ ...obj,
375
+ ...(obj.refreshToken && { refreshToken: smithyClient.SENSITIVE_STRING }),
376
+ ...(obj.assertion && { assertion: smithyClient.SENSITIVE_STRING }),
377
+ ...(obj.subjectToken && { subjectToken: smithyClient.SENSITIVE_STRING }),
378
+ ...(obj.codeVerifier && { codeVerifier: smithyClient.SENSITIVE_STRING }),
379
+ });
380
+ const CreateTokenWithIAMResponseFilterSensitiveLog = (obj) => ({
381
+ ...obj,
382
+ ...(obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }),
383
+ ...(obj.refreshToken && { refreshToken: smithyClient.SENSITIVE_STRING }),
384
+ ...(obj.idToken && { idToken: smithyClient.SENSITIVE_STRING }),
385
+ });
386
+ const RegisterClientResponseFilterSensitiveLog = (obj) => ({
387
+ ...obj,
388
+ ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
389
+ });
390
+ const StartDeviceAuthorizationRequestFilterSensitiveLog = (obj) => ({
391
+ ...obj,
392
+ ...(obj.clientSecret && { clientSecret: smithyClient.SENSITIVE_STRING }),
393
+ });
223
394
 
224
- // src/models/models_0.ts
225
- var AccessDeniedExceptionReason = {
226
- KMS_ACCESS_DENIED: "KMS_AccessDeniedException"
395
+ const se_CreateTokenCommand = async (input, context) => {
396
+ const b = core.requestBuilder(input, context);
397
+ const headers = {
398
+ "content-type": "application/json",
399
+ };
400
+ b.bp("/token");
401
+ let body;
402
+ body = JSON.stringify(smithyClient.take(input, {
403
+ clientId: [],
404
+ clientSecret: [],
405
+ code: [],
406
+ codeVerifier: [],
407
+ deviceCode: [],
408
+ grantType: [],
409
+ redirectUri: [],
410
+ refreshToken: [],
411
+ scope: (_) => smithyClient._json(_),
412
+ }));
413
+ b.m("POST").h(headers).b(body);
414
+ return b.build();
227
415
  };
228
- var AccessDeniedException = class _AccessDeniedException extends SSOOIDCServiceException {
229
- static {
230
- __name(this, "AccessDeniedException");
231
- }
232
- name = "AccessDeniedException";
233
- $fault = "client";
234
- /**
235
- * <p>Single error code. For this exception the value will be <code>access_denied</code>.</p>
236
- * @public
237
- */
238
- error;
239
- /**
240
- * <p>A string that uniquely identifies a reason for the error.</p>
241
- * @public
242
- */
243
- reason;
244
- /**
245
- * <p>Human-readable text providing additional information, used to assist the client developer
246
- * in understanding the error that occurred.</p>
247
- * @public
248
- */
249
- error_description;
250
- /**
251
- * @internal
252
- */
253
- constructor(opts) {
254
- super({
255
- name: "AccessDeniedException",
256
- $fault: "client",
257
- ...opts
416
+ const se_CreateTokenWithIAMCommand = async (input, context) => {
417
+ const b = core.requestBuilder(input, context);
418
+ const headers = {
419
+ "content-type": "application/json",
420
+ };
421
+ b.bp("/token");
422
+ const query = smithyClient.map({
423
+ [_ai]: [, "t"],
258
424
  });
259
- Object.setPrototypeOf(this, _AccessDeniedException.prototype);
260
- this.error = opts.error;
261
- this.reason = opts.reason;
262
- this.error_description = opts.error_description;
263
- }
425
+ let body;
426
+ body = JSON.stringify(smithyClient.take(input, {
427
+ assertion: [],
428
+ clientId: [],
429
+ code: [],
430
+ codeVerifier: [],
431
+ grantType: [],
432
+ redirectUri: [],
433
+ refreshToken: [],
434
+ requestedTokenType: [],
435
+ scope: (_) => smithyClient._json(_),
436
+ subjectToken: [],
437
+ subjectTokenType: [],
438
+ }));
439
+ b.m("POST").h(headers).q(query).b(body);
440
+ return b.build();
264
441
  };
265
- var AuthorizationPendingException = class _AuthorizationPendingException extends SSOOIDCServiceException {
266
- static {
267
- __name(this, "AuthorizationPendingException");
268
- }
269
- name = "AuthorizationPendingException";
270
- $fault = "client";
271
- /**
272
- * <p>Single error code. For this exception the value will be
273
- * <code>authorization_pending</code>.</p>
274
- * @public
275
- */
276
- error;
277
- /**
278
- * <p>Human-readable text providing additional information, used to assist the client developer
279
- * in understanding the error that occurred.</p>
280
- * @public
281
- */
282
- error_description;
283
- /**
284
- * @internal
285
- */
286
- constructor(opts) {
287
- super({
288
- name: "AuthorizationPendingException",
289
- $fault: "client",
290
- ...opts
291
- });
292
- Object.setPrototypeOf(this, _AuthorizationPendingException.prototype);
293
- this.error = opts.error;
294
- this.error_description = opts.error_description;
295
- }
442
+ const se_RegisterClientCommand = async (input, context) => {
443
+ const b = core.requestBuilder(input, context);
444
+ const headers = {
445
+ "content-type": "application/json",
446
+ };
447
+ b.bp("/client/register");
448
+ let body;
449
+ body = JSON.stringify(smithyClient.take(input, {
450
+ clientName: [],
451
+ clientType: [],
452
+ entitledApplicationArn: [],
453
+ grantTypes: (_) => smithyClient._json(_),
454
+ issuerUrl: [],
455
+ redirectUris: (_) => smithyClient._json(_),
456
+ scopes: (_) => smithyClient._json(_),
457
+ }));
458
+ b.m("POST").h(headers).b(body);
459
+ return b.build();
460
+ };
461
+ const se_StartDeviceAuthorizationCommand = async (input, context) => {
462
+ const b = core.requestBuilder(input, context);
463
+ const headers = {
464
+ "content-type": "application/json",
465
+ };
466
+ b.bp("/device_authorization");
467
+ let body;
468
+ body = JSON.stringify(smithyClient.take(input, {
469
+ clientId: [],
470
+ clientSecret: [],
471
+ startUrl: [],
472
+ }));
473
+ b.m("POST").h(headers).b(body);
474
+ return b.build();
296
475
  };
297
- var ExpiredTokenException = class _ExpiredTokenException extends SSOOIDCServiceException {
298
- static {
299
- __name(this, "ExpiredTokenException");
300
- }
301
- name = "ExpiredTokenException";
302
- $fault = "client";
303
- /**
304
- * <p>Single error code. For this exception the value will be <code>expired_token</code>.</p>
305
- * @public
306
- */
307
- error;
308
- /**
309
- * <p>Human-readable text providing additional information, used to assist the client developer
310
- * in understanding the error that occurred.</p>
311
- * @public
312
- */
313
- error_description;
314
- /**
315
- * @internal
316
- */
317
- constructor(opts) {
318
- super({
319
- name: "ExpiredTokenException",
320
- $fault: "client",
321
- ...opts
476
+ const de_CreateTokenCommand = async (output, context) => {
477
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
478
+ return de_CommandError(output, context);
479
+ }
480
+ const contents = smithyClient.map({
481
+ $metadata: deserializeMetadata(output),
482
+ });
483
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
484
+ const doc = smithyClient.take(data, {
485
+ accessToken: smithyClient.expectString,
486
+ expiresIn: smithyClient.expectInt32,
487
+ idToken: smithyClient.expectString,
488
+ refreshToken: smithyClient.expectString,
489
+ tokenType: smithyClient.expectString,
322
490
  });
323
- Object.setPrototypeOf(this, _ExpiredTokenException.prototype);
324
- this.error = opts.error;
325
- this.error_description = opts.error_description;
326
- }
491
+ Object.assign(contents, doc);
492
+ return contents;
327
493
  };
328
- var InternalServerException = class _InternalServerException extends SSOOIDCServiceException {
329
- static {
330
- __name(this, "InternalServerException");
331
- }
332
- name = "InternalServerException";
333
- $fault = "server";
334
- /**
335
- * <p>Single error code. For this exception the value will be <code>server_error</code>.</p>
336
- * @public
337
- */
338
- error;
339
- /**
340
- * <p>Human-readable text providing additional information, used to assist the client developer
341
- * in understanding the error that occurred.</p>
342
- * @public
343
- */
344
- error_description;
345
- /**
346
- * @internal
347
- */
348
- constructor(opts) {
349
- super({
350
- name: "InternalServerException",
351
- $fault: "server",
352
- ...opts
494
+ const de_CreateTokenWithIAMCommand = async (output, context) => {
495
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
496
+ return de_CommandError(output, context);
497
+ }
498
+ const contents = smithyClient.map({
499
+ $metadata: deserializeMetadata(output),
353
500
  });
354
- Object.setPrototypeOf(this, _InternalServerException.prototype);
355
- this.error = opts.error;
356
- this.error_description = opts.error_description;
357
- }
501
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
502
+ const doc = smithyClient.take(data, {
503
+ accessToken: smithyClient.expectString,
504
+ awsAdditionalDetails: smithyClient._json,
505
+ expiresIn: smithyClient.expectInt32,
506
+ idToken: smithyClient.expectString,
507
+ issuedTokenType: smithyClient.expectString,
508
+ refreshToken: smithyClient.expectString,
509
+ scope: smithyClient._json,
510
+ tokenType: smithyClient.expectString,
511
+ });
512
+ Object.assign(contents, doc);
513
+ return contents;
358
514
  };
359
- var InvalidClientException = class _InvalidClientException extends SSOOIDCServiceException {
360
- static {
361
- __name(this, "InvalidClientException");
362
- }
363
- name = "InvalidClientException";
364
- $fault = "client";
365
- /**
366
- * <p>Single error code. For this exception the value will be
367
- * <code>invalid_client</code>.</p>
368
- * @public
369
- */
370
- error;
371
- /**
372
- * <p>Human-readable text providing additional information, used to assist the client developer
373
- * in understanding the error that occurred.</p>
374
- * @public
375
- */
376
- error_description;
377
- /**
378
- * @internal
379
- */
380
- constructor(opts) {
381
- super({
382
- name: "InvalidClientException",
383
- $fault: "client",
384
- ...opts
515
+ const de_RegisterClientCommand = async (output, context) => {
516
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
517
+ return de_CommandError(output, context);
518
+ }
519
+ const contents = smithyClient.map({
520
+ $metadata: deserializeMetadata(output),
385
521
  });
386
- Object.setPrototypeOf(this, _InvalidClientException.prototype);
387
- this.error = opts.error;
388
- this.error_description = opts.error_description;
389
- }
522
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
523
+ const doc = smithyClient.take(data, {
524
+ authorizationEndpoint: smithyClient.expectString,
525
+ clientId: smithyClient.expectString,
526
+ clientIdIssuedAt: smithyClient.expectLong,
527
+ clientSecret: smithyClient.expectString,
528
+ clientSecretExpiresAt: smithyClient.expectLong,
529
+ tokenEndpoint: smithyClient.expectString,
530
+ });
531
+ Object.assign(contents, doc);
532
+ return contents;
390
533
  };
391
- var InvalidGrantException = class _InvalidGrantException extends SSOOIDCServiceException {
392
- static {
393
- __name(this, "InvalidGrantException");
394
- }
395
- name = "InvalidGrantException";
396
- $fault = "client";
397
- /**
398
- * <p>Single error code. For this exception the value will be <code>invalid_grant</code>.</p>
399
- * @public
400
- */
401
- error;
402
- /**
403
- * <p>Human-readable text providing additional information, used to assist the client developer
404
- * in understanding the error that occurred.</p>
405
- * @public
406
- */
407
- error_description;
408
- /**
409
- * @internal
410
- */
411
- constructor(opts) {
412
- super({
413
- name: "InvalidGrantException",
414
- $fault: "client",
415
- ...opts
534
+ const de_StartDeviceAuthorizationCommand = async (output, context) => {
535
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
536
+ return de_CommandError(output, context);
537
+ }
538
+ const contents = smithyClient.map({
539
+ $metadata: deserializeMetadata(output),
540
+ });
541
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
542
+ const doc = smithyClient.take(data, {
543
+ deviceCode: smithyClient.expectString,
544
+ expiresIn: smithyClient.expectInt32,
545
+ interval: smithyClient.expectInt32,
546
+ userCode: smithyClient.expectString,
547
+ verificationUri: smithyClient.expectString,
548
+ verificationUriComplete: smithyClient.expectString,
416
549
  });
417
- Object.setPrototypeOf(this, _InvalidGrantException.prototype);
418
- this.error = opts.error;
419
- this.error_description = opts.error_description;
420
- }
550
+ Object.assign(contents, doc);
551
+ return contents;
421
552
  };
422
- var InvalidRequestExceptionReason = {
423
- KMS_DISABLED_KEY: "KMS_DisabledException",
424
- KMS_INVALID_KEY_USAGE: "KMS_InvalidKeyUsageException",
425
- KMS_INVALID_STATE: "KMS_InvalidStateException",
426
- KMS_KEY_NOT_FOUND: "KMS_NotFoundException"
553
+ const de_CommandError = async (output, context) => {
554
+ const parsedOutput = {
555
+ ...output,
556
+ body: await core$1.parseJsonErrorBody(output.body, context),
557
+ };
558
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
559
+ switch (errorCode) {
560
+ case "AccessDeniedException":
561
+ case "com.amazonaws.ssooidc#AccessDeniedException":
562
+ throw await de_AccessDeniedExceptionRes(parsedOutput);
563
+ case "AuthorizationPendingException":
564
+ case "com.amazonaws.ssooidc#AuthorizationPendingException":
565
+ throw await de_AuthorizationPendingExceptionRes(parsedOutput);
566
+ case "ExpiredTokenException":
567
+ case "com.amazonaws.ssooidc#ExpiredTokenException":
568
+ throw await de_ExpiredTokenExceptionRes(parsedOutput);
569
+ case "InternalServerException":
570
+ case "com.amazonaws.ssooidc#InternalServerException":
571
+ throw await de_InternalServerExceptionRes(parsedOutput);
572
+ case "InvalidClientException":
573
+ case "com.amazonaws.ssooidc#InvalidClientException":
574
+ throw await de_InvalidClientExceptionRes(parsedOutput);
575
+ case "InvalidGrantException":
576
+ case "com.amazonaws.ssooidc#InvalidGrantException":
577
+ throw await de_InvalidGrantExceptionRes(parsedOutput);
578
+ case "InvalidRequestException":
579
+ case "com.amazonaws.ssooidc#InvalidRequestException":
580
+ throw await de_InvalidRequestExceptionRes(parsedOutput);
581
+ case "InvalidScopeException":
582
+ case "com.amazonaws.ssooidc#InvalidScopeException":
583
+ throw await de_InvalidScopeExceptionRes(parsedOutput);
584
+ case "SlowDownException":
585
+ case "com.amazonaws.ssooidc#SlowDownException":
586
+ throw await de_SlowDownExceptionRes(parsedOutput);
587
+ case "UnauthorizedClientException":
588
+ case "com.amazonaws.ssooidc#UnauthorizedClientException":
589
+ throw await de_UnauthorizedClientExceptionRes(parsedOutput);
590
+ case "UnsupportedGrantTypeException":
591
+ case "com.amazonaws.ssooidc#UnsupportedGrantTypeException":
592
+ throw await de_UnsupportedGrantTypeExceptionRes(parsedOutput);
593
+ case "InvalidRequestRegionException":
594
+ case "com.amazonaws.ssooidc#InvalidRequestRegionException":
595
+ throw await de_InvalidRequestRegionExceptionRes(parsedOutput);
596
+ case "InvalidClientMetadataException":
597
+ case "com.amazonaws.ssooidc#InvalidClientMetadataException":
598
+ throw await de_InvalidClientMetadataExceptionRes(parsedOutput);
599
+ case "InvalidRedirectUriException":
600
+ case "com.amazonaws.ssooidc#InvalidRedirectUriException":
601
+ throw await de_InvalidRedirectUriExceptionRes(parsedOutput);
602
+ default:
603
+ const parsedBody = parsedOutput.body;
604
+ return throwDefaultError({
605
+ output,
606
+ parsedBody,
607
+ errorCode,
608
+ });
609
+ }
427
610
  };
428
- var InvalidRequestException = class _InvalidRequestException extends SSOOIDCServiceException {
429
- static {
430
- __name(this, "InvalidRequestException");
431
- }
432
- name = "InvalidRequestException";
433
- $fault = "client";
434
- /**
435
- * <p>Single error code. For this exception the value will be
436
- * <code>invalid_request</code>.</p>
437
- * @public
438
- */
439
- error;
440
- /**
441
- * <p>A string that uniquely identifies a reason for the error.</p>
442
- * @public
443
- */
444
- reason;
445
- /**
446
- * <p>Human-readable text providing additional information, used to assist the client developer
447
- * in understanding the error that occurred.</p>
448
- * @public
449
- */
450
- error_description;
451
- /**
452
- * @internal
453
- */
454
- constructor(opts) {
455
- super({
456
- name: "InvalidRequestException",
457
- $fault: "client",
458
- ...opts
611
+ const throwDefaultError = smithyClient.withBaseException(SSOOIDCServiceException);
612
+ const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
613
+ const contents = smithyClient.map({});
614
+ const data = parsedOutput.body;
615
+ const doc = smithyClient.take(data, {
616
+ error: smithyClient.expectString,
617
+ error_description: smithyClient.expectString,
618
+ reason: smithyClient.expectString,
619
+ });
620
+ Object.assign(contents, doc);
621
+ const exception = new AccessDeniedException({
622
+ $metadata: deserializeMetadata(parsedOutput),
623
+ ...contents,
459
624
  });
460
- Object.setPrototypeOf(this, _InvalidRequestException.prototype);
461
- this.error = opts.error;
462
- this.reason = opts.reason;
463
- this.error_description = opts.error_description;
464
- }
625
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
465
626
  };
466
- var InvalidScopeException = class _InvalidScopeException extends SSOOIDCServiceException {
467
- static {
468
- __name(this, "InvalidScopeException");
469
- }
470
- name = "InvalidScopeException";
471
- $fault = "client";
472
- /**
473
- * <p>Single error code. For this exception the value will be <code>invalid_scope</code>.</p>
474
- * @public
475
- */
476
- error;
477
- /**
478
- * <p>Human-readable text providing additional information, used to assist the client developer
479
- * in understanding the error that occurred.</p>
480
- * @public
481
- */
482
- error_description;
483
- /**
484
- * @internal
485
- */
486
- constructor(opts) {
487
- super({
488
- name: "InvalidScopeException",
489
- $fault: "client",
490
- ...opts
627
+ const de_AuthorizationPendingExceptionRes = async (parsedOutput, context) => {
628
+ const contents = smithyClient.map({});
629
+ const data = parsedOutput.body;
630
+ const doc = smithyClient.take(data, {
631
+ error: smithyClient.expectString,
632
+ error_description: smithyClient.expectString,
633
+ });
634
+ Object.assign(contents, doc);
635
+ const exception = new AuthorizationPendingException({
636
+ $metadata: deserializeMetadata(parsedOutput),
637
+ ...contents,
491
638
  });
492
- Object.setPrototypeOf(this, _InvalidScopeException.prototype);
493
- this.error = opts.error;
494
- this.error_description = opts.error_description;
495
- }
639
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
496
640
  };
497
- var SlowDownException = class _SlowDownException extends SSOOIDCServiceException {
498
- static {
499
- __name(this, "SlowDownException");
500
- }
501
- name = "SlowDownException";
502
- $fault = "client";
503
- /**
504
- * <p>Single error code. For this exception the value will be <code>slow_down</code>.</p>
505
- * @public
506
- */
507
- error;
508
- /**
509
- * <p>Human-readable text providing additional information, used to assist the client developer
510
- * in understanding the error that occurred.</p>
511
- * @public
512
- */
513
- error_description;
514
- /**
515
- * @internal
516
- */
517
- constructor(opts) {
518
- super({
519
- name: "SlowDownException",
520
- $fault: "client",
521
- ...opts
641
+ const de_ExpiredTokenExceptionRes = async (parsedOutput, context) => {
642
+ const contents = smithyClient.map({});
643
+ const data = parsedOutput.body;
644
+ const doc = smithyClient.take(data, {
645
+ error: smithyClient.expectString,
646
+ error_description: smithyClient.expectString,
522
647
  });
523
- Object.setPrototypeOf(this, _SlowDownException.prototype);
524
- this.error = opts.error;
525
- this.error_description = opts.error_description;
526
- }
648
+ Object.assign(contents, doc);
649
+ const exception = new ExpiredTokenException({
650
+ $metadata: deserializeMetadata(parsedOutput),
651
+ ...contents,
652
+ });
653
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
527
654
  };
528
- var UnauthorizedClientException = class _UnauthorizedClientException extends SSOOIDCServiceException {
529
- static {
530
- __name(this, "UnauthorizedClientException");
531
- }
532
- name = "UnauthorizedClientException";
533
- $fault = "client";
534
- /**
535
- * <p>Single error code. For this exception the value will be
536
- * <code>unauthorized_client</code>.</p>
537
- * @public
538
- */
539
- error;
540
- /**
541
- * <p>Human-readable text providing additional information, used to assist the client developer
542
- * in understanding the error that occurred.</p>
543
- * @public
544
- */
545
- error_description;
546
- /**
547
- * @internal
548
- */
549
- constructor(opts) {
550
- super({
551
- name: "UnauthorizedClientException",
552
- $fault: "client",
553
- ...opts
655
+ const de_InternalServerExceptionRes = async (parsedOutput, context) => {
656
+ const contents = smithyClient.map({});
657
+ const data = parsedOutput.body;
658
+ const doc = smithyClient.take(data, {
659
+ error: smithyClient.expectString,
660
+ error_description: smithyClient.expectString,
661
+ });
662
+ Object.assign(contents, doc);
663
+ const exception = new InternalServerException({
664
+ $metadata: deserializeMetadata(parsedOutput),
665
+ ...contents,
554
666
  });
555
- Object.setPrototypeOf(this, _UnauthorizedClientException.prototype);
556
- this.error = opts.error;
557
- this.error_description = opts.error_description;
558
- }
667
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
559
668
  };
560
- var UnsupportedGrantTypeException = class _UnsupportedGrantTypeException extends SSOOIDCServiceException {
561
- static {
562
- __name(this, "UnsupportedGrantTypeException");
563
- }
564
- name = "UnsupportedGrantTypeException";
565
- $fault = "client";
566
- /**
567
- * <p>Single error code. For this exception the value will be
568
- * <code>unsupported_grant_type</code>.</p>
569
- * @public
570
- */
571
- error;
572
- /**
573
- * <p>Human-readable text providing additional information, used to assist the client developer
574
- * in understanding the error that occurred.</p>
575
- * @public
576
- */
577
- error_description;
578
- /**
579
- * @internal
580
- */
581
- constructor(opts) {
582
- super({
583
- name: "UnsupportedGrantTypeException",
584
- $fault: "client",
585
- ...opts
669
+ const de_InvalidClientExceptionRes = async (parsedOutput, context) => {
670
+ const contents = smithyClient.map({});
671
+ const data = parsedOutput.body;
672
+ const doc = smithyClient.take(data, {
673
+ error: smithyClient.expectString,
674
+ error_description: smithyClient.expectString,
675
+ });
676
+ Object.assign(contents, doc);
677
+ const exception = new InvalidClientException({
678
+ $metadata: deserializeMetadata(parsedOutput),
679
+ ...contents,
586
680
  });
587
- Object.setPrototypeOf(this, _UnsupportedGrantTypeException.prototype);
588
- this.error = opts.error;
589
- this.error_description = opts.error_description;
590
- }
681
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
591
682
  };
592
- var InvalidRequestRegionException = class _InvalidRequestRegionException extends SSOOIDCServiceException {
593
- static {
594
- __name(this, "InvalidRequestRegionException");
595
- }
596
- name = "InvalidRequestRegionException";
597
- $fault = "client";
598
- /**
599
- * <p>Single error code. For this exception the value will be
600
- * <code>invalid_request</code>.</p>
601
- * @public
602
- */
603
- error;
604
- /**
605
- * <p>Human-readable text providing additional information, used to assist the client developer
606
- * in understanding the error that occurred.</p>
607
- * @public
608
- */
609
- error_description;
610
- /**
611
- * <p>Indicates the IAM Identity Center endpoint which the requester may call with this token.</p>
612
- * @public
613
- */
614
- endpoint;
615
- /**
616
- * <p>Indicates the region which the requester may call with this token.</p>
617
- * @public
618
- */
619
- region;
620
- /**
621
- * @internal
622
- */
623
- constructor(opts) {
624
- super({
625
- name: "InvalidRequestRegionException",
626
- $fault: "client",
627
- ...opts
683
+ const de_InvalidClientMetadataExceptionRes = async (parsedOutput, context) => {
684
+ const contents = smithyClient.map({});
685
+ const data = parsedOutput.body;
686
+ const doc = smithyClient.take(data, {
687
+ error: smithyClient.expectString,
688
+ error_description: smithyClient.expectString,
628
689
  });
629
- Object.setPrototypeOf(this, _InvalidRequestRegionException.prototype);
630
- this.error = opts.error;
631
- this.error_description = opts.error_description;
632
- this.endpoint = opts.endpoint;
633
- this.region = opts.region;
634
- }
690
+ Object.assign(contents, doc);
691
+ const exception = new InvalidClientMetadataException({
692
+ $metadata: deserializeMetadata(parsedOutput),
693
+ ...contents,
694
+ });
695
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
635
696
  };
636
- var InvalidClientMetadataException = class _InvalidClientMetadataException extends SSOOIDCServiceException {
637
- static {
638
- __name(this, "InvalidClientMetadataException");
639
- }
640
- name = "InvalidClientMetadataException";
641
- $fault = "client";
642
- /**
643
- * <p>Single error code. For this exception the value will be
644
- * <code>invalid_client_metadata</code>.</p>
645
- * @public
646
- */
647
- error;
648
- /**
649
- * <p>Human-readable text providing additional information, used to assist the client developer
650
- * in understanding the error that occurred.</p>
651
- * @public
652
- */
653
- error_description;
654
- /**
655
- * @internal
656
- */
657
- constructor(opts) {
658
- super({
659
- name: "InvalidClientMetadataException",
660
- $fault: "client",
661
- ...opts
697
+ const de_InvalidGrantExceptionRes = async (parsedOutput, context) => {
698
+ const contents = smithyClient.map({});
699
+ const data = parsedOutput.body;
700
+ const doc = smithyClient.take(data, {
701
+ error: smithyClient.expectString,
702
+ error_description: smithyClient.expectString,
703
+ });
704
+ Object.assign(contents, doc);
705
+ const exception = new InvalidGrantException({
706
+ $metadata: deserializeMetadata(parsedOutput),
707
+ ...contents,
662
708
  });
663
- Object.setPrototypeOf(this, _InvalidClientMetadataException.prototype);
664
- this.error = opts.error;
665
- this.error_description = opts.error_description;
666
- }
709
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
667
710
  };
668
- var InvalidRedirectUriException = class _InvalidRedirectUriException extends SSOOIDCServiceException {
669
- static {
670
- __name(this, "InvalidRedirectUriException");
671
- }
672
- name = "InvalidRedirectUriException";
673
- $fault = "client";
674
- /**
675
- * <p>Single error code. For this exception the value will be
676
- * <code>invalid_redirect_uri</code>.</p>
677
- * @public
678
- */
679
- error;
680
- /**
681
- * <p>Human-readable text providing additional information, used to assist the client developer
682
- * in understanding the error that occurred.</p>
683
- * @public
684
- */
685
- error_description;
686
- /**
687
- * @internal
688
- */
689
- constructor(opts) {
690
- super({
691
- name: "InvalidRedirectUriException",
692
- $fault: "client",
693
- ...opts
711
+ const de_InvalidRedirectUriExceptionRes = async (parsedOutput, context) => {
712
+ const contents = smithyClient.map({});
713
+ const data = parsedOutput.body;
714
+ const doc = smithyClient.take(data, {
715
+ error: smithyClient.expectString,
716
+ error_description: smithyClient.expectString,
717
+ });
718
+ Object.assign(contents, doc);
719
+ const exception = new InvalidRedirectUriException({
720
+ $metadata: deserializeMetadata(parsedOutput),
721
+ ...contents,
694
722
  });
695
- Object.setPrototypeOf(this, _InvalidRedirectUriException.prototype);
696
- this.error = opts.error;
697
- this.error_description = opts.error_description;
698
- }
723
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
699
724
  };
700
- var CreateTokenRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
701
- ...obj,
702
- ...obj.clientSecret && { clientSecret: import_smithy_client.SENSITIVE_STRING },
703
- ...obj.refreshToken && { refreshToken: import_smithy_client.SENSITIVE_STRING },
704
- ...obj.codeVerifier && { codeVerifier: import_smithy_client.SENSITIVE_STRING }
705
- }), "CreateTokenRequestFilterSensitiveLog");
706
- var CreateTokenResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
707
- ...obj,
708
- ...obj.accessToken && { accessToken: import_smithy_client.SENSITIVE_STRING },
709
- ...obj.refreshToken && { refreshToken: import_smithy_client.SENSITIVE_STRING },
710
- ...obj.idToken && { idToken: import_smithy_client.SENSITIVE_STRING }
711
- }), "CreateTokenResponseFilterSensitiveLog");
712
- var CreateTokenWithIAMRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
713
- ...obj,
714
- ...obj.refreshToken && { refreshToken: import_smithy_client.SENSITIVE_STRING },
715
- ...obj.assertion && { assertion: import_smithy_client.SENSITIVE_STRING },
716
- ...obj.subjectToken && { subjectToken: import_smithy_client.SENSITIVE_STRING },
717
- ...obj.codeVerifier && { codeVerifier: import_smithy_client.SENSITIVE_STRING }
718
- }), "CreateTokenWithIAMRequestFilterSensitiveLog");
719
- var CreateTokenWithIAMResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
720
- ...obj,
721
- ...obj.accessToken && { accessToken: import_smithy_client.SENSITIVE_STRING },
722
- ...obj.refreshToken && { refreshToken: import_smithy_client.SENSITIVE_STRING },
723
- ...obj.idToken && { idToken: import_smithy_client.SENSITIVE_STRING }
724
- }), "CreateTokenWithIAMResponseFilterSensitiveLog");
725
- var RegisterClientResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
726
- ...obj,
727
- ...obj.clientSecret && { clientSecret: import_smithy_client.SENSITIVE_STRING }
728
- }), "RegisterClientResponseFilterSensitiveLog");
729
- var StartDeviceAuthorizationRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
730
- ...obj,
731
- ...obj.clientSecret && { clientSecret: import_smithy_client.SENSITIVE_STRING }
732
- }), "StartDeviceAuthorizationRequestFilterSensitiveLog");
733
-
734
- // src/protocols/Aws_restJson1.ts
735
- var import_core2 = require("@aws-sdk/core");
736
-
737
-
738
- var se_CreateTokenCommand = /* @__PURE__ */ __name(async (input, context) => {
739
- const b = (0, import_core.requestBuilder)(input, context);
740
- const headers = {
741
- "content-type": "application/json"
742
- };
743
- b.bp("/token");
744
- let body;
745
- body = JSON.stringify(
746
- (0, import_smithy_client.take)(input, {
747
- clientId: [],
748
- clientSecret: [],
749
- code: [],
750
- codeVerifier: [],
751
- deviceCode: [],
752
- grantType: [],
753
- redirectUri: [],
754
- refreshToken: [],
755
- scope: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "scope")
756
- })
757
- );
758
- b.m("POST").h(headers).b(body);
759
- return b.build();
760
- }, "se_CreateTokenCommand");
761
- var se_CreateTokenWithIAMCommand = /* @__PURE__ */ __name(async (input, context) => {
762
- const b = (0, import_core.requestBuilder)(input, context);
763
- const headers = {
764
- "content-type": "application/json"
765
- };
766
- b.bp("/token");
767
- const query = (0, import_smithy_client.map)({
768
- [_ai]: [, "t"]
769
- });
770
- let body;
771
- body = JSON.stringify(
772
- (0, import_smithy_client.take)(input, {
773
- assertion: [],
774
- clientId: [],
775
- code: [],
776
- codeVerifier: [],
777
- grantType: [],
778
- redirectUri: [],
779
- refreshToken: [],
780
- requestedTokenType: [],
781
- scope: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "scope"),
782
- subjectToken: [],
783
- subjectTokenType: []
784
- })
785
- );
786
- b.m("POST").h(headers).q(query).b(body);
787
- return b.build();
788
- }, "se_CreateTokenWithIAMCommand");
789
- var se_RegisterClientCommand = /* @__PURE__ */ __name(async (input, context) => {
790
- const b = (0, import_core.requestBuilder)(input, context);
791
- const headers = {
792
- "content-type": "application/json"
793
- };
794
- b.bp("/client/register");
795
- let body;
796
- body = JSON.stringify(
797
- (0, import_smithy_client.take)(input, {
798
- clientName: [],
799
- clientType: [],
800
- entitledApplicationArn: [],
801
- grantTypes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "grantTypes"),
802
- issuerUrl: [],
803
- redirectUris: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "redirectUris"),
804
- scopes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "scopes")
805
- })
806
- );
807
- b.m("POST").h(headers).b(body);
808
- return b.build();
809
- }, "se_RegisterClientCommand");
810
- var se_StartDeviceAuthorizationCommand = /* @__PURE__ */ __name(async (input, context) => {
811
- const b = (0, import_core.requestBuilder)(input, context);
812
- const headers = {
813
- "content-type": "application/json"
814
- };
815
- b.bp("/device_authorization");
816
- let body;
817
- body = JSON.stringify(
818
- (0, import_smithy_client.take)(input, {
819
- clientId: [],
820
- clientSecret: [],
821
- startUrl: []
822
- })
823
- );
824
- b.m("POST").h(headers).b(body);
825
- return b.build();
826
- }, "se_StartDeviceAuthorizationCommand");
827
- var de_CreateTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
828
- if (output.statusCode !== 200 && output.statusCode >= 300) {
829
- return de_CommandError(output, context);
830
- }
831
- const contents = (0, import_smithy_client.map)({
832
- $metadata: deserializeMetadata(output)
833
- });
834
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
835
- const doc = (0, import_smithy_client.take)(data, {
836
- accessToken: import_smithy_client.expectString,
837
- expiresIn: import_smithy_client.expectInt32,
838
- idToken: import_smithy_client.expectString,
839
- refreshToken: import_smithy_client.expectString,
840
- tokenType: import_smithy_client.expectString
841
- });
842
- Object.assign(contents, doc);
843
- return contents;
844
- }, "de_CreateTokenCommand");
845
- var de_CreateTokenWithIAMCommand = /* @__PURE__ */ __name(async (output, context) => {
846
- if (output.statusCode !== 200 && output.statusCode >= 300) {
847
- return de_CommandError(output, context);
848
- }
849
- const contents = (0, import_smithy_client.map)({
850
- $metadata: deserializeMetadata(output)
851
- });
852
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
853
- const doc = (0, import_smithy_client.take)(data, {
854
- accessToken: import_smithy_client.expectString,
855
- awsAdditionalDetails: import_smithy_client._json,
856
- expiresIn: import_smithy_client.expectInt32,
857
- idToken: import_smithy_client.expectString,
858
- issuedTokenType: import_smithy_client.expectString,
859
- refreshToken: import_smithy_client.expectString,
860
- scope: import_smithy_client._json,
861
- tokenType: import_smithy_client.expectString
862
- });
863
- Object.assign(contents, doc);
864
- return contents;
865
- }, "de_CreateTokenWithIAMCommand");
866
- var de_RegisterClientCommand = /* @__PURE__ */ __name(async (output, context) => {
867
- if (output.statusCode !== 200 && output.statusCode >= 300) {
868
- return de_CommandError(output, context);
869
- }
870
- const contents = (0, import_smithy_client.map)({
871
- $metadata: deserializeMetadata(output)
872
- });
873
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
874
- const doc = (0, import_smithy_client.take)(data, {
875
- authorizationEndpoint: import_smithy_client.expectString,
876
- clientId: import_smithy_client.expectString,
877
- clientIdIssuedAt: import_smithy_client.expectLong,
878
- clientSecret: import_smithy_client.expectString,
879
- clientSecretExpiresAt: import_smithy_client.expectLong,
880
- tokenEndpoint: import_smithy_client.expectString
881
- });
882
- Object.assign(contents, doc);
883
- return contents;
884
- }, "de_RegisterClientCommand");
885
- var de_StartDeviceAuthorizationCommand = /* @__PURE__ */ __name(async (output, context) => {
886
- if (output.statusCode !== 200 && output.statusCode >= 300) {
887
- return de_CommandError(output, context);
888
- }
889
- const contents = (0, import_smithy_client.map)({
890
- $metadata: deserializeMetadata(output)
891
- });
892
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
893
- const doc = (0, import_smithy_client.take)(data, {
894
- deviceCode: import_smithy_client.expectString,
895
- expiresIn: import_smithy_client.expectInt32,
896
- interval: import_smithy_client.expectInt32,
897
- userCode: import_smithy_client.expectString,
898
- verificationUri: import_smithy_client.expectString,
899
- verificationUriComplete: import_smithy_client.expectString
900
- });
901
- Object.assign(contents, doc);
902
- return contents;
903
- }, "de_StartDeviceAuthorizationCommand");
904
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
905
- const parsedOutput = {
906
- ...output,
907
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
908
- };
909
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
910
- switch (errorCode) {
911
- case "AccessDeniedException":
912
- case "com.amazonaws.ssooidc#AccessDeniedException":
913
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
914
- case "AuthorizationPendingException":
915
- case "com.amazonaws.ssooidc#AuthorizationPendingException":
916
- throw await de_AuthorizationPendingExceptionRes(parsedOutput, context);
917
- case "ExpiredTokenException":
918
- case "com.amazonaws.ssooidc#ExpiredTokenException":
919
- throw await de_ExpiredTokenExceptionRes(parsedOutput, context);
920
- case "InternalServerException":
921
- case "com.amazonaws.ssooidc#InternalServerException":
922
- throw await de_InternalServerExceptionRes(parsedOutput, context);
923
- case "InvalidClientException":
924
- case "com.amazonaws.ssooidc#InvalidClientException":
925
- throw await de_InvalidClientExceptionRes(parsedOutput, context);
926
- case "InvalidGrantException":
927
- case "com.amazonaws.ssooidc#InvalidGrantException":
928
- throw await de_InvalidGrantExceptionRes(parsedOutput, context);
929
- case "InvalidRequestException":
930
- case "com.amazonaws.ssooidc#InvalidRequestException":
931
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
932
- case "InvalidScopeException":
933
- case "com.amazonaws.ssooidc#InvalidScopeException":
934
- throw await de_InvalidScopeExceptionRes(parsedOutput, context);
935
- case "SlowDownException":
936
- case "com.amazonaws.ssooidc#SlowDownException":
937
- throw await de_SlowDownExceptionRes(parsedOutput, context);
938
- case "UnauthorizedClientException":
939
- case "com.amazonaws.ssooidc#UnauthorizedClientException":
940
- throw await de_UnauthorizedClientExceptionRes(parsedOutput, context);
941
- case "UnsupportedGrantTypeException":
942
- case "com.amazonaws.ssooidc#UnsupportedGrantTypeException":
943
- throw await de_UnsupportedGrantTypeExceptionRes(parsedOutput, context);
944
- case "InvalidRequestRegionException":
945
- case "com.amazonaws.ssooidc#InvalidRequestRegionException":
946
- throw await de_InvalidRequestRegionExceptionRes(parsedOutput, context);
947
- case "InvalidClientMetadataException":
948
- case "com.amazonaws.ssooidc#InvalidClientMetadataException":
949
- throw await de_InvalidClientMetadataExceptionRes(parsedOutput, context);
950
- case "InvalidRedirectUriException":
951
- case "com.amazonaws.ssooidc#InvalidRedirectUriException":
952
- throw await de_InvalidRedirectUriExceptionRes(parsedOutput, context);
953
- default:
954
- const parsedBody = parsedOutput.body;
955
- return throwDefaultError({
956
- output,
957
- parsedBody,
958
- errorCode
959
- });
960
- }
961
- }, "de_CommandError");
962
- var throwDefaultError = (0, import_smithy_client.withBaseException)(SSOOIDCServiceException);
963
- var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
964
- const contents = (0, import_smithy_client.map)({});
965
- const data = parsedOutput.body;
966
- const doc = (0, import_smithy_client.take)(data, {
967
- error: import_smithy_client.expectString,
968
- error_description: import_smithy_client.expectString,
969
- reason: import_smithy_client.expectString
970
- });
971
- Object.assign(contents, doc);
972
- const exception = new AccessDeniedException({
973
- $metadata: deserializeMetadata(parsedOutput),
974
- ...contents
975
- });
976
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
977
- }, "de_AccessDeniedExceptionRes");
978
- var de_AuthorizationPendingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
979
- const contents = (0, import_smithy_client.map)({});
980
- const data = parsedOutput.body;
981
- const doc = (0, import_smithy_client.take)(data, {
982
- error: import_smithy_client.expectString,
983
- error_description: import_smithy_client.expectString
984
- });
985
- Object.assign(contents, doc);
986
- const exception = new AuthorizationPendingException({
987
- $metadata: deserializeMetadata(parsedOutput),
988
- ...contents
989
- });
990
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
991
- }, "de_AuthorizationPendingExceptionRes");
992
- var de_ExpiredTokenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
993
- const contents = (0, import_smithy_client.map)({});
994
- const data = parsedOutput.body;
995
- const doc = (0, import_smithy_client.take)(data, {
996
- error: import_smithy_client.expectString,
997
- error_description: import_smithy_client.expectString
998
- });
999
- Object.assign(contents, doc);
1000
- const exception = new ExpiredTokenException({
1001
- $metadata: deserializeMetadata(parsedOutput),
1002
- ...contents
1003
- });
1004
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1005
- }, "de_ExpiredTokenExceptionRes");
1006
- var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1007
- const contents = (0, import_smithy_client.map)({});
1008
- const data = parsedOutput.body;
1009
- const doc = (0, import_smithy_client.take)(data, {
1010
- error: import_smithy_client.expectString,
1011
- error_description: import_smithy_client.expectString
1012
- });
1013
- Object.assign(contents, doc);
1014
- const exception = new InternalServerException({
1015
- $metadata: deserializeMetadata(parsedOutput),
1016
- ...contents
1017
- });
1018
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1019
- }, "de_InternalServerExceptionRes");
1020
- var de_InvalidClientExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1021
- const contents = (0, import_smithy_client.map)({});
1022
- const data = parsedOutput.body;
1023
- const doc = (0, import_smithy_client.take)(data, {
1024
- error: import_smithy_client.expectString,
1025
- error_description: import_smithy_client.expectString
1026
- });
1027
- Object.assign(contents, doc);
1028
- const exception = new InvalidClientException({
1029
- $metadata: deserializeMetadata(parsedOutput),
1030
- ...contents
1031
- });
1032
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1033
- }, "de_InvalidClientExceptionRes");
1034
- var de_InvalidClientMetadataExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1035
- const contents = (0, import_smithy_client.map)({});
1036
- const data = parsedOutput.body;
1037
- const doc = (0, import_smithy_client.take)(data, {
1038
- error: import_smithy_client.expectString,
1039
- error_description: import_smithy_client.expectString
1040
- });
1041
- Object.assign(contents, doc);
1042
- const exception = new InvalidClientMetadataException({
1043
- $metadata: deserializeMetadata(parsedOutput),
1044
- ...contents
1045
- });
1046
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1047
- }, "de_InvalidClientMetadataExceptionRes");
1048
- var de_InvalidGrantExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1049
- const contents = (0, import_smithy_client.map)({});
1050
- const data = parsedOutput.body;
1051
- const doc = (0, import_smithy_client.take)(data, {
1052
- error: import_smithy_client.expectString,
1053
- error_description: import_smithy_client.expectString
1054
- });
1055
- Object.assign(contents, doc);
1056
- const exception = new InvalidGrantException({
1057
- $metadata: deserializeMetadata(parsedOutput),
1058
- ...contents
1059
- });
1060
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1061
- }, "de_InvalidGrantExceptionRes");
1062
- var de_InvalidRedirectUriExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1063
- const contents = (0, import_smithy_client.map)({});
1064
- const data = parsedOutput.body;
1065
- const doc = (0, import_smithy_client.take)(data, {
1066
- error: import_smithy_client.expectString,
1067
- error_description: import_smithy_client.expectString
1068
- });
1069
- Object.assign(contents, doc);
1070
- const exception = new InvalidRedirectUriException({
1071
- $metadata: deserializeMetadata(parsedOutput),
1072
- ...contents
1073
- });
1074
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1075
- }, "de_InvalidRedirectUriExceptionRes");
1076
- var de_InvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1077
- const contents = (0, import_smithy_client.map)({});
1078
- const data = parsedOutput.body;
1079
- const doc = (0, import_smithy_client.take)(data, {
1080
- error: import_smithy_client.expectString,
1081
- error_description: import_smithy_client.expectString,
1082
- reason: import_smithy_client.expectString
1083
- });
1084
- Object.assign(contents, doc);
1085
- const exception = new InvalidRequestException({
1086
- $metadata: deserializeMetadata(parsedOutput),
1087
- ...contents
1088
- });
1089
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1090
- }, "de_InvalidRequestExceptionRes");
1091
- var de_InvalidRequestRegionExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1092
- const contents = (0, import_smithy_client.map)({});
1093
- const data = parsedOutput.body;
1094
- const doc = (0, import_smithy_client.take)(data, {
1095
- endpoint: import_smithy_client.expectString,
1096
- error: import_smithy_client.expectString,
1097
- error_description: import_smithy_client.expectString,
1098
- region: import_smithy_client.expectString
1099
- });
1100
- Object.assign(contents, doc);
1101
- const exception = new InvalidRequestRegionException({
1102
- $metadata: deserializeMetadata(parsedOutput),
1103
- ...contents
1104
- });
1105
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1106
- }, "de_InvalidRequestRegionExceptionRes");
1107
- var de_InvalidScopeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1108
- const contents = (0, import_smithy_client.map)({});
1109
- const data = parsedOutput.body;
1110
- const doc = (0, import_smithy_client.take)(data, {
1111
- error: import_smithy_client.expectString,
1112
- error_description: import_smithy_client.expectString
1113
- });
1114
- Object.assign(contents, doc);
1115
- const exception = new InvalidScopeException({
1116
- $metadata: deserializeMetadata(parsedOutput),
1117
- ...contents
1118
- });
1119
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1120
- }, "de_InvalidScopeExceptionRes");
1121
- var de_SlowDownExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1122
- const contents = (0, import_smithy_client.map)({});
1123
- const data = parsedOutput.body;
1124
- const doc = (0, import_smithy_client.take)(data, {
1125
- error: import_smithy_client.expectString,
1126
- error_description: import_smithy_client.expectString
1127
- });
1128
- Object.assign(contents, doc);
1129
- const exception = new SlowDownException({
1130
- $metadata: deserializeMetadata(parsedOutput),
1131
- ...contents
1132
- });
1133
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1134
- }, "de_SlowDownExceptionRes");
1135
- var de_UnauthorizedClientExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1136
- const contents = (0, import_smithy_client.map)({});
1137
- const data = parsedOutput.body;
1138
- const doc = (0, import_smithy_client.take)(data, {
1139
- error: import_smithy_client.expectString,
1140
- error_description: import_smithy_client.expectString
1141
- });
1142
- Object.assign(contents, doc);
1143
- const exception = new UnauthorizedClientException({
1144
- $metadata: deserializeMetadata(parsedOutput),
1145
- ...contents
1146
- });
1147
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1148
- }, "de_UnauthorizedClientExceptionRes");
1149
- var de_UnsupportedGrantTypeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1150
- const contents = (0, import_smithy_client.map)({});
1151
- const data = parsedOutput.body;
1152
- const doc = (0, import_smithy_client.take)(data, {
1153
- error: import_smithy_client.expectString,
1154
- error_description: import_smithy_client.expectString
1155
- });
1156
- Object.assign(contents, doc);
1157
- const exception = new UnsupportedGrantTypeException({
1158
- $metadata: deserializeMetadata(parsedOutput),
1159
- ...contents
1160
- });
1161
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1162
- }, "de_UnsupportedGrantTypeExceptionRes");
1163
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
1164
- httpStatusCode: output.statusCode,
1165
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1166
- extendedRequestId: output.headers["x-amz-id-2"],
1167
- cfId: output.headers["x-amz-cf-id"]
1168
- }), "deserializeMetadata");
1169
- var _ai = "aws_iam";
1170
-
1171
- // src/commands/CreateTokenCommand.ts
1172
- var CreateTokenCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1173
- return [
1174
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1175
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1176
- ];
1177
- }).s("AWSSSOOIDCService", "CreateToken", {}).n("SSOOIDCClient", "CreateTokenCommand").f(CreateTokenRequestFilterSensitiveLog, CreateTokenResponseFilterSensitiveLog).ser(se_CreateTokenCommand).de(de_CreateTokenCommand).build() {
1178
- static {
1179
- __name(this, "CreateTokenCommand");
1180
- }
725
+ const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
726
+ const contents = smithyClient.map({});
727
+ const data = parsedOutput.body;
728
+ const doc = smithyClient.take(data, {
729
+ error: smithyClient.expectString,
730
+ error_description: smithyClient.expectString,
731
+ reason: smithyClient.expectString,
732
+ });
733
+ Object.assign(contents, doc);
734
+ const exception = new InvalidRequestException({
735
+ $metadata: deserializeMetadata(parsedOutput),
736
+ ...contents,
737
+ });
738
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1181
739
  };
1182
-
1183
- // src/commands/CreateTokenWithIAMCommand.ts
1184
-
1185
-
1186
-
1187
- var CreateTokenWithIAMCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1188
- return [
1189
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1190
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1191
- ];
1192
- }).s("AWSSSOOIDCService", "CreateTokenWithIAM", {}).n("SSOOIDCClient", "CreateTokenWithIAMCommand").f(CreateTokenWithIAMRequestFilterSensitiveLog, CreateTokenWithIAMResponseFilterSensitiveLog).ser(se_CreateTokenWithIAMCommand).de(de_CreateTokenWithIAMCommand).build() {
1193
- static {
1194
- __name(this, "CreateTokenWithIAMCommand");
1195
- }
740
+ const de_InvalidRequestRegionExceptionRes = async (parsedOutput, context) => {
741
+ const contents = smithyClient.map({});
742
+ const data = parsedOutput.body;
743
+ const doc = smithyClient.take(data, {
744
+ endpoint: smithyClient.expectString,
745
+ error: smithyClient.expectString,
746
+ error_description: smithyClient.expectString,
747
+ region: smithyClient.expectString,
748
+ });
749
+ Object.assign(contents, doc);
750
+ const exception = new InvalidRequestRegionException({
751
+ $metadata: deserializeMetadata(parsedOutput),
752
+ ...contents,
753
+ });
754
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1196
755
  };
1197
-
1198
- // src/commands/RegisterClientCommand.ts
1199
-
1200
-
1201
-
1202
- var RegisterClientCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1203
- return [
1204
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1205
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1206
- ];
1207
- }).s("AWSSSOOIDCService", "RegisterClient", {}).n("SSOOIDCClient", "RegisterClientCommand").f(void 0, RegisterClientResponseFilterSensitiveLog).ser(se_RegisterClientCommand).de(de_RegisterClientCommand).build() {
1208
- static {
1209
- __name(this, "RegisterClientCommand");
1210
- }
756
+ const de_InvalidScopeExceptionRes = async (parsedOutput, context) => {
757
+ const contents = smithyClient.map({});
758
+ const data = parsedOutput.body;
759
+ const doc = smithyClient.take(data, {
760
+ error: smithyClient.expectString,
761
+ error_description: smithyClient.expectString,
762
+ });
763
+ Object.assign(contents, doc);
764
+ const exception = new InvalidScopeException({
765
+ $metadata: deserializeMetadata(parsedOutput),
766
+ ...contents,
767
+ });
768
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1211
769
  };
1212
-
1213
- // src/commands/StartDeviceAuthorizationCommand.ts
1214
-
1215
-
1216
-
1217
- var StartDeviceAuthorizationCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1218
- return [
1219
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1220
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1221
- ];
1222
- }).s("AWSSSOOIDCService", "StartDeviceAuthorization", {}).n("SSOOIDCClient", "StartDeviceAuthorizationCommand").f(StartDeviceAuthorizationRequestFilterSensitiveLog, void 0).ser(se_StartDeviceAuthorizationCommand).de(de_StartDeviceAuthorizationCommand).build() {
1223
- static {
1224
- __name(this, "StartDeviceAuthorizationCommand");
1225
- }
770
+ const de_SlowDownExceptionRes = async (parsedOutput, context) => {
771
+ const contents = smithyClient.map({});
772
+ const data = parsedOutput.body;
773
+ const doc = smithyClient.take(data, {
774
+ error: smithyClient.expectString,
775
+ error_description: smithyClient.expectString,
776
+ });
777
+ Object.assign(contents, doc);
778
+ const exception = new SlowDownException({
779
+ $metadata: deserializeMetadata(parsedOutput),
780
+ ...contents,
781
+ });
782
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1226
783
  };
1227
-
1228
- // src/SSOOIDC.ts
1229
- var commands = {
1230
- CreateTokenCommand,
1231
- CreateTokenWithIAMCommand,
1232
- RegisterClientCommand,
1233
- StartDeviceAuthorizationCommand
784
+ const de_UnauthorizedClientExceptionRes = async (parsedOutput, context) => {
785
+ const contents = smithyClient.map({});
786
+ const data = parsedOutput.body;
787
+ const doc = smithyClient.take(data, {
788
+ error: smithyClient.expectString,
789
+ error_description: smithyClient.expectString,
790
+ });
791
+ Object.assign(contents, doc);
792
+ const exception = new UnauthorizedClientException({
793
+ $metadata: deserializeMetadata(parsedOutput),
794
+ ...contents,
795
+ });
796
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1234
797
  };
1235
- var SSOOIDC = class extends SSOOIDCClient {
1236
- static {
1237
- __name(this, "SSOOIDC");
1238
- }
798
+ const de_UnsupportedGrantTypeExceptionRes = async (parsedOutput, context) => {
799
+ const contents = smithyClient.map({});
800
+ const data = parsedOutput.body;
801
+ const doc = smithyClient.take(data, {
802
+ error: smithyClient.expectString,
803
+ error_description: smithyClient.expectString,
804
+ });
805
+ Object.assign(contents, doc);
806
+ const exception = new UnsupportedGrantTypeException({
807
+ $metadata: deserializeMetadata(parsedOutput),
808
+ ...contents,
809
+ });
810
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1239
811
  };
1240
- (0, import_smithy_client.createAggregatedClient)(commands, SSOOIDC);
1241
- // Annotate the CommonJS export names for ESM import in node:
1242
-
1243
- 0 && (module.exports = {
1244
- SSOOIDCServiceException,
1245
- __Client,
1246
- SSOOIDCClient,
1247
- SSOOIDC,
1248
- $Command,
1249
- CreateTokenCommand,
1250
- CreateTokenWithIAMCommand,
1251
- RegisterClientCommand,
1252
- StartDeviceAuthorizationCommand,
1253
- AccessDeniedExceptionReason,
1254
- AccessDeniedException,
1255
- AuthorizationPendingException,
1256
- ExpiredTokenException,
1257
- InternalServerException,
1258
- InvalidClientException,
1259
- InvalidGrantException,
1260
- InvalidRequestExceptionReason,
1261
- InvalidRequestException,
1262
- InvalidScopeException,
1263
- SlowDownException,
1264
- UnauthorizedClientException,
1265
- UnsupportedGrantTypeException,
1266
- InvalidRequestRegionException,
1267
- InvalidClientMetadataException,
1268
- InvalidRedirectUriException,
1269
- CreateTokenRequestFilterSensitiveLog,
1270
- CreateTokenResponseFilterSensitiveLog,
1271
- CreateTokenWithIAMRequestFilterSensitiveLog,
1272
- CreateTokenWithIAMResponseFilterSensitiveLog,
1273
- RegisterClientResponseFilterSensitiveLog,
1274
- StartDeviceAuthorizationRequestFilterSensitiveLog
812
+ const deserializeMetadata = (output) => ({
813
+ httpStatusCode: output.statusCode,
814
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
815
+ extendedRequestId: output.headers["x-amz-id-2"],
816
+ cfId: output.headers["x-amz-cf-id"],
1275
817
  });
818
+ const _ai = "aws_iam";
819
+
820
+ class CreateTokenCommand extends smithyClient.Command
821
+ .classBuilder()
822
+ .ep(commonParams)
823
+ .m(function (Command, cs, config, o) {
824
+ return [
825
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
826
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
827
+ ];
828
+ })
829
+ .s("AWSSSOOIDCService", "CreateToken", {})
830
+ .n("SSOOIDCClient", "CreateTokenCommand")
831
+ .f(CreateTokenRequestFilterSensitiveLog, CreateTokenResponseFilterSensitiveLog)
832
+ .ser(se_CreateTokenCommand)
833
+ .de(de_CreateTokenCommand)
834
+ .build() {
835
+ }
836
+
837
+ class CreateTokenWithIAMCommand extends smithyClient.Command
838
+ .classBuilder()
839
+ .ep(commonParams)
840
+ .m(function (Command, cs, config, o) {
841
+ return [
842
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
843
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
844
+ ];
845
+ })
846
+ .s("AWSSSOOIDCService", "CreateTokenWithIAM", {})
847
+ .n("SSOOIDCClient", "CreateTokenWithIAMCommand")
848
+ .f(CreateTokenWithIAMRequestFilterSensitiveLog, CreateTokenWithIAMResponseFilterSensitiveLog)
849
+ .ser(se_CreateTokenWithIAMCommand)
850
+ .de(de_CreateTokenWithIAMCommand)
851
+ .build() {
852
+ }
853
+
854
+ class RegisterClientCommand extends smithyClient.Command
855
+ .classBuilder()
856
+ .ep(commonParams)
857
+ .m(function (Command, cs, config, o) {
858
+ return [
859
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
860
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
861
+ ];
862
+ })
863
+ .s("AWSSSOOIDCService", "RegisterClient", {})
864
+ .n("SSOOIDCClient", "RegisterClientCommand")
865
+ .f(void 0, RegisterClientResponseFilterSensitiveLog)
866
+ .ser(se_RegisterClientCommand)
867
+ .de(de_RegisterClientCommand)
868
+ .build() {
869
+ }
870
+
871
+ class StartDeviceAuthorizationCommand extends smithyClient.Command
872
+ .classBuilder()
873
+ .ep(commonParams)
874
+ .m(function (Command, cs, config, o) {
875
+ return [
876
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
877
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
878
+ ];
879
+ })
880
+ .s("AWSSSOOIDCService", "StartDeviceAuthorization", {})
881
+ .n("SSOOIDCClient", "StartDeviceAuthorizationCommand")
882
+ .f(StartDeviceAuthorizationRequestFilterSensitiveLog, void 0)
883
+ .ser(se_StartDeviceAuthorizationCommand)
884
+ .de(de_StartDeviceAuthorizationCommand)
885
+ .build() {
886
+ }
887
+
888
+ const commands = {
889
+ CreateTokenCommand,
890
+ CreateTokenWithIAMCommand,
891
+ RegisterClientCommand,
892
+ StartDeviceAuthorizationCommand,
893
+ };
894
+ class SSOOIDC extends SSOOIDCClient {
895
+ }
896
+ smithyClient.createAggregatedClient(commands, SSOOIDC);
1276
897
 
898
+ Object.defineProperty(exports, "$Command", {
899
+ enumerable: true,
900
+ get: function () { return smithyClient.Command; }
901
+ });
902
+ Object.defineProperty(exports, "__Client", {
903
+ enumerable: true,
904
+ get: function () { return smithyClient.Client; }
905
+ });
906
+ exports.AccessDeniedException = AccessDeniedException;
907
+ exports.AccessDeniedExceptionReason = AccessDeniedExceptionReason;
908
+ exports.AuthorizationPendingException = AuthorizationPendingException;
909
+ exports.CreateTokenCommand = CreateTokenCommand;
910
+ exports.CreateTokenRequestFilterSensitiveLog = CreateTokenRequestFilterSensitiveLog;
911
+ exports.CreateTokenResponseFilterSensitiveLog = CreateTokenResponseFilterSensitiveLog;
912
+ exports.CreateTokenWithIAMCommand = CreateTokenWithIAMCommand;
913
+ exports.CreateTokenWithIAMRequestFilterSensitiveLog = CreateTokenWithIAMRequestFilterSensitiveLog;
914
+ exports.CreateTokenWithIAMResponseFilterSensitiveLog = CreateTokenWithIAMResponseFilterSensitiveLog;
915
+ exports.ExpiredTokenException = ExpiredTokenException;
916
+ exports.InternalServerException = InternalServerException;
917
+ exports.InvalidClientException = InvalidClientException;
918
+ exports.InvalidClientMetadataException = InvalidClientMetadataException;
919
+ exports.InvalidGrantException = InvalidGrantException;
920
+ exports.InvalidRedirectUriException = InvalidRedirectUriException;
921
+ exports.InvalidRequestException = InvalidRequestException;
922
+ exports.InvalidRequestExceptionReason = InvalidRequestExceptionReason;
923
+ exports.InvalidRequestRegionException = InvalidRequestRegionException;
924
+ exports.InvalidScopeException = InvalidScopeException;
925
+ exports.RegisterClientCommand = RegisterClientCommand;
926
+ exports.RegisterClientResponseFilterSensitiveLog = RegisterClientResponseFilterSensitiveLog;
927
+ exports.SSOOIDC = SSOOIDC;
928
+ exports.SSOOIDCClient = SSOOIDCClient;
929
+ exports.SSOOIDCServiceException = SSOOIDCServiceException;
930
+ exports.SlowDownException = SlowDownException;
931
+ exports.StartDeviceAuthorizationCommand = StartDeviceAuthorizationCommand;
932
+ exports.StartDeviceAuthorizationRequestFilterSensitiveLog = StartDeviceAuthorizationRequestFilterSensitiveLog;
933
+ exports.UnauthorizedClientException = UnauthorizedClientException;
934
+ exports.UnsupportedGrantTypeException = UnsupportedGrantTypeException;