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