@aws-sdk/client-resource-groups 3.899.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 +1581 -1753
  2. package/package.json +37 -37
package/dist-cjs/index.js CHANGED
@@ -1,1794 +1,1622 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
7
- var __export = (target, all) => {
8
- for (var name in all)
9
- __defProp(target, name, { get: all[name], enumerable: true });
10
- };
11
- var __copyProps = (to, from, except, desc) => {
12
- if (from && typeof from === "object" || typeof from === "function") {
13
- for (let key of __getOwnPropNames(from))
14
- if (!__hasOwnProp.call(to, key) && key !== except)
15
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
- }
17
- return to;
18
- };
19
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
20
-
21
- // src/index.ts
22
- var index_exports = {};
23
- __export(index_exports, {
24
- BadRequestException: () => BadRequestException,
25
- CancelTagSyncTaskCommand: () => CancelTagSyncTaskCommand,
26
- CreateGroupCommand: () => CreateGroupCommand,
27
- DeleteGroupCommand: () => DeleteGroupCommand,
28
- ForbiddenException: () => ForbiddenException,
29
- GetAccountSettingsCommand: () => GetAccountSettingsCommand,
30
- GetGroupCommand: () => GetGroupCommand,
31
- GetGroupConfigurationCommand: () => GetGroupConfigurationCommand,
32
- GetGroupQueryCommand: () => GetGroupQueryCommand,
33
- GetTagSyncTaskCommand: () => GetTagSyncTaskCommand,
34
- GetTagsCommand: () => GetTagsCommand,
35
- GroupConfigurationStatus: () => GroupConfigurationStatus,
36
- GroupFilterName: () => GroupFilterName,
37
- GroupLifecycleEventsDesiredStatus: () => GroupLifecycleEventsDesiredStatus,
38
- GroupLifecycleEventsStatus: () => GroupLifecycleEventsStatus,
39
- GroupResourcesCommand: () => GroupResourcesCommand,
40
- GroupingStatus: () => GroupingStatus,
41
- GroupingType: () => GroupingType,
42
- InternalServerErrorException: () => InternalServerErrorException,
43
- ListGroupResourcesCommand: () => ListGroupResourcesCommand,
44
- ListGroupingStatusesCommand: () => ListGroupingStatusesCommand,
45
- ListGroupingStatusesFilterName: () => ListGroupingStatusesFilterName,
46
- ListGroupsCommand: () => ListGroupsCommand,
47
- ListTagSyncTasksCommand: () => ListTagSyncTasksCommand,
48
- MethodNotAllowedException: () => MethodNotAllowedException,
49
- NotFoundException: () => NotFoundException,
50
- PutGroupConfigurationCommand: () => PutGroupConfigurationCommand,
51
- QueryErrorCode: () => QueryErrorCode,
52
- QueryType: () => QueryType,
53
- ResourceFilterName: () => ResourceFilterName,
54
- ResourceGroups: () => ResourceGroups,
55
- ResourceGroupsClient: () => ResourceGroupsClient,
56
- ResourceGroupsServiceException: () => ResourceGroupsServiceException,
57
- ResourceStatusValue: () => ResourceStatusValue,
58
- SearchResourcesCommand: () => SearchResourcesCommand,
59
- StartTagSyncTaskCommand: () => StartTagSyncTaskCommand,
60
- TagCommand: () => TagCommand,
61
- TagSyncTaskStatus: () => TagSyncTaskStatus,
62
- TooManyRequestsException: () => TooManyRequestsException,
63
- UnauthorizedException: () => UnauthorizedException,
64
- UngroupResourcesCommand: () => UngroupResourcesCommand,
65
- UntagCommand: () => UntagCommand,
66
- UpdateAccountSettingsCommand: () => UpdateAccountSettingsCommand,
67
- UpdateGroupCommand: () => UpdateGroupCommand,
68
- UpdateGroupQueryCommand: () => UpdateGroupQueryCommand,
69
- __Client: () => import_smithy_client.Client,
70
- paginateListGroupResources: () => paginateListGroupResources,
71
- paginateListGroupingStatuses: () => paginateListGroupingStatuses,
72
- paginateListGroups: () => paginateListGroups,
73
- paginateListTagSyncTasks: () => paginateListTagSyncTasks,
74
- paginateSearchResources: () => paginateSearchResources
75
- });
76
- module.exports = __toCommonJS(index_exports);
77
-
78
- // src/ResourceGroupsClient.ts
79
- var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
80
- var import_middleware_logger = require("@aws-sdk/middleware-logger");
81
- var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
82
- var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
83
- var import_config_resolver = require("@smithy/config-resolver");
84
- var import_core = require("@smithy/core");
85
- var import_middleware_content_length = require("@smithy/middleware-content-length");
86
- var import_middleware_endpoint = require("@smithy/middleware-endpoint");
87
- var import_middleware_retry = require("@smithy/middleware-retry");
88
-
89
- var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
90
-
91
- // src/endpoint/EndpointParameters.ts
92
- var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
93
- return Object.assign(options, {
94
- useDualstackEndpoint: options.useDualstackEndpoint ?? false,
95
- useFipsEndpoint: options.useFipsEndpoint ?? false,
96
- defaultSigningName: "resource-groups"
97
- });
98
- }, "resolveClientEndpointParameters");
99
- var commonParams = {
100
- UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
101
- Endpoint: { type: "builtInParams", name: "endpoint" },
102
- Region: { type: "builtInParams", name: "region" },
103
- UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
1
+ 'use strict';
2
+
3
+ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
4
+ var middlewareLogger = require('@aws-sdk/middleware-logger');
5
+ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
6
+ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
7
+ var configResolver = require('@smithy/config-resolver');
8
+ var core = require('@smithy/core');
9
+ var middlewareContentLength = require('@smithy/middleware-content-length');
10
+ var middlewareEndpoint = require('@smithy/middleware-endpoint');
11
+ var middlewareRetry = require('@smithy/middleware-retry');
12
+ var smithyClient = require('@smithy/smithy-client');
13
+ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
14
+ var runtimeConfig = require('./runtimeConfig');
15
+ var regionConfigResolver = require('@aws-sdk/region-config-resolver');
16
+ var protocolHttp = require('@smithy/protocol-http');
17
+ var middlewareSerde = require('@smithy/middleware-serde');
18
+ var core$1 = require('@aws-sdk/core');
19
+
20
+ const resolveClientEndpointParameters = (options) => {
21
+ return Object.assign(options, {
22
+ useDualstackEndpoint: options.useDualstackEndpoint ?? false,
23
+ useFipsEndpoint: options.useFipsEndpoint ?? false,
24
+ defaultSigningName: "resource-groups",
25
+ });
26
+ };
27
+ const commonParams = {
28
+ UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
29
+ Endpoint: { type: "builtInParams", name: "endpoint" },
30
+ Region: { type: "builtInParams", name: "region" },
31
+ UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
104
32
  };
105
33
 
106
- // src/ResourceGroupsClient.ts
107
- var import_runtimeConfig = require("././runtimeConfig");
34
+ const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
35
+ const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
36
+ let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
37
+ let _credentials = runtimeConfig.credentials;
38
+ return {
39
+ setHttpAuthScheme(httpAuthScheme) {
40
+ const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
41
+ if (index === -1) {
42
+ _httpAuthSchemes.push(httpAuthScheme);
43
+ }
44
+ else {
45
+ _httpAuthSchemes.splice(index, 1, httpAuthScheme);
46
+ }
47
+ },
48
+ httpAuthSchemes() {
49
+ return _httpAuthSchemes;
50
+ },
51
+ setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
52
+ _httpAuthSchemeProvider = httpAuthSchemeProvider;
53
+ },
54
+ httpAuthSchemeProvider() {
55
+ return _httpAuthSchemeProvider;
56
+ },
57
+ setCredentials(credentials) {
58
+ _credentials = credentials;
59
+ },
60
+ credentials() {
61
+ return _credentials;
62
+ },
63
+ };
64
+ };
65
+ const resolveHttpAuthRuntimeConfig = (config) => {
66
+ return {
67
+ httpAuthSchemes: config.httpAuthSchemes(),
68
+ httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
69
+ credentials: config.credentials(),
70
+ };
71
+ };
108
72
 
109
- // src/runtimeExtensions.ts
110
- var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
111
- var import_protocol_http = require("@smithy/protocol-http");
112
- var import_smithy_client = require("@smithy/smithy-client");
73
+ const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
74
+ const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
75
+ extensions.forEach((extension) => extension.configure(extensionConfiguration));
76
+ return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
77
+ };
113
78
 
114
- // src/auth/httpAuthExtensionConfiguration.ts
115
- var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
116
- const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
117
- let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
118
- let _credentials = runtimeConfig.credentials;
119
- return {
120
- setHttpAuthScheme(httpAuthScheme) {
121
- const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
122
- if (index === -1) {
123
- _httpAuthSchemes.push(httpAuthScheme);
124
- } else {
125
- _httpAuthSchemes.splice(index, 1, httpAuthScheme);
126
- }
127
- },
128
- httpAuthSchemes() {
129
- return _httpAuthSchemes;
130
- },
131
- setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
132
- _httpAuthSchemeProvider = httpAuthSchemeProvider;
133
- },
134
- httpAuthSchemeProvider() {
135
- return _httpAuthSchemeProvider;
136
- },
137
- setCredentials(credentials) {
138
- _credentials = credentials;
139
- },
140
- credentials() {
141
- return _credentials;
79
+ class ResourceGroupsClient extends smithyClient.Client {
80
+ config;
81
+ constructor(...[configuration]) {
82
+ const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
83
+ super(_config_0);
84
+ this.initConfig = _config_0;
85
+ const _config_1 = resolveClientEndpointParameters(_config_0);
86
+ const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
87
+ const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
88
+ const _config_4 = configResolver.resolveRegionConfig(_config_3);
89
+ const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
90
+ const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
91
+ const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
92
+ const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
93
+ this.config = _config_8;
94
+ this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
95
+ this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
96
+ this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
97
+ this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
98
+ this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
99
+ this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
100
+ this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
101
+ httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultResourceGroupsHttpAuthSchemeParametersProvider,
102
+ identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
103
+ "aws.auth#sigv4": config.credentials,
104
+ }),
105
+ }));
106
+ this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
107
+ }
108
+ destroy() {
109
+ super.destroy();
142
110
  }
143
- };
144
- }, "getHttpAuthExtensionConfiguration");
145
- var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
146
- return {
147
- httpAuthSchemes: config.httpAuthSchemes(),
148
- httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
149
- credentials: config.credentials()
150
- };
151
- }, "resolveHttpAuthRuntimeConfig");
111
+ }
152
112
 
153
- // src/runtimeExtensions.ts
154
- var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
155
- const extensionConfiguration = Object.assign(
156
- (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
157
- (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
158
- (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
159
- getHttpAuthExtensionConfiguration(runtimeConfig)
160
- );
161
- extensions.forEach((extension) => extension.configure(extensionConfiguration));
162
- return Object.assign(
163
- runtimeConfig,
164
- (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
165
- (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
166
- (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
167
- resolveHttpAuthRuntimeConfig(extensionConfiguration)
168
- );
169
- }, "resolveRuntimeExtensions");
113
+ class ResourceGroupsServiceException extends smithyClient.ServiceException {
114
+ constructor(options) {
115
+ super(options);
116
+ Object.setPrototypeOf(this, ResourceGroupsServiceException.prototype);
117
+ }
118
+ }
170
119
 
171
- // src/ResourceGroupsClient.ts
172
- var ResourceGroupsClient = class extends import_smithy_client.Client {
173
- static {
174
- __name(this, "ResourceGroupsClient");
175
- }
176
- /**
177
- * The resolved configuration of ResourceGroupsClient class. This is resolved and normalized from the {@link ResourceGroupsClientConfig | constructor configuration interface}.
178
- */
179
- config;
180
- constructor(...[configuration]) {
181
- const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
182
- super(_config_0);
183
- this.initConfig = _config_0;
184
- const _config_1 = resolveClientEndpointParameters(_config_0);
185
- const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
186
- const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
187
- const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
188
- const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
189
- const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
190
- const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
191
- const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
192
- this.config = _config_8;
193
- this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
194
- this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
195
- this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
196
- this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
197
- this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
198
- this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
199
- this.middlewareStack.use(
200
- (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
201
- httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultResourceGroupsHttpAuthSchemeParametersProvider,
202
- identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
203
- "aws.auth#sigv4": config.credentials
204
- }), "identityProviderConfigProvider")
205
- })
206
- );
207
- this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
208
- }
209
- /**
210
- * Destroy underlying resources, like sockets. It's usually not necessary to do this.
211
- * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
212
- * Otherwise, sockets might stay open for quite a long time before the server terminates them.
213
- */
214
- destroy() {
215
- super.destroy();
216
- }
120
+ const GroupLifecycleEventsDesiredStatus = {
121
+ ACTIVE: "ACTIVE",
122
+ INACTIVE: "INACTIVE",
217
123
  };
218
-
219
- // src/ResourceGroups.ts
220
-
221
-
222
- // src/commands/CancelTagSyncTaskCommand.ts
223
-
224
- var import_middleware_serde = require("@smithy/middleware-serde");
225
-
226
-
227
- // src/protocols/Aws_restJson1.ts
228
- var import_core2 = require("@aws-sdk/core");
229
-
230
-
231
-
232
- // src/models/ResourceGroupsServiceException.ts
233
-
234
- var ResourceGroupsServiceException = class _ResourceGroupsServiceException extends import_smithy_client.ServiceException {
235
- static {
236
- __name(this, "ResourceGroupsServiceException");
237
- }
238
- /**
239
- * @internal
240
- */
241
- constructor(options) {
242
- super(options);
243
- Object.setPrototypeOf(this, _ResourceGroupsServiceException.prototype);
244
- }
124
+ const GroupLifecycleEventsStatus = {
125
+ ACTIVE: "ACTIVE",
126
+ ERROR: "ERROR",
127
+ INACTIVE: "INACTIVE",
128
+ IN_PROGRESS: "IN_PROGRESS",
245
129
  };
246
-
247
- // src/models/models_0.ts
248
- var GroupLifecycleEventsDesiredStatus = {
249
- ACTIVE: "ACTIVE",
250
- INACTIVE: "INACTIVE"
251
- };
252
- var GroupLifecycleEventsStatus = {
253
- ACTIVE: "ACTIVE",
254
- ERROR: "ERROR",
255
- INACTIVE: "INACTIVE",
256
- IN_PROGRESS: "IN_PROGRESS"
257
- };
258
- var BadRequestException = class _BadRequestException extends ResourceGroupsServiceException {
259
- static {
260
- __name(this, "BadRequestException");
261
- }
262
- name = "BadRequestException";
263
- $fault = "client";
264
- Message;
265
- /**
266
- * @internal
267
- */
268
- constructor(opts) {
269
- super({
270
- name: "BadRequestException",
271
- $fault: "client",
272
- ...opts
273
- });
274
- Object.setPrototypeOf(this, _BadRequestException.prototype);
275
- this.Message = opts.Message;
276
- }
277
- };
278
- var ForbiddenException = class _ForbiddenException extends ResourceGroupsServiceException {
279
- static {
280
- __name(this, "ForbiddenException");
281
- }
282
- name = "ForbiddenException";
283
- $fault = "client";
284
- Message;
285
- /**
286
- * @internal
287
- */
288
- constructor(opts) {
289
- super({
290
- name: "ForbiddenException",
291
- $fault: "client",
292
- ...opts
293
- });
294
- Object.setPrototypeOf(this, _ForbiddenException.prototype);
295
- this.Message = opts.Message;
296
- }
297
- };
298
- var InternalServerErrorException = class _InternalServerErrorException extends ResourceGroupsServiceException {
299
- static {
300
- __name(this, "InternalServerErrorException");
301
- }
302
- name = "InternalServerErrorException";
303
- $fault = "server";
304
- Message;
305
- /**
306
- * @internal
307
- */
308
- constructor(opts) {
309
- super({
310
- name: "InternalServerErrorException",
311
- $fault: "server",
312
- ...opts
313
- });
314
- Object.setPrototypeOf(this, _InternalServerErrorException.prototype);
315
- this.Message = opts.Message;
316
- }
317
- };
318
- var MethodNotAllowedException = class _MethodNotAllowedException extends ResourceGroupsServiceException {
319
- static {
320
- __name(this, "MethodNotAllowedException");
321
- }
322
- name = "MethodNotAllowedException";
323
- $fault = "client";
324
- Message;
325
- /**
326
- * @internal
327
- */
328
- constructor(opts) {
329
- super({
330
- name: "MethodNotAllowedException",
331
- $fault: "client",
332
- ...opts
333
- });
334
- Object.setPrototypeOf(this, _MethodNotAllowedException.prototype);
335
- this.Message = opts.Message;
336
- }
337
- };
338
- var TooManyRequestsException = class _TooManyRequestsException extends ResourceGroupsServiceException {
339
- static {
340
- __name(this, "TooManyRequestsException");
341
- }
342
- name = "TooManyRequestsException";
343
- $fault = "client";
344
- Message;
345
- /**
346
- * @internal
347
- */
348
- constructor(opts) {
349
- super({
350
- name: "TooManyRequestsException",
351
- $fault: "client",
352
- ...opts
353
- });
354
- Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
355
- this.Message = opts.Message;
356
- }
357
- };
358
- var UnauthorizedException = class _UnauthorizedException extends ResourceGroupsServiceException {
359
- static {
360
- __name(this, "UnauthorizedException");
361
- }
362
- name = "UnauthorizedException";
363
- $fault = "client";
364
- Message;
365
- /**
366
- * @internal
367
- */
368
- constructor(opts) {
369
- super({
370
- name: "UnauthorizedException",
371
- $fault: "client",
372
- ...opts
373
- });
374
- Object.setPrototypeOf(this, _UnauthorizedException.prototype);
375
- this.Message = opts.Message;
376
- }
377
- };
378
- var QueryType = {
379
- CLOUDFORMATION_STACK_1_0: "CLOUDFORMATION_STACK_1_0",
380
- TAG_FILTERS_1_0: "TAG_FILTERS_1_0"
381
- };
382
- var GroupConfigurationStatus = {
383
- UPDATE_COMPLETE: "UPDATE_COMPLETE",
384
- UPDATE_FAILED: "UPDATE_FAILED",
385
- UPDATING: "UPDATING"
386
- };
387
- var NotFoundException = class _NotFoundException extends ResourceGroupsServiceException {
388
- static {
389
- __name(this, "NotFoundException");
390
- }
391
- name = "NotFoundException";
392
- $fault = "client";
393
- Message;
394
- /**
395
- * @internal
396
- */
397
- constructor(opts) {
398
- super({
399
- name: "NotFoundException",
400
- $fault: "client",
401
- ...opts
402
- });
403
- Object.setPrototypeOf(this, _NotFoundException.prototype);
404
- this.Message = opts.Message;
405
- }
406
- };
407
- var TagSyncTaskStatus = {
408
- ACTIVE: "ACTIVE",
409
- ERROR: "ERROR"
410
- };
411
- var ListGroupingStatusesFilterName = {
412
- ResourceArn: "resource-arn",
413
- Status: "status"
414
- };
415
- var GroupingType = {
416
- GROUP: "GROUP",
417
- UNGROUP: "UNGROUP"
418
- };
419
- var GroupingStatus = {
420
- FAILED: "FAILED",
421
- IN_PROGRESS: "IN_PROGRESS",
422
- SKIPPED: "SKIPPED",
423
- SUCCESS: "SUCCESS"
424
- };
425
- var ResourceFilterName = {
426
- ResourceType: "resource-type"
427
- };
428
- var QueryErrorCode = {
429
- CLOUDFORMATION_STACK_INACTIVE: "CLOUDFORMATION_STACK_INACTIVE",
430
- CLOUDFORMATION_STACK_NOT_EXISTING: "CLOUDFORMATION_STACK_NOT_EXISTING",
431
- CLOUDFORMATION_STACK_UNASSUMABLE_ROLE: "CLOUDFORMATION_STACK_UNASSUMABLE_ROLE",
432
- RESOURCE_TYPE_NOT_SUPPORTED: "RESOURCE_TYPE_NOT_SUPPORTED"
433
- };
434
- var ResourceStatusValue = {
435
- Pending: "PENDING"
436
- };
437
- var GroupFilterName = {
438
- ConfigurationType: "configuration-type",
439
- Criticality: "criticality",
440
- DisplayName: "display-name",
441
- Owner: "owner",
442
- ResourceType: "resource-type"
130
+ class BadRequestException extends ResourceGroupsServiceException {
131
+ name = "BadRequestException";
132
+ $fault = "client";
133
+ Message;
134
+ constructor(opts) {
135
+ super({
136
+ name: "BadRequestException",
137
+ $fault: "client",
138
+ ...opts,
139
+ });
140
+ Object.setPrototypeOf(this, BadRequestException.prototype);
141
+ this.Message = opts.Message;
142
+ }
143
+ }
144
+ class ForbiddenException extends ResourceGroupsServiceException {
145
+ name = "ForbiddenException";
146
+ $fault = "client";
147
+ Message;
148
+ constructor(opts) {
149
+ super({
150
+ name: "ForbiddenException",
151
+ $fault: "client",
152
+ ...opts,
153
+ });
154
+ Object.setPrototypeOf(this, ForbiddenException.prototype);
155
+ this.Message = opts.Message;
156
+ }
157
+ }
158
+ class InternalServerErrorException extends ResourceGroupsServiceException {
159
+ name = "InternalServerErrorException";
160
+ $fault = "server";
161
+ Message;
162
+ constructor(opts) {
163
+ super({
164
+ name: "InternalServerErrorException",
165
+ $fault: "server",
166
+ ...opts,
167
+ });
168
+ Object.setPrototypeOf(this, InternalServerErrorException.prototype);
169
+ this.Message = opts.Message;
170
+ }
171
+ }
172
+ class MethodNotAllowedException extends ResourceGroupsServiceException {
173
+ name = "MethodNotAllowedException";
174
+ $fault = "client";
175
+ Message;
176
+ constructor(opts) {
177
+ super({
178
+ name: "MethodNotAllowedException",
179
+ $fault: "client",
180
+ ...opts,
181
+ });
182
+ Object.setPrototypeOf(this, MethodNotAllowedException.prototype);
183
+ this.Message = opts.Message;
184
+ }
185
+ }
186
+ class TooManyRequestsException extends ResourceGroupsServiceException {
187
+ name = "TooManyRequestsException";
188
+ $fault = "client";
189
+ Message;
190
+ constructor(opts) {
191
+ super({
192
+ name: "TooManyRequestsException",
193
+ $fault: "client",
194
+ ...opts,
195
+ });
196
+ Object.setPrototypeOf(this, TooManyRequestsException.prototype);
197
+ this.Message = opts.Message;
198
+ }
199
+ }
200
+ class UnauthorizedException extends ResourceGroupsServiceException {
201
+ name = "UnauthorizedException";
202
+ $fault = "client";
203
+ Message;
204
+ constructor(opts) {
205
+ super({
206
+ name: "UnauthorizedException",
207
+ $fault: "client",
208
+ ...opts,
209
+ });
210
+ Object.setPrototypeOf(this, UnauthorizedException.prototype);
211
+ this.Message = opts.Message;
212
+ }
213
+ }
214
+ const QueryType = {
215
+ CLOUDFORMATION_STACK_1_0: "CLOUDFORMATION_STACK_1_0",
216
+ TAG_FILTERS_1_0: "TAG_FILTERS_1_0",
443
217
  };
444
-
445
- // src/protocols/Aws_restJson1.ts
446
- var se_CancelTagSyncTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
447
- const b = (0, import_core.requestBuilder)(input, context);
448
- const headers = {
449
- "content-type": "application/json"
450
- };
451
- b.bp("/cancel-tag-sync-task");
452
- let body;
453
- body = JSON.stringify(
454
- (0, import_smithy_client.take)(input, {
455
- TaskArn: []
456
- })
457
- );
458
- b.m("POST").h(headers).b(body);
459
- return b.build();
460
- }, "se_CancelTagSyncTaskCommand");
461
- var se_CreateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
462
- const b = (0, import_core.requestBuilder)(input, context);
463
- const headers = {
464
- "content-type": "application/json"
465
- };
466
- b.bp("/groups");
467
- let body;
468
- body = JSON.stringify(
469
- (0, import_smithy_client.take)(input, {
470
- Configuration: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Configuration"),
471
- Criticality: [],
472
- Description: [],
473
- DisplayName: [],
474
- Name: [],
475
- Owner: [],
476
- ResourceQuery: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ResourceQuery"),
477
- Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags")
478
- })
479
- );
480
- b.m("POST").h(headers).b(body);
481
- return b.build();
482
- }, "se_CreateGroupCommand");
483
- var se_DeleteGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
484
- const b = (0, import_core.requestBuilder)(input, context);
485
- const headers = {
486
- "content-type": "application/json"
487
- };
488
- b.bp("/delete-group");
489
- let body;
490
- body = JSON.stringify(
491
- (0, import_smithy_client.take)(input, {
492
- Group: [],
493
- GroupName: []
494
- })
495
- );
496
- b.m("POST").h(headers).b(body);
497
- return b.build();
498
- }, "se_DeleteGroupCommand");
499
- var se_GetAccountSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
500
- const b = (0, import_core.requestBuilder)(input, context);
501
- const headers = {};
502
- b.bp("/get-account-settings");
503
- let body;
504
- b.m("POST").h(headers).b(body);
505
- return b.build();
506
- }, "se_GetAccountSettingsCommand");
507
- var se_GetGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
508
- const b = (0, import_core.requestBuilder)(input, context);
509
- const headers = {
510
- "content-type": "application/json"
511
- };
512
- b.bp("/get-group");
513
- let body;
514
- body = JSON.stringify(
515
- (0, import_smithy_client.take)(input, {
516
- Group: [],
517
- GroupName: []
518
- })
519
- );
520
- b.m("POST").h(headers).b(body);
521
- return b.build();
522
- }, "se_GetGroupCommand");
523
- var se_GetGroupConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
524
- const b = (0, import_core.requestBuilder)(input, context);
525
- const headers = {
526
- "content-type": "application/json"
527
- };
528
- b.bp("/get-group-configuration");
529
- let body;
530
- body = JSON.stringify(
531
- (0, import_smithy_client.take)(input, {
532
- Group: []
533
- })
534
- );
535
- b.m("POST").h(headers).b(body);
536
- return b.build();
537
- }, "se_GetGroupConfigurationCommand");
538
- var se_GetGroupQueryCommand = /* @__PURE__ */ __name(async (input, context) => {
539
- const b = (0, import_core.requestBuilder)(input, context);
540
- const headers = {
541
- "content-type": "application/json"
542
- };
543
- b.bp("/get-group-query");
544
- let body;
545
- body = JSON.stringify(
546
- (0, import_smithy_client.take)(input, {
547
- Group: [],
548
- GroupName: []
549
- })
550
- );
551
- b.m("POST").h(headers).b(body);
552
- return b.build();
553
- }, "se_GetGroupQueryCommand");
554
- var se_GetTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
555
- const b = (0, import_core.requestBuilder)(input, context);
556
- const headers = {};
557
- b.bp("/resources/{Arn}/tags");
558
- b.p("Arn", () => input.Arn, "{Arn}", false);
559
- let body;
560
- b.m("GET").h(headers).b(body);
561
- return b.build();
562
- }, "se_GetTagsCommand");
563
- var se_GetTagSyncTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
564
- const b = (0, import_core.requestBuilder)(input, context);
565
- const headers = {
566
- "content-type": "application/json"
567
- };
568
- b.bp("/get-tag-sync-task");
569
- let body;
570
- body = JSON.stringify(
571
- (0, import_smithy_client.take)(input, {
572
- TaskArn: []
573
- })
574
- );
575
- b.m("POST").h(headers).b(body);
576
- return b.build();
577
- }, "se_GetTagSyncTaskCommand");
578
- var se_GroupResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
579
- const b = (0, import_core.requestBuilder)(input, context);
580
- const headers = {
581
- "content-type": "application/json"
582
- };
583
- b.bp("/group-resources");
584
- let body;
585
- body = JSON.stringify(
586
- (0, import_smithy_client.take)(input, {
587
- Group: [],
588
- ResourceArns: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ResourceArns")
589
- })
590
- );
591
- b.m("POST").h(headers).b(body);
592
- return b.build();
593
- }, "se_GroupResourcesCommand");
594
- var se_ListGroupingStatusesCommand = /* @__PURE__ */ __name(async (input, context) => {
595
- const b = (0, import_core.requestBuilder)(input, context);
596
- const headers = {
597
- "content-type": "application/json"
598
- };
599
- b.bp("/list-grouping-statuses");
600
- let body;
601
- body = JSON.stringify(
602
- (0, import_smithy_client.take)(input, {
603
- Filters: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Filters"),
604
- Group: [],
605
- MaxResults: [],
606
- NextToken: []
607
- })
608
- );
609
- b.m("POST").h(headers).b(body);
610
- return b.build();
611
- }, "se_ListGroupingStatusesCommand");
612
- var se_ListGroupResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
613
- const b = (0, import_core.requestBuilder)(input, context);
614
- const headers = {
615
- "content-type": "application/json"
616
- };
617
- b.bp("/list-group-resources");
618
- let body;
619
- body = JSON.stringify(
620
- (0, import_smithy_client.take)(input, {
621
- Filters: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Filters"),
622
- Group: [],
623
- GroupName: [],
624
- MaxResults: [],
625
- NextToken: []
626
- })
627
- );
628
- b.m("POST").h(headers).b(body);
629
- return b.build();
630
- }, "se_ListGroupResourcesCommand");
631
- var se_ListGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
632
- const b = (0, import_core.requestBuilder)(input, context);
633
- const headers = {
634
- "content-type": "application/json"
635
- };
636
- b.bp("/groups-list");
637
- const query = (0, import_smithy_client.map)({
638
- [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
639
- [_nT]: [, input[_NT]]
640
- });
641
- let body;
642
- body = JSON.stringify(
643
- (0, import_smithy_client.take)(input, {
644
- Filters: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Filters")
645
- })
646
- );
647
- b.m("POST").h(headers).q(query).b(body);
648
- return b.build();
649
- }, "se_ListGroupsCommand");
650
- var se_ListTagSyncTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
651
- const b = (0, import_core.requestBuilder)(input, context);
652
- const headers = {
653
- "content-type": "application/json"
654
- };
655
- b.bp("/list-tag-sync-tasks");
656
- let body;
657
- body = JSON.stringify(
658
- (0, import_smithy_client.take)(input, {
659
- Filters: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Filters"),
660
- MaxResults: [],
661
- NextToken: []
662
- })
663
- );
664
- b.m("POST").h(headers).b(body);
665
- return b.build();
666
- }, "se_ListTagSyncTasksCommand");
667
- var se_PutGroupConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
668
- const b = (0, import_core.requestBuilder)(input, context);
669
- const headers = {
670
- "content-type": "application/json"
671
- };
672
- b.bp("/put-group-configuration");
673
- let body;
674
- body = JSON.stringify(
675
- (0, import_smithy_client.take)(input, {
676
- Configuration: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Configuration"),
677
- Group: []
678
- })
679
- );
680
- b.m("POST").h(headers).b(body);
681
- return b.build();
682
- }, "se_PutGroupConfigurationCommand");
683
- var se_SearchResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
684
- const b = (0, import_core.requestBuilder)(input, context);
685
- const headers = {
686
- "content-type": "application/json"
687
- };
688
- b.bp("/resources/search");
689
- let body;
690
- body = JSON.stringify(
691
- (0, import_smithy_client.take)(input, {
692
- MaxResults: [],
693
- NextToken: [],
694
- ResourceQuery: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ResourceQuery")
695
- })
696
- );
697
- b.m("POST").h(headers).b(body);
698
- return b.build();
699
- }, "se_SearchResourcesCommand");
700
- var se_StartTagSyncTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
701
- const b = (0, import_core.requestBuilder)(input, context);
702
- const headers = {
703
- "content-type": "application/json"
704
- };
705
- b.bp("/start-tag-sync-task");
706
- let body;
707
- body = JSON.stringify(
708
- (0, import_smithy_client.take)(input, {
709
- Group: [],
710
- ResourceQuery: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ResourceQuery"),
711
- RoleArn: [],
712
- TagKey: [],
713
- TagValue: []
714
- })
715
- );
716
- b.m("POST").h(headers).b(body);
717
- return b.build();
718
- }, "se_StartTagSyncTaskCommand");
719
- var se_TagCommand = /* @__PURE__ */ __name(async (input, context) => {
720
- const b = (0, import_core.requestBuilder)(input, context);
721
- const headers = {
722
- "content-type": "application/json"
723
- };
724
- b.bp("/resources/{Arn}/tags");
725
- b.p("Arn", () => input.Arn, "{Arn}", false);
726
- let body;
727
- body = JSON.stringify(
728
- (0, import_smithy_client.take)(input, {
729
- Tags: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Tags")
730
- })
731
- );
732
- b.m("PUT").h(headers).b(body);
733
- return b.build();
734
- }, "se_TagCommand");
735
- var se_UngroupResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
736
- const b = (0, import_core.requestBuilder)(input, context);
737
- const headers = {
738
- "content-type": "application/json"
739
- };
740
- b.bp("/ungroup-resources");
741
- let body;
742
- body = JSON.stringify(
743
- (0, import_smithy_client.take)(input, {
744
- Group: [],
745
- ResourceArns: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ResourceArns")
746
- })
747
- );
748
- b.m("POST").h(headers).b(body);
749
- return b.build();
750
- }, "se_UngroupResourcesCommand");
751
- var se_UntagCommand = /* @__PURE__ */ __name(async (input, context) => {
752
- const b = (0, import_core.requestBuilder)(input, context);
753
- const headers = {
754
- "content-type": "application/json"
755
- };
756
- b.bp("/resources/{Arn}/tags");
757
- b.p("Arn", () => input.Arn, "{Arn}", false);
758
- let body;
759
- body = JSON.stringify(
760
- (0, import_smithy_client.take)(input, {
761
- Keys: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "Keys")
762
- })
763
- );
764
- b.m("PATCH").h(headers).b(body);
765
- return b.build();
766
- }, "se_UntagCommand");
767
- var se_UpdateAccountSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
768
- const b = (0, import_core.requestBuilder)(input, context);
769
- const headers = {
770
- "content-type": "application/json"
771
- };
772
- b.bp("/update-account-settings");
773
- let body;
774
- body = JSON.stringify(
775
- (0, import_smithy_client.take)(input, {
776
- GroupLifecycleEventsDesiredStatus: []
777
- })
778
- );
779
- b.m("POST").h(headers).b(body);
780
- return b.build();
781
- }, "se_UpdateAccountSettingsCommand");
782
- var se_UpdateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
783
- const b = (0, import_core.requestBuilder)(input, context);
784
- const headers = {
785
- "content-type": "application/json"
786
- };
787
- b.bp("/update-group");
788
- let body;
789
- body = JSON.stringify(
790
- (0, import_smithy_client.take)(input, {
791
- Criticality: [],
792
- Description: [],
793
- DisplayName: [],
794
- Group: [],
795
- GroupName: [],
796
- Owner: []
797
- })
798
- );
799
- b.m("POST").h(headers).b(body);
800
- return b.build();
801
- }, "se_UpdateGroupCommand");
802
- var se_UpdateGroupQueryCommand = /* @__PURE__ */ __name(async (input, context) => {
803
- const b = (0, import_core.requestBuilder)(input, context);
804
- const headers = {
805
- "content-type": "application/json"
806
- };
807
- b.bp("/update-group-query");
808
- let body;
809
- body = JSON.stringify(
810
- (0, import_smithy_client.take)(input, {
811
- Group: [],
812
- GroupName: [],
813
- ResourceQuery: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ResourceQuery")
814
- })
815
- );
816
- b.m("POST").h(headers).b(body);
817
- return b.build();
818
- }, "se_UpdateGroupQueryCommand");
819
- var de_CancelTagSyncTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
820
- if (output.statusCode !== 200 && output.statusCode >= 300) {
821
- return de_CommandError(output, context);
822
- }
823
- const contents = (0, import_smithy_client.map)({
824
- $metadata: deserializeMetadata(output)
825
- });
826
- await (0, import_smithy_client.collectBody)(output.body, context);
827
- return contents;
828
- }, "de_CancelTagSyncTaskCommand");
829
- var de_CreateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
830
- if (output.statusCode !== 200 && output.statusCode >= 300) {
831
- return de_CommandError(output, context);
832
- }
833
- const contents = (0, import_smithy_client.map)({
834
- $metadata: deserializeMetadata(output)
835
- });
836
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
837
- const doc = (0, import_smithy_client.take)(data, {
838
- Group: import_smithy_client._json,
839
- GroupConfiguration: import_smithy_client._json,
840
- ResourceQuery: import_smithy_client._json,
841
- Tags: import_smithy_client._json
842
- });
843
- Object.assign(contents, doc);
844
- return contents;
845
- }, "de_CreateGroupCommand");
846
- var de_DeleteGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
847
- if (output.statusCode !== 200 && output.statusCode >= 300) {
848
- return de_CommandError(output, context);
849
- }
850
- const contents = (0, import_smithy_client.map)({
851
- $metadata: deserializeMetadata(output)
852
- });
853
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
854
- const doc = (0, import_smithy_client.take)(data, {
855
- Group: import_smithy_client._json
856
- });
857
- Object.assign(contents, doc);
858
- return contents;
859
- }, "de_DeleteGroupCommand");
860
- var de_GetAccountSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
861
- if (output.statusCode !== 200 && output.statusCode >= 300) {
862
- return de_CommandError(output, context);
863
- }
864
- const contents = (0, import_smithy_client.map)({
865
- $metadata: deserializeMetadata(output)
866
- });
867
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
868
- const doc = (0, import_smithy_client.take)(data, {
869
- AccountSettings: import_smithy_client._json
870
- });
871
- Object.assign(contents, doc);
872
- return contents;
873
- }, "de_GetAccountSettingsCommand");
874
- var de_GetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
875
- if (output.statusCode !== 200 && output.statusCode >= 300) {
876
- return de_CommandError(output, context);
877
- }
878
- const contents = (0, import_smithy_client.map)({
879
- $metadata: deserializeMetadata(output)
880
- });
881
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
882
- const doc = (0, import_smithy_client.take)(data, {
883
- Group: import_smithy_client._json
884
- });
885
- Object.assign(contents, doc);
886
- return contents;
887
- }, "de_GetGroupCommand");
888
- var de_GetGroupConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
889
- if (output.statusCode !== 200 && output.statusCode >= 300) {
890
- return de_CommandError(output, context);
891
- }
892
- const contents = (0, import_smithy_client.map)({
893
- $metadata: deserializeMetadata(output)
894
- });
895
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
896
- const doc = (0, import_smithy_client.take)(data, {
897
- GroupConfiguration: import_smithy_client._json
898
- });
899
- Object.assign(contents, doc);
900
- return contents;
901
- }, "de_GetGroupConfigurationCommand");
902
- var de_GetGroupQueryCommand = /* @__PURE__ */ __name(async (output, context) => {
903
- if (output.statusCode !== 200 && output.statusCode >= 300) {
904
- return de_CommandError(output, context);
905
- }
906
- const contents = (0, import_smithy_client.map)({
907
- $metadata: deserializeMetadata(output)
908
- });
909
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
910
- const doc = (0, import_smithy_client.take)(data, {
911
- GroupQuery: import_smithy_client._json
912
- });
913
- Object.assign(contents, doc);
914
- return contents;
915
- }, "de_GetGroupQueryCommand");
916
- var de_GetTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
917
- if (output.statusCode !== 200 && output.statusCode >= 300) {
918
- return de_CommandError(output, context);
919
- }
920
- const contents = (0, import_smithy_client.map)({
921
- $metadata: deserializeMetadata(output)
922
- });
923
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
924
- const doc = (0, import_smithy_client.take)(data, {
925
- Arn: import_smithy_client.expectString,
926
- Tags: import_smithy_client._json
927
- });
928
- Object.assign(contents, doc);
929
- return contents;
930
- }, "de_GetTagsCommand");
931
- var de_GetTagSyncTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
932
- if (output.statusCode !== 200 && output.statusCode >= 300) {
933
- return de_CommandError(output, context);
934
- }
935
- const contents = (0, import_smithy_client.map)({
936
- $metadata: deserializeMetadata(output)
937
- });
938
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
939
- const doc = (0, import_smithy_client.take)(data, {
940
- CreatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreatedAt"),
941
- ErrorMessage: import_smithy_client.expectString,
942
- GroupArn: import_smithy_client.expectString,
943
- GroupName: import_smithy_client.expectString,
944
- ResourceQuery: import_smithy_client._json,
945
- RoleArn: import_smithy_client.expectString,
946
- Status: import_smithy_client.expectString,
947
- TagKey: import_smithy_client.expectString,
948
- TagValue: import_smithy_client.expectString,
949
- TaskArn: import_smithy_client.expectString
950
- });
951
- Object.assign(contents, doc);
952
- return contents;
953
- }, "de_GetTagSyncTaskCommand");
954
- var de_GroupResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
955
- if (output.statusCode !== 200 && output.statusCode >= 300) {
956
- return de_CommandError(output, context);
957
- }
958
- const contents = (0, import_smithy_client.map)({
959
- $metadata: deserializeMetadata(output)
960
- });
961
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
962
- const doc = (0, import_smithy_client.take)(data, {
963
- Failed: import_smithy_client._json,
964
- Pending: import_smithy_client._json,
965
- Succeeded: import_smithy_client._json
966
- });
967
- Object.assign(contents, doc);
968
- return contents;
969
- }, "de_GroupResourcesCommand");
970
- var de_ListGroupingStatusesCommand = /* @__PURE__ */ __name(async (output, context) => {
971
- if (output.statusCode !== 200 && output.statusCode >= 300) {
972
- return de_CommandError(output, context);
973
- }
974
- const contents = (0, import_smithy_client.map)({
975
- $metadata: deserializeMetadata(output)
976
- });
977
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
978
- const doc = (0, import_smithy_client.take)(data, {
979
- Group: import_smithy_client.expectString,
980
- GroupingStatuses: /* @__PURE__ */ __name((_) => de_GroupingStatusesList(_, context), "GroupingStatuses"),
981
- NextToken: import_smithy_client.expectString
982
- });
983
- Object.assign(contents, doc);
984
- return contents;
985
- }, "de_ListGroupingStatusesCommand");
986
- var de_ListGroupResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
987
- if (output.statusCode !== 200 && output.statusCode >= 300) {
988
- return de_CommandError(output, context);
989
- }
990
- const contents = (0, import_smithy_client.map)({
991
- $metadata: deserializeMetadata(output)
992
- });
993
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
994
- const doc = (0, import_smithy_client.take)(data, {
995
- NextToken: import_smithy_client.expectString,
996
- QueryErrors: import_smithy_client._json,
997
- ResourceIdentifiers: import_smithy_client._json,
998
- Resources: import_smithy_client._json
999
- });
1000
- Object.assign(contents, doc);
1001
- return contents;
1002
- }, "de_ListGroupResourcesCommand");
1003
- var de_ListGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
1004
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1005
- return de_CommandError(output, context);
1006
- }
1007
- const contents = (0, import_smithy_client.map)({
1008
- $metadata: deserializeMetadata(output)
1009
- });
1010
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1011
- const doc = (0, import_smithy_client.take)(data, {
1012
- GroupIdentifiers: import_smithy_client._json,
1013
- Groups: import_smithy_client._json,
1014
- NextToken: import_smithy_client.expectString
1015
- });
1016
- Object.assign(contents, doc);
1017
- return contents;
1018
- }, "de_ListGroupsCommand");
1019
- var de_ListTagSyncTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
1020
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1021
- return de_CommandError(output, context);
1022
- }
1023
- const contents = (0, import_smithy_client.map)({
1024
- $metadata: deserializeMetadata(output)
1025
- });
1026
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1027
- const doc = (0, import_smithy_client.take)(data, {
1028
- NextToken: import_smithy_client.expectString,
1029
- TagSyncTasks: /* @__PURE__ */ __name((_) => de_TagSyncTaskList(_, context), "TagSyncTasks")
1030
- });
1031
- Object.assign(contents, doc);
1032
- return contents;
1033
- }, "de_ListTagSyncTasksCommand");
1034
- var de_PutGroupConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
1035
- if (output.statusCode !== 202 && output.statusCode >= 300) {
1036
- return de_CommandError(output, context);
1037
- }
1038
- const contents = (0, import_smithy_client.map)({
1039
- $metadata: deserializeMetadata(output)
1040
- });
1041
- await (0, import_smithy_client.collectBody)(output.body, context);
1042
- return contents;
1043
- }, "de_PutGroupConfigurationCommand");
1044
- var de_SearchResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
1045
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1046
- return de_CommandError(output, context);
1047
- }
1048
- const contents = (0, import_smithy_client.map)({
1049
- $metadata: deserializeMetadata(output)
1050
- });
1051
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1052
- const doc = (0, import_smithy_client.take)(data, {
1053
- NextToken: import_smithy_client.expectString,
1054
- QueryErrors: import_smithy_client._json,
1055
- ResourceIdentifiers: import_smithy_client._json
1056
- });
1057
- Object.assign(contents, doc);
1058
- return contents;
1059
- }, "de_SearchResourcesCommand");
1060
- var de_StartTagSyncTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
1061
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1062
- return de_CommandError(output, context);
1063
- }
1064
- const contents = (0, import_smithy_client.map)({
1065
- $metadata: deserializeMetadata(output)
1066
- });
1067
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1068
- const doc = (0, import_smithy_client.take)(data, {
1069
- GroupArn: import_smithy_client.expectString,
1070
- GroupName: import_smithy_client.expectString,
1071
- ResourceQuery: import_smithy_client._json,
1072
- RoleArn: import_smithy_client.expectString,
1073
- TagKey: import_smithy_client.expectString,
1074
- TagValue: import_smithy_client.expectString,
1075
- TaskArn: import_smithy_client.expectString
1076
- });
1077
- Object.assign(contents, doc);
1078
- return contents;
1079
- }, "de_StartTagSyncTaskCommand");
1080
- var de_TagCommand = /* @__PURE__ */ __name(async (output, context) => {
1081
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1082
- return de_CommandError(output, context);
1083
- }
1084
- const contents = (0, import_smithy_client.map)({
1085
- $metadata: deserializeMetadata(output)
1086
- });
1087
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1088
- const doc = (0, import_smithy_client.take)(data, {
1089
- Arn: import_smithy_client.expectString,
1090
- Tags: import_smithy_client._json
1091
- });
1092
- Object.assign(contents, doc);
1093
- return contents;
1094
- }, "de_TagCommand");
1095
- var de_UngroupResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
1096
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1097
- return de_CommandError(output, context);
1098
- }
1099
- const contents = (0, import_smithy_client.map)({
1100
- $metadata: deserializeMetadata(output)
1101
- });
1102
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1103
- const doc = (0, import_smithy_client.take)(data, {
1104
- Failed: import_smithy_client._json,
1105
- Pending: import_smithy_client._json,
1106
- Succeeded: import_smithy_client._json
1107
- });
1108
- Object.assign(contents, doc);
1109
- return contents;
1110
- }, "de_UngroupResourcesCommand");
1111
- var de_UntagCommand = /* @__PURE__ */ __name(async (output, context) => {
1112
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1113
- return de_CommandError(output, context);
1114
- }
1115
- const contents = (0, import_smithy_client.map)({
1116
- $metadata: deserializeMetadata(output)
1117
- });
1118
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1119
- const doc = (0, import_smithy_client.take)(data, {
1120
- Arn: import_smithy_client.expectString,
1121
- Keys: import_smithy_client._json
1122
- });
1123
- Object.assign(contents, doc);
1124
- return contents;
1125
- }, "de_UntagCommand");
1126
- var de_UpdateAccountSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
1127
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1128
- return de_CommandError(output, context);
1129
- }
1130
- const contents = (0, import_smithy_client.map)({
1131
- $metadata: deserializeMetadata(output)
1132
- });
1133
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1134
- const doc = (0, import_smithy_client.take)(data, {
1135
- AccountSettings: import_smithy_client._json
1136
- });
1137
- Object.assign(contents, doc);
1138
- return contents;
1139
- }, "de_UpdateAccountSettingsCommand");
1140
- var de_UpdateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
1141
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1142
- return de_CommandError(output, context);
1143
- }
1144
- const contents = (0, import_smithy_client.map)({
1145
- $metadata: deserializeMetadata(output)
1146
- });
1147
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1148
- const doc = (0, import_smithy_client.take)(data, {
1149
- Group: import_smithy_client._json
1150
- });
1151
- Object.assign(contents, doc);
1152
- return contents;
1153
- }, "de_UpdateGroupCommand");
1154
- var de_UpdateGroupQueryCommand = /* @__PURE__ */ __name(async (output, context) => {
1155
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1156
- return de_CommandError(output, context);
1157
- }
1158
- const contents = (0, import_smithy_client.map)({
1159
- $metadata: deserializeMetadata(output)
1160
- });
1161
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
1162
- const doc = (0, import_smithy_client.take)(data, {
1163
- GroupQuery: import_smithy_client._json
1164
- });
1165
- Object.assign(contents, doc);
1166
- return contents;
1167
- }, "de_UpdateGroupQueryCommand");
1168
- var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
1169
- const parsedOutput = {
1170
- ...output,
1171
- body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
1172
- };
1173
- const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
1174
- switch (errorCode) {
1175
- case "BadRequestException":
1176
- case "com.amazonaws.resourcegroups#BadRequestException":
1177
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1178
- case "ForbiddenException":
1179
- case "com.amazonaws.resourcegroups#ForbiddenException":
1180
- throw await de_ForbiddenExceptionRes(parsedOutput, context);
1181
- case "InternalServerErrorException":
1182
- case "com.amazonaws.resourcegroups#InternalServerErrorException":
1183
- throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
1184
- case "MethodNotAllowedException":
1185
- case "com.amazonaws.resourcegroups#MethodNotAllowedException":
1186
- throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
1187
- case "TooManyRequestsException":
1188
- case "com.amazonaws.resourcegroups#TooManyRequestsException":
1189
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1190
- case "UnauthorizedException":
1191
- case "com.amazonaws.resourcegroups#UnauthorizedException":
1192
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1193
- case "NotFoundException":
1194
- case "com.amazonaws.resourcegroups#NotFoundException":
1195
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1196
- default:
1197
- const parsedBody = parsedOutput.body;
1198
- return throwDefaultError({
1199
- output,
1200
- parsedBody,
1201
- errorCode
1202
- });
1203
- }
1204
- }, "de_CommandError");
1205
- var throwDefaultError = (0, import_smithy_client.withBaseException)(ResourceGroupsServiceException);
1206
- var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1207
- const contents = (0, import_smithy_client.map)({});
1208
- const data = parsedOutput.body;
1209
- const doc = (0, import_smithy_client.take)(data, {
1210
- Message: import_smithy_client.expectString
1211
- });
1212
- Object.assign(contents, doc);
1213
- const exception = new BadRequestException({
1214
- $metadata: deserializeMetadata(parsedOutput),
1215
- ...contents
1216
- });
1217
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1218
- }, "de_BadRequestExceptionRes");
1219
- var de_ForbiddenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1220
- const contents = (0, import_smithy_client.map)({});
1221
- const data = parsedOutput.body;
1222
- const doc = (0, import_smithy_client.take)(data, {
1223
- Message: import_smithy_client.expectString
1224
- });
1225
- Object.assign(contents, doc);
1226
- const exception = new ForbiddenException({
1227
- $metadata: deserializeMetadata(parsedOutput),
1228
- ...contents
1229
- });
1230
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1231
- }, "de_ForbiddenExceptionRes");
1232
- var de_InternalServerErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1233
- const contents = (0, import_smithy_client.map)({});
1234
- const data = parsedOutput.body;
1235
- const doc = (0, import_smithy_client.take)(data, {
1236
- Message: import_smithy_client.expectString
1237
- });
1238
- Object.assign(contents, doc);
1239
- const exception = new InternalServerErrorException({
1240
- $metadata: deserializeMetadata(parsedOutput),
1241
- ...contents
1242
- });
1243
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1244
- }, "de_InternalServerErrorExceptionRes");
1245
- var de_MethodNotAllowedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1246
- const contents = (0, import_smithy_client.map)({});
1247
- const data = parsedOutput.body;
1248
- const doc = (0, import_smithy_client.take)(data, {
1249
- Message: import_smithy_client.expectString
1250
- });
1251
- Object.assign(contents, doc);
1252
- const exception = new MethodNotAllowedException({
1253
- $metadata: deserializeMetadata(parsedOutput),
1254
- ...contents
1255
- });
1256
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1257
- }, "de_MethodNotAllowedExceptionRes");
1258
- var de_NotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1259
- const contents = (0, import_smithy_client.map)({});
1260
- const data = parsedOutput.body;
1261
- const doc = (0, import_smithy_client.take)(data, {
1262
- Message: import_smithy_client.expectString
1263
- });
1264
- Object.assign(contents, doc);
1265
- const exception = new NotFoundException({
1266
- $metadata: deserializeMetadata(parsedOutput),
1267
- ...contents
1268
- });
1269
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1270
- }, "de_NotFoundExceptionRes");
1271
- var de_TooManyRequestsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1272
- const contents = (0, import_smithy_client.map)({});
1273
- const data = parsedOutput.body;
1274
- const doc = (0, import_smithy_client.take)(data, {
1275
- Message: import_smithy_client.expectString
1276
- });
1277
- Object.assign(contents, doc);
1278
- const exception = new TooManyRequestsException({
1279
- $metadata: deserializeMetadata(parsedOutput),
1280
- ...contents
1281
- });
1282
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1283
- }, "de_TooManyRequestsExceptionRes");
1284
- var de_UnauthorizedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
1285
- const contents = (0, import_smithy_client.map)({});
1286
- const data = parsedOutput.body;
1287
- const doc = (0, import_smithy_client.take)(data, {
1288
- Message: import_smithy_client.expectString
1289
- });
1290
- Object.assign(contents, doc);
1291
- const exception = new UnauthorizedException({
1292
- $metadata: deserializeMetadata(parsedOutput),
1293
- ...contents
1294
- });
1295
- return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
1296
- }, "de_UnauthorizedExceptionRes");
1297
- var de_GroupingStatusesItem = /* @__PURE__ */ __name((output, context) => {
1298
- return (0, import_smithy_client.take)(output, {
1299
- Action: import_smithy_client.expectString,
1300
- ErrorCode: import_smithy_client.expectString,
1301
- ErrorMessage: import_smithy_client.expectString,
1302
- ResourceArn: import_smithy_client.expectString,
1303
- Status: import_smithy_client.expectString,
1304
- UpdatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "UpdatedAt")
1305
- });
1306
- }, "de_GroupingStatusesItem");
1307
- var de_GroupingStatusesList = /* @__PURE__ */ __name((output, context) => {
1308
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1309
- return de_GroupingStatusesItem(entry, context);
1310
- });
1311
- return retVal;
1312
- }, "de_GroupingStatusesList");
1313
- var de_TagSyncTaskItem = /* @__PURE__ */ __name((output, context) => {
1314
- return (0, import_smithy_client.take)(output, {
1315
- CreatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreatedAt"),
1316
- ErrorMessage: import_smithy_client.expectString,
1317
- GroupArn: import_smithy_client.expectString,
1318
- GroupName: import_smithy_client.expectString,
1319
- ResourceQuery: import_smithy_client._json,
1320
- RoleArn: import_smithy_client.expectString,
1321
- Status: import_smithy_client.expectString,
1322
- TagKey: import_smithy_client.expectString,
1323
- TagValue: import_smithy_client.expectString,
1324
- TaskArn: import_smithy_client.expectString
1325
- });
1326
- }, "de_TagSyncTaskItem");
1327
- var de_TagSyncTaskList = /* @__PURE__ */ __name((output, context) => {
1328
- const retVal = (output || []).filter((e) => e != null).map((entry) => {
1329
- return de_TagSyncTaskItem(entry, context);
1330
- });
1331
- return retVal;
1332
- }, "de_TagSyncTaskList");
1333
- var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
1334
- httpStatusCode: output.statusCode,
1335
- requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1336
- extendedRequestId: output.headers["x-amz-id-2"],
1337
- cfId: output.headers["x-amz-cf-id"]
1338
- }), "deserializeMetadata");
1339
- var _MR = "MaxResults";
1340
- var _NT = "NextToken";
1341
- var _mR = "maxResults";
1342
- var _nT = "nextToken";
1343
-
1344
- // src/commands/CancelTagSyncTaskCommand.ts
1345
- var CancelTagSyncTaskCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1346
- return [
1347
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1348
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1349
- ];
1350
- }).s("Ardi", "CancelTagSyncTask", {}).n("ResourceGroupsClient", "CancelTagSyncTaskCommand").f(void 0, void 0).ser(se_CancelTagSyncTaskCommand).de(de_CancelTagSyncTaskCommand).build() {
1351
- static {
1352
- __name(this, "CancelTagSyncTaskCommand");
1353
- }
218
+ const GroupConfigurationStatus = {
219
+ UPDATE_COMPLETE: "UPDATE_COMPLETE",
220
+ UPDATE_FAILED: "UPDATE_FAILED",
221
+ UPDATING: "UPDATING",
1354
222
  };
1355
-
1356
- // src/commands/CreateGroupCommand.ts
1357
-
1358
-
1359
-
1360
- var CreateGroupCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1361
- return [
1362
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1363
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1364
- ];
1365
- }).s("Ardi", "CreateGroup", {}).n("ResourceGroupsClient", "CreateGroupCommand").f(void 0, void 0).ser(se_CreateGroupCommand).de(de_CreateGroupCommand).build() {
1366
- static {
1367
- __name(this, "CreateGroupCommand");
1368
- }
223
+ class NotFoundException extends ResourceGroupsServiceException {
224
+ name = "NotFoundException";
225
+ $fault = "client";
226
+ Message;
227
+ constructor(opts) {
228
+ super({
229
+ name: "NotFoundException",
230
+ $fault: "client",
231
+ ...opts,
232
+ });
233
+ Object.setPrototypeOf(this, NotFoundException.prototype);
234
+ this.Message = opts.Message;
235
+ }
236
+ }
237
+ const TagSyncTaskStatus = {
238
+ ACTIVE: "ACTIVE",
239
+ ERROR: "ERROR",
1369
240
  };
1370
-
1371
- // src/commands/DeleteGroupCommand.ts
1372
-
1373
-
1374
-
1375
- var DeleteGroupCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1376
- return [
1377
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1378
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1379
- ];
1380
- }).s("Ardi", "DeleteGroup", {}).n("ResourceGroupsClient", "DeleteGroupCommand").f(void 0, void 0).ser(se_DeleteGroupCommand).de(de_DeleteGroupCommand).build() {
1381
- static {
1382
- __name(this, "DeleteGroupCommand");
1383
- }
241
+ const ListGroupingStatusesFilterName = {
242
+ ResourceArn: "resource-arn",
243
+ Status: "status",
1384
244
  };
1385
-
1386
- // src/commands/GetAccountSettingsCommand.ts
1387
-
1388
-
1389
-
1390
- var GetAccountSettingsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1391
- return [
1392
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1393
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1394
- ];
1395
- }).s("Ardi", "GetAccountSettings", {}).n("ResourceGroupsClient", "GetAccountSettingsCommand").f(void 0, void 0).ser(se_GetAccountSettingsCommand).de(de_GetAccountSettingsCommand).build() {
1396
- static {
1397
- __name(this, "GetAccountSettingsCommand");
1398
- }
245
+ const GroupingType = {
246
+ GROUP: "GROUP",
247
+ UNGROUP: "UNGROUP",
1399
248
  };
1400
-
1401
- // src/commands/GetGroupCommand.ts
1402
-
1403
-
1404
-
1405
- var GetGroupCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1406
- return [
1407
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1408
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1409
- ];
1410
- }).s("Ardi", "GetGroup", {}).n("ResourceGroupsClient", "GetGroupCommand").f(void 0, void 0).ser(se_GetGroupCommand).de(de_GetGroupCommand).build() {
1411
- static {
1412
- __name(this, "GetGroupCommand");
1413
- }
249
+ const GroupingStatus = {
250
+ FAILED: "FAILED",
251
+ IN_PROGRESS: "IN_PROGRESS",
252
+ SKIPPED: "SKIPPED",
253
+ SUCCESS: "SUCCESS",
1414
254
  };
1415
-
1416
- // src/commands/GetGroupConfigurationCommand.ts
1417
-
1418
-
1419
-
1420
- var GetGroupConfigurationCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1421
- return [
1422
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1423
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1424
- ];
1425
- }).s("Ardi", "GetGroupConfiguration", {}).n("ResourceGroupsClient", "GetGroupConfigurationCommand").f(void 0, void 0).ser(se_GetGroupConfigurationCommand).de(de_GetGroupConfigurationCommand).build() {
1426
- static {
1427
- __name(this, "GetGroupConfigurationCommand");
1428
- }
255
+ const ResourceFilterName = {
256
+ ResourceType: "resource-type",
1429
257
  };
1430
-
1431
- // src/commands/GetGroupQueryCommand.ts
1432
-
1433
-
1434
-
1435
- var GetGroupQueryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1436
- return [
1437
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1438
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1439
- ];
1440
- }).s("Ardi", "GetGroupQuery", {}).n("ResourceGroupsClient", "GetGroupQueryCommand").f(void 0, void 0).ser(se_GetGroupQueryCommand).de(de_GetGroupQueryCommand).build() {
1441
- static {
1442
- __name(this, "GetGroupQueryCommand");
1443
- }
258
+ const QueryErrorCode = {
259
+ CLOUDFORMATION_STACK_INACTIVE: "CLOUDFORMATION_STACK_INACTIVE",
260
+ CLOUDFORMATION_STACK_NOT_EXISTING: "CLOUDFORMATION_STACK_NOT_EXISTING",
261
+ CLOUDFORMATION_STACK_UNASSUMABLE_ROLE: "CLOUDFORMATION_STACK_UNASSUMABLE_ROLE",
262
+ RESOURCE_TYPE_NOT_SUPPORTED: "RESOURCE_TYPE_NOT_SUPPORTED",
1444
263
  };
1445
-
1446
- // src/commands/GetTagsCommand.ts
1447
-
1448
-
1449
-
1450
- var GetTagsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1451
- return [
1452
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1453
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1454
- ];
1455
- }).s("Ardi", "GetTags", {}).n("ResourceGroupsClient", "GetTagsCommand").f(void 0, void 0).ser(se_GetTagsCommand).de(de_GetTagsCommand).build() {
1456
- static {
1457
- __name(this, "GetTagsCommand");
1458
- }
264
+ const ResourceStatusValue = {
265
+ Pending: "PENDING",
1459
266
  };
1460
-
1461
- // src/commands/GetTagSyncTaskCommand.ts
1462
-
1463
-
1464
-
1465
- var GetTagSyncTaskCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1466
- return [
1467
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1468
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1469
- ];
1470
- }).s("Ardi", "GetTagSyncTask", {}).n("ResourceGroupsClient", "GetTagSyncTaskCommand").f(void 0, void 0).ser(se_GetTagSyncTaskCommand).de(de_GetTagSyncTaskCommand).build() {
1471
- static {
1472
- __name(this, "GetTagSyncTaskCommand");
1473
- }
267
+ const GroupFilterName = {
268
+ ConfigurationType: "configuration-type",
269
+ Criticality: "criticality",
270
+ DisplayName: "display-name",
271
+ Owner: "owner",
272
+ ResourceType: "resource-type",
1474
273
  };
1475
274
 
1476
- // src/commands/GroupResourcesCommand.ts
1477
-
1478
-
1479
-
1480
- var GroupResourcesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1481
- return [
1482
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1483
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1484
- ];
1485
- }).s("Ardi", "GroupResources", {}).n("ResourceGroupsClient", "GroupResourcesCommand").f(void 0, void 0).ser(se_GroupResourcesCommand).de(de_GroupResourcesCommand).build() {
1486
- static {
1487
- __name(this, "GroupResourcesCommand");
1488
- }
275
+ const se_CancelTagSyncTaskCommand = async (input, context) => {
276
+ const b = core.requestBuilder(input, context);
277
+ const headers = {
278
+ "content-type": "application/json",
279
+ };
280
+ b.bp("/cancel-tag-sync-task");
281
+ let body;
282
+ body = JSON.stringify(smithyClient.take(input, {
283
+ TaskArn: [],
284
+ }));
285
+ b.m("POST").h(headers).b(body);
286
+ return b.build();
1489
287
  };
1490
-
1491
- // src/commands/ListGroupingStatusesCommand.ts
1492
-
1493
-
1494
-
1495
- var ListGroupingStatusesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1496
- return [
1497
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1498
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1499
- ];
1500
- }).s("Ardi", "ListGroupingStatuses", {}).n("ResourceGroupsClient", "ListGroupingStatusesCommand").f(void 0, void 0).ser(se_ListGroupingStatusesCommand).de(de_ListGroupingStatusesCommand).build() {
1501
- static {
1502
- __name(this, "ListGroupingStatusesCommand");
1503
- }
288
+ const se_CreateGroupCommand = async (input, context) => {
289
+ const b = core.requestBuilder(input, context);
290
+ const headers = {
291
+ "content-type": "application/json",
292
+ };
293
+ b.bp("/groups");
294
+ let body;
295
+ body = JSON.stringify(smithyClient.take(input, {
296
+ Configuration: (_) => smithyClient._json(_),
297
+ Criticality: [],
298
+ Description: [],
299
+ DisplayName: [],
300
+ Name: [],
301
+ Owner: [],
302
+ ResourceQuery: (_) => smithyClient._json(_),
303
+ Tags: (_) => smithyClient._json(_),
304
+ }));
305
+ b.m("POST").h(headers).b(body);
306
+ return b.build();
1504
307
  };
1505
-
1506
- // src/commands/ListGroupResourcesCommand.ts
1507
-
1508
-
1509
-
1510
- var ListGroupResourcesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1511
- return [
1512
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1513
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1514
- ];
1515
- }).s("Ardi", "ListGroupResources", {}).n("ResourceGroupsClient", "ListGroupResourcesCommand").f(void 0, void 0).ser(se_ListGroupResourcesCommand).de(de_ListGroupResourcesCommand).build() {
1516
- static {
1517
- __name(this, "ListGroupResourcesCommand");
1518
- }
308
+ const se_DeleteGroupCommand = async (input, context) => {
309
+ const b = core.requestBuilder(input, context);
310
+ const headers = {
311
+ "content-type": "application/json",
312
+ };
313
+ b.bp("/delete-group");
314
+ let body;
315
+ body = JSON.stringify(smithyClient.take(input, {
316
+ Group: [],
317
+ GroupName: [],
318
+ }));
319
+ b.m("POST").h(headers).b(body);
320
+ return b.build();
1519
321
  };
1520
-
1521
- // src/commands/ListGroupsCommand.ts
1522
-
1523
-
1524
-
1525
- var ListGroupsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1526
- return [
1527
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1528
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1529
- ];
1530
- }).s("Ardi", "ListGroups", {}).n("ResourceGroupsClient", "ListGroupsCommand").f(void 0, void 0).ser(se_ListGroupsCommand).de(de_ListGroupsCommand).build() {
1531
- static {
1532
- __name(this, "ListGroupsCommand");
1533
- }
322
+ const se_GetAccountSettingsCommand = async (input, context) => {
323
+ const b = core.requestBuilder(input, context);
324
+ const headers = {};
325
+ b.bp("/get-account-settings");
326
+ let body;
327
+ b.m("POST").h(headers).b(body);
328
+ return b.build();
1534
329
  };
1535
-
1536
- // src/commands/ListTagSyncTasksCommand.ts
1537
-
1538
-
1539
-
1540
- var ListTagSyncTasksCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1541
- return [
1542
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1543
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1544
- ];
1545
- }).s("Ardi", "ListTagSyncTasks", {}).n("ResourceGroupsClient", "ListTagSyncTasksCommand").f(void 0, void 0).ser(se_ListTagSyncTasksCommand).de(de_ListTagSyncTasksCommand).build() {
1546
- static {
1547
- __name(this, "ListTagSyncTasksCommand");
1548
- }
330
+ const se_GetGroupCommand = async (input, context) => {
331
+ const b = core.requestBuilder(input, context);
332
+ const headers = {
333
+ "content-type": "application/json",
334
+ };
335
+ b.bp("/get-group");
336
+ let body;
337
+ body = JSON.stringify(smithyClient.take(input, {
338
+ Group: [],
339
+ GroupName: [],
340
+ }));
341
+ b.m("POST").h(headers).b(body);
342
+ return b.build();
1549
343
  };
1550
-
1551
- // src/commands/PutGroupConfigurationCommand.ts
1552
-
1553
-
1554
-
1555
- var PutGroupConfigurationCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1556
- return [
1557
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1558
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1559
- ];
1560
- }).s("Ardi", "PutGroupConfiguration", {}).n("ResourceGroupsClient", "PutGroupConfigurationCommand").f(void 0, void 0).ser(se_PutGroupConfigurationCommand).de(de_PutGroupConfigurationCommand).build() {
1561
- static {
1562
- __name(this, "PutGroupConfigurationCommand");
1563
- }
344
+ const se_GetGroupConfigurationCommand = async (input, context) => {
345
+ const b = core.requestBuilder(input, context);
346
+ const headers = {
347
+ "content-type": "application/json",
348
+ };
349
+ b.bp("/get-group-configuration");
350
+ let body;
351
+ body = JSON.stringify(smithyClient.take(input, {
352
+ Group: [],
353
+ }));
354
+ b.m("POST").h(headers).b(body);
355
+ return b.build();
1564
356
  };
1565
-
1566
- // src/commands/SearchResourcesCommand.ts
1567
-
1568
-
1569
-
1570
- var SearchResourcesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1571
- return [
1572
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1573
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1574
- ];
1575
- }).s("Ardi", "SearchResources", {}).n("ResourceGroupsClient", "SearchResourcesCommand").f(void 0, void 0).ser(se_SearchResourcesCommand).de(de_SearchResourcesCommand).build() {
1576
- static {
1577
- __name(this, "SearchResourcesCommand");
1578
- }
357
+ const se_GetGroupQueryCommand = async (input, context) => {
358
+ const b = core.requestBuilder(input, context);
359
+ const headers = {
360
+ "content-type": "application/json",
361
+ };
362
+ b.bp("/get-group-query");
363
+ let body;
364
+ body = JSON.stringify(smithyClient.take(input, {
365
+ Group: [],
366
+ GroupName: [],
367
+ }));
368
+ b.m("POST").h(headers).b(body);
369
+ return b.build();
1579
370
  };
1580
-
1581
- // src/commands/StartTagSyncTaskCommand.ts
1582
-
1583
-
1584
-
1585
- var StartTagSyncTaskCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1586
- return [
1587
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1588
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1589
- ];
1590
- }).s("Ardi", "StartTagSyncTask", {}).n("ResourceGroupsClient", "StartTagSyncTaskCommand").f(void 0, void 0).ser(se_StartTagSyncTaskCommand).de(de_StartTagSyncTaskCommand).build() {
1591
- static {
1592
- __name(this, "StartTagSyncTaskCommand");
1593
- }
371
+ const se_GetTagsCommand = async (input, context) => {
372
+ const b = core.requestBuilder(input, context);
373
+ const headers = {};
374
+ b.bp("/resources/{Arn}/tags");
375
+ b.p("Arn", () => input.Arn, "{Arn}", false);
376
+ let body;
377
+ b.m("GET").h(headers).b(body);
378
+ return b.build();
1594
379
  };
1595
-
1596
- // src/commands/TagCommand.ts
1597
-
1598
-
1599
-
1600
- var TagCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1601
- return [
1602
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1603
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1604
- ];
1605
- }).s("Ardi", "Tag", {}).n("ResourceGroupsClient", "TagCommand").f(void 0, void 0).ser(se_TagCommand).de(de_TagCommand).build() {
1606
- static {
1607
- __name(this, "TagCommand");
1608
- }
380
+ const se_GetTagSyncTaskCommand = async (input, context) => {
381
+ const b = core.requestBuilder(input, context);
382
+ const headers = {
383
+ "content-type": "application/json",
384
+ };
385
+ b.bp("/get-tag-sync-task");
386
+ let body;
387
+ body = JSON.stringify(smithyClient.take(input, {
388
+ TaskArn: [],
389
+ }));
390
+ b.m("POST").h(headers).b(body);
391
+ return b.build();
1609
392
  };
1610
-
1611
- // src/commands/UngroupResourcesCommand.ts
1612
-
1613
-
1614
-
1615
- var UngroupResourcesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1616
- return [
1617
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1618
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1619
- ];
1620
- }).s("Ardi", "UngroupResources", {}).n("ResourceGroupsClient", "UngroupResourcesCommand").f(void 0, void 0).ser(se_UngroupResourcesCommand).de(de_UngroupResourcesCommand).build() {
1621
- static {
1622
- __name(this, "UngroupResourcesCommand");
1623
- }
393
+ const se_GroupResourcesCommand = async (input, context) => {
394
+ const b = core.requestBuilder(input, context);
395
+ const headers = {
396
+ "content-type": "application/json",
397
+ };
398
+ b.bp("/group-resources");
399
+ let body;
400
+ body = JSON.stringify(smithyClient.take(input, {
401
+ Group: [],
402
+ ResourceArns: (_) => smithyClient._json(_),
403
+ }));
404
+ b.m("POST").h(headers).b(body);
405
+ return b.build();
1624
406
  };
1625
-
1626
- // src/commands/UntagCommand.ts
1627
-
1628
-
1629
-
1630
- var UntagCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1631
- return [
1632
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1633
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1634
- ];
1635
- }).s("Ardi", "Untag", {}).n("ResourceGroupsClient", "UntagCommand").f(void 0, void 0).ser(se_UntagCommand).de(de_UntagCommand).build() {
1636
- static {
1637
- __name(this, "UntagCommand");
1638
- }
407
+ const se_ListGroupingStatusesCommand = async (input, context) => {
408
+ const b = core.requestBuilder(input, context);
409
+ const headers = {
410
+ "content-type": "application/json",
411
+ };
412
+ b.bp("/list-grouping-statuses");
413
+ let body;
414
+ body = JSON.stringify(smithyClient.take(input, {
415
+ Filters: (_) => smithyClient._json(_),
416
+ Group: [],
417
+ MaxResults: [],
418
+ NextToken: [],
419
+ }));
420
+ b.m("POST").h(headers).b(body);
421
+ return b.build();
1639
422
  };
1640
-
1641
- // src/commands/UpdateAccountSettingsCommand.ts
1642
-
1643
-
1644
-
1645
- var UpdateAccountSettingsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1646
- return [
1647
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1648
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1649
- ];
1650
- }).s("Ardi", "UpdateAccountSettings", {}).n("ResourceGroupsClient", "UpdateAccountSettingsCommand").f(void 0, void 0).ser(se_UpdateAccountSettingsCommand).de(de_UpdateAccountSettingsCommand).build() {
1651
- static {
1652
- __name(this, "UpdateAccountSettingsCommand");
1653
- }
423
+ const se_ListGroupResourcesCommand = async (input, context) => {
424
+ const b = core.requestBuilder(input, context);
425
+ const headers = {
426
+ "content-type": "application/json",
427
+ };
428
+ b.bp("/list-group-resources");
429
+ let body;
430
+ body = JSON.stringify(smithyClient.take(input, {
431
+ Filters: (_) => smithyClient._json(_),
432
+ Group: [],
433
+ GroupName: [],
434
+ MaxResults: [],
435
+ NextToken: [],
436
+ }));
437
+ b.m("POST").h(headers).b(body);
438
+ return b.build();
1654
439
  };
1655
-
1656
- // src/commands/UpdateGroupCommand.ts
1657
-
1658
-
1659
-
1660
- var UpdateGroupCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1661
- return [
1662
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1663
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1664
- ];
1665
- }).s("Ardi", "UpdateGroup", {}).n("ResourceGroupsClient", "UpdateGroupCommand").f(void 0, void 0).ser(se_UpdateGroupCommand).de(de_UpdateGroupCommand).build() {
1666
- static {
1667
- __name(this, "UpdateGroupCommand");
1668
- }
440
+ const se_ListGroupsCommand = async (input, context) => {
441
+ const b = core.requestBuilder(input, context);
442
+ const headers = {
443
+ "content-type": "application/json",
444
+ };
445
+ b.bp("/groups-list");
446
+ const query = smithyClient.map({
447
+ [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
448
+ [_nT]: [, input[_NT]],
449
+ });
450
+ let body;
451
+ body = JSON.stringify(smithyClient.take(input, {
452
+ Filters: (_) => smithyClient._json(_),
453
+ }));
454
+ b.m("POST").h(headers).q(query).b(body);
455
+ return b.build();
1669
456
  };
1670
-
1671
- // src/commands/UpdateGroupQueryCommand.ts
1672
-
1673
-
1674
-
1675
- var UpdateGroupQueryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
1676
- return [
1677
- (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
1678
- (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
1679
- ];
1680
- }).s("Ardi", "UpdateGroupQuery", {}).n("ResourceGroupsClient", "UpdateGroupQueryCommand").f(void 0, void 0).ser(se_UpdateGroupQueryCommand).de(de_UpdateGroupQueryCommand).build() {
1681
- static {
1682
- __name(this, "UpdateGroupQueryCommand");
1683
- }
457
+ const se_ListTagSyncTasksCommand = async (input, context) => {
458
+ const b = core.requestBuilder(input, context);
459
+ const headers = {
460
+ "content-type": "application/json",
461
+ };
462
+ b.bp("/list-tag-sync-tasks");
463
+ let body;
464
+ body = JSON.stringify(smithyClient.take(input, {
465
+ Filters: (_) => smithyClient._json(_),
466
+ MaxResults: [],
467
+ NextToken: [],
468
+ }));
469
+ b.m("POST").h(headers).b(body);
470
+ return b.build();
1684
471
  };
472
+ const se_PutGroupConfigurationCommand = async (input, context) => {
473
+ const b = core.requestBuilder(input, context);
474
+ const headers = {
475
+ "content-type": "application/json",
476
+ };
477
+ b.bp("/put-group-configuration");
478
+ let body;
479
+ body = JSON.stringify(smithyClient.take(input, {
480
+ Configuration: (_) => smithyClient._json(_),
481
+ Group: [],
482
+ }));
483
+ b.m("POST").h(headers).b(body);
484
+ return b.build();
485
+ };
486
+ const se_SearchResourcesCommand = async (input, context) => {
487
+ const b = core.requestBuilder(input, context);
488
+ const headers = {
489
+ "content-type": "application/json",
490
+ };
491
+ b.bp("/resources/search");
492
+ let body;
493
+ body = JSON.stringify(smithyClient.take(input, {
494
+ MaxResults: [],
495
+ NextToken: [],
496
+ ResourceQuery: (_) => smithyClient._json(_),
497
+ }));
498
+ b.m("POST").h(headers).b(body);
499
+ return b.build();
500
+ };
501
+ const se_StartTagSyncTaskCommand = async (input, context) => {
502
+ const b = core.requestBuilder(input, context);
503
+ const headers = {
504
+ "content-type": "application/json",
505
+ };
506
+ b.bp("/start-tag-sync-task");
507
+ let body;
508
+ body = JSON.stringify(smithyClient.take(input, {
509
+ Group: [],
510
+ ResourceQuery: (_) => smithyClient._json(_),
511
+ RoleArn: [],
512
+ TagKey: [],
513
+ TagValue: [],
514
+ }));
515
+ b.m("POST").h(headers).b(body);
516
+ return b.build();
517
+ };
518
+ const se_TagCommand = async (input, context) => {
519
+ const b = core.requestBuilder(input, context);
520
+ const headers = {
521
+ "content-type": "application/json",
522
+ };
523
+ b.bp("/resources/{Arn}/tags");
524
+ b.p("Arn", () => input.Arn, "{Arn}", false);
525
+ let body;
526
+ body = JSON.stringify(smithyClient.take(input, {
527
+ Tags: (_) => smithyClient._json(_),
528
+ }));
529
+ b.m("PUT").h(headers).b(body);
530
+ return b.build();
531
+ };
532
+ const se_UngroupResourcesCommand = async (input, context) => {
533
+ const b = core.requestBuilder(input, context);
534
+ const headers = {
535
+ "content-type": "application/json",
536
+ };
537
+ b.bp("/ungroup-resources");
538
+ let body;
539
+ body = JSON.stringify(smithyClient.take(input, {
540
+ Group: [],
541
+ ResourceArns: (_) => smithyClient._json(_),
542
+ }));
543
+ b.m("POST").h(headers).b(body);
544
+ return b.build();
545
+ };
546
+ const se_UntagCommand = async (input, context) => {
547
+ const b = core.requestBuilder(input, context);
548
+ const headers = {
549
+ "content-type": "application/json",
550
+ };
551
+ b.bp("/resources/{Arn}/tags");
552
+ b.p("Arn", () => input.Arn, "{Arn}", false);
553
+ let body;
554
+ body = JSON.stringify(smithyClient.take(input, {
555
+ Keys: (_) => smithyClient._json(_),
556
+ }));
557
+ b.m("PATCH").h(headers).b(body);
558
+ return b.build();
559
+ };
560
+ const se_UpdateAccountSettingsCommand = async (input, context) => {
561
+ const b = core.requestBuilder(input, context);
562
+ const headers = {
563
+ "content-type": "application/json",
564
+ };
565
+ b.bp("/update-account-settings");
566
+ let body;
567
+ body = JSON.stringify(smithyClient.take(input, {
568
+ GroupLifecycleEventsDesiredStatus: [],
569
+ }));
570
+ b.m("POST").h(headers).b(body);
571
+ return b.build();
572
+ };
573
+ const se_UpdateGroupCommand = async (input, context) => {
574
+ const b = core.requestBuilder(input, context);
575
+ const headers = {
576
+ "content-type": "application/json",
577
+ };
578
+ b.bp("/update-group");
579
+ let body;
580
+ body = JSON.stringify(smithyClient.take(input, {
581
+ Criticality: [],
582
+ Description: [],
583
+ DisplayName: [],
584
+ Group: [],
585
+ GroupName: [],
586
+ Owner: [],
587
+ }));
588
+ b.m("POST").h(headers).b(body);
589
+ return b.build();
590
+ };
591
+ const se_UpdateGroupQueryCommand = async (input, context) => {
592
+ const b = core.requestBuilder(input, context);
593
+ const headers = {
594
+ "content-type": "application/json",
595
+ };
596
+ b.bp("/update-group-query");
597
+ let body;
598
+ body = JSON.stringify(smithyClient.take(input, {
599
+ Group: [],
600
+ GroupName: [],
601
+ ResourceQuery: (_) => smithyClient._json(_),
602
+ }));
603
+ b.m("POST").h(headers).b(body);
604
+ return b.build();
605
+ };
606
+ const de_CancelTagSyncTaskCommand = async (output, context) => {
607
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
608
+ return de_CommandError(output, context);
609
+ }
610
+ const contents = smithyClient.map({
611
+ $metadata: deserializeMetadata(output),
612
+ });
613
+ await smithyClient.collectBody(output.body, context);
614
+ return contents;
615
+ };
616
+ const de_CreateGroupCommand = async (output, context) => {
617
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
618
+ return de_CommandError(output, context);
619
+ }
620
+ const contents = smithyClient.map({
621
+ $metadata: deserializeMetadata(output),
622
+ });
623
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
624
+ const doc = smithyClient.take(data, {
625
+ Group: smithyClient._json,
626
+ GroupConfiguration: smithyClient._json,
627
+ ResourceQuery: smithyClient._json,
628
+ Tags: smithyClient._json,
629
+ });
630
+ Object.assign(contents, doc);
631
+ return contents;
632
+ };
633
+ const de_DeleteGroupCommand = async (output, context) => {
634
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
635
+ return de_CommandError(output, context);
636
+ }
637
+ const contents = smithyClient.map({
638
+ $metadata: deserializeMetadata(output),
639
+ });
640
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
641
+ const doc = smithyClient.take(data, {
642
+ Group: smithyClient._json,
643
+ });
644
+ Object.assign(contents, doc);
645
+ return contents;
646
+ };
647
+ const de_GetAccountSettingsCommand = async (output, context) => {
648
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
649
+ return de_CommandError(output, context);
650
+ }
651
+ const contents = smithyClient.map({
652
+ $metadata: deserializeMetadata(output),
653
+ });
654
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
655
+ const doc = smithyClient.take(data, {
656
+ AccountSettings: smithyClient._json,
657
+ });
658
+ Object.assign(contents, doc);
659
+ return contents;
660
+ };
661
+ const de_GetGroupCommand = async (output, context) => {
662
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
663
+ return de_CommandError(output, context);
664
+ }
665
+ const contents = smithyClient.map({
666
+ $metadata: deserializeMetadata(output),
667
+ });
668
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
669
+ const doc = smithyClient.take(data, {
670
+ Group: smithyClient._json,
671
+ });
672
+ Object.assign(contents, doc);
673
+ return contents;
674
+ };
675
+ const de_GetGroupConfigurationCommand = async (output, context) => {
676
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
677
+ return de_CommandError(output, context);
678
+ }
679
+ const contents = smithyClient.map({
680
+ $metadata: deserializeMetadata(output),
681
+ });
682
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
683
+ const doc = smithyClient.take(data, {
684
+ GroupConfiguration: smithyClient._json,
685
+ });
686
+ Object.assign(contents, doc);
687
+ return contents;
688
+ };
689
+ const de_GetGroupQueryCommand = async (output, context) => {
690
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
691
+ return de_CommandError(output, context);
692
+ }
693
+ const contents = smithyClient.map({
694
+ $metadata: deserializeMetadata(output),
695
+ });
696
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
697
+ const doc = smithyClient.take(data, {
698
+ GroupQuery: smithyClient._json,
699
+ });
700
+ Object.assign(contents, doc);
701
+ return contents;
702
+ };
703
+ const de_GetTagsCommand = async (output, context) => {
704
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
705
+ return de_CommandError(output, context);
706
+ }
707
+ const contents = smithyClient.map({
708
+ $metadata: deserializeMetadata(output),
709
+ });
710
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
711
+ const doc = smithyClient.take(data, {
712
+ Arn: smithyClient.expectString,
713
+ Tags: smithyClient._json,
714
+ });
715
+ Object.assign(contents, doc);
716
+ return contents;
717
+ };
718
+ const de_GetTagSyncTaskCommand = async (output, context) => {
719
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
720
+ return de_CommandError(output, context);
721
+ }
722
+ const contents = smithyClient.map({
723
+ $metadata: deserializeMetadata(output),
724
+ });
725
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
726
+ const doc = smithyClient.take(data, {
727
+ CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
728
+ ErrorMessage: smithyClient.expectString,
729
+ GroupArn: smithyClient.expectString,
730
+ GroupName: smithyClient.expectString,
731
+ ResourceQuery: smithyClient._json,
732
+ RoleArn: smithyClient.expectString,
733
+ Status: smithyClient.expectString,
734
+ TagKey: smithyClient.expectString,
735
+ TagValue: smithyClient.expectString,
736
+ TaskArn: smithyClient.expectString,
737
+ });
738
+ Object.assign(contents, doc);
739
+ return contents;
740
+ };
741
+ const de_GroupResourcesCommand = async (output, context) => {
742
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
743
+ return de_CommandError(output, context);
744
+ }
745
+ const contents = smithyClient.map({
746
+ $metadata: deserializeMetadata(output),
747
+ });
748
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
749
+ const doc = smithyClient.take(data, {
750
+ Failed: smithyClient._json,
751
+ Pending: smithyClient._json,
752
+ Succeeded: smithyClient._json,
753
+ });
754
+ Object.assign(contents, doc);
755
+ return contents;
756
+ };
757
+ const de_ListGroupingStatusesCommand = async (output, context) => {
758
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
759
+ return de_CommandError(output, context);
760
+ }
761
+ const contents = smithyClient.map({
762
+ $metadata: deserializeMetadata(output),
763
+ });
764
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
765
+ const doc = smithyClient.take(data, {
766
+ Group: smithyClient.expectString,
767
+ GroupingStatuses: (_) => de_GroupingStatusesList(_),
768
+ NextToken: smithyClient.expectString,
769
+ });
770
+ Object.assign(contents, doc);
771
+ return contents;
772
+ };
773
+ const de_ListGroupResourcesCommand = async (output, context) => {
774
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
775
+ return de_CommandError(output, context);
776
+ }
777
+ const contents = smithyClient.map({
778
+ $metadata: deserializeMetadata(output),
779
+ });
780
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
781
+ const doc = smithyClient.take(data, {
782
+ NextToken: smithyClient.expectString,
783
+ QueryErrors: smithyClient._json,
784
+ ResourceIdentifiers: smithyClient._json,
785
+ Resources: smithyClient._json,
786
+ });
787
+ Object.assign(contents, doc);
788
+ return contents;
789
+ };
790
+ const de_ListGroupsCommand = async (output, context) => {
791
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
792
+ return de_CommandError(output, context);
793
+ }
794
+ const contents = smithyClient.map({
795
+ $metadata: deserializeMetadata(output),
796
+ });
797
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
798
+ const doc = smithyClient.take(data, {
799
+ GroupIdentifiers: smithyClient._json,
800
+ Groups: smithyClient._json,
801
+ NextToken: smithyClient.expectString,
802
+ });
803
+ Object.assign(contents, doc);
804
+ return contents;
805
+ };
806
+ const de_ListTagSyncTasksCommand = async (output, context) => {
807
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
808
+ return de_CommandError(output, context);
809
+ }
810
+ const contents = smithyClient.map({
811
+ $metadata: deserializeMetadata(output),
812
+ });
813
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
814
+ const doc = smithyClient.take(data, {
815
+ NextToken: smithyClient.expectString,
816
+ TagSyncTasks: (_) => de_TagSyncTaskList(_),
817
+ });
818
+ Object.assign(contents, doc);
819
+ return contents;
820
+ };
821
+ const de_PutGroupConfigurationCommand = async (output, context) => {
822
+ if (output.statusCode !== 202 && output.statusCode >= 300) {
823
+ return de_CommandError(output, context);
824
+ }
825
+ const contents = smithyClient.map({
826
+ $metadata: deserializeMetadata(output),
827
+ });
828
+ await smithyClient.collectBody(output.body, context);
829
+ return contents;
830
+ };
831
+ const de_SearchResourcesCommand = async (output, context) => {
832
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
833
+ return de_CommandError(output, context);
834
+ }
835
+ const contents = smithyClient.map({
836
+ $metadata: deserializeMetadata(output),
837
+ });
838
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
839
+ const doc = smithyClient.take(data, {
840
+ NextToken: smithyClient.expectString,
841
+ QueryErrors: smithyClient._json,
842
+ ResourceIdentifiers: smithyClient._json,
843
+ });
844
+ Object.assign(contents, doc);
845
+ return contents;
846
+ };
847
+ const de_StartTagSyncTaskCommand = async (output, context) => {
848
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
849
+ return de_CommandError(output, context);
850
+ }
851
+ const contents = smithyClient.map({
852
+ $metadata: deserializeMetadata(output),
853
+ });
854
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
855
+ const doc = smithyClient.take(data, {
856
+ GroupArn: smithyClient.expectString,
857
+ GroupName: smithyClient.expectString,
858
+ ResourceQuery: smithyClient._json,
859
+ RoleArn: smithyClient.expectString,
860
+ TagKey: smithyClient.expectString,
861
+ TagValue: smithyClient.expectString,
862
+ TaskArn: smithyClient.expectString,
863
+ });
864
+ Object.assign(contents, doc);
865
+ return contents;
866
+ };
867
+ const de_TagCommand = async (output, context) => {
868
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
869
+ return de_CommandError(output, context);
870
+ }
871
+ const contents = smithyClient.map({
872
+ $metadata: deserializeMetadata(output),
873
+ });
874
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
875
+ const doc = smithyClient.take(data, {
876
+ Arn: smithyClient.expectString,
877
+ Tags: smithyClient._json,
878
+ });
879
+ Object.assign(contents, doc);
880
+ return contents;
881
+ };
882
+ const de_UngroupResourcesCommand = async (output, context) => {
883
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
884
+ return de_CommandError(output, context);
885
+ }
886
+ const contents = smithyClient.map({
887
+ $metadata: deserializeMetadata(output),
888
+ });
889
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
890
+ const doc = smithyClient.take(data, {
891
+ Failed: smithyClient._json,
892
+ Pending: smithyClient._json,
893
+ Succeeded: smithyClient._json,
894
+ });
895
+ Object.assign(contents, doc);
896
+ return contents;
897
+ };
898
+ const de_UntagCommand = async (output, context) => {
899
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
900
+ return de_CommandError(output, context);
901
+ }
902
+ const contents = smithyClient.map({
903
+ $metadata: deserializeMetadata(output),
904
+ });
905
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
906
+ const doc = smithyClient.take(data, {
907
+ Arn: smithyClient.expectString,
908
+ Keys: smithyClient._json,
909
+ });
910
+ Object.assign(contents, doc);
911
+ return contents;
912
+ };
913
+ const de_UpdateAccountSettingsCommand = async (output, context) => {
914
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
915
+ return de_CommandError(output, context);
916
+ }
917
+ const contents = smithyClient.map({
918
+ $metadata: deserializeMetadata(output),
919
+ });
920
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
921
+ const doc = smithyClient.take(data, {
922
+ AccountSettings: smithyClient._json,
923
+ });
924
+ Object.assign(contents, doc);
925
+ return contents;
926
+ };
927
+ const de_UpdateGroupCommand = async (output, context) => {
928
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
929
+ return de_CommandError(output, context);
930
+ }
931
+ const contents = smithyClient.map({
932
+ $metadata: deserializeMetadata(output),
933
+ });
934
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
935
+ const doc = smithyClient.take(data, {
936
+ Group: smithyClient._json,
937
+ });
938
+ Object.assign(contents, doc);
939
+ return contents;
940
+ };
941
+ const de_UpdateGroupQueryCommand = async (output, context) => {
942
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
943
+ return de_CommandError(output, context);
944
+ }
945
+ const contents = smithyClient.map({
946
+ $metadata: deserializeMetadata(output),
947
+ });
948
+ const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
949
+ const doc = smithyClient.take(data, {
950
+ GroupQuery: smithyClient._json,
951
+ });
952
+ Object.assign(contents, doc);
953
+ return contents;
954
+ };
955
+ const de_CommandError = async (output, context) => {
956
+ const parsedOutput = {
957
+ ...output,
958
+ body: await core$1.parseJsonErrorBody(output.body, context),
959
+ };
960
+ const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
961
+ switch (errorCode) {
962
+ case "BadRequestException":
963
+ case "com.amazonaws.resourcegroups#BadRequestException":
964
+ throw await de_BadRequestExceptionRes(parsedOutput);
965
+ case "ForbiddenException":
966
+ case "com.amazonaws.resourcegroups#ForbiddenException":
967
+ throw await de_ForbiddenExceptionRes(parsedOutput);
968
+ case "InternalServerErrorException":
969
+ case "com.amazonaws.resourcegroups#InternalServerErrorException":
970
+ throw await de_InternalServerErrorExceptionRes(parsedOutput);
971
+ case "MethodNotAllowedException":
972
+ case "com.amazonaws.resourcegroups#MethodNotAllowedException":
973
+ throw await de_MethodNotAllowedExceptionRes(parsedOutput);
974
+ case "TooManyRequestsException":
975
+ case "com.amazonaws.resourcegroups#TooManyRequestsException":
976
+ throw await de_TooManyRequestsExceptionRes(parsedOutput);
977
+ case "UnauthorizedException":
978
+ case "com.amazonaws.resourcegroups#UnauthorizedException":
979
+ throw await de_UnauthorizedExceptionRes(parsedOutput);
980
+ case "NotFoundException":
981
+ case "com.amazonaws.resourcegroups#NotFoundException":
982
+ throw await de_NotFoundExceptionRes(parsedOutput);
983
+ default:
984
+ const parsedBody = parsedOutput.body;
985
+ return throwDefaultError({
986
+ output,
987
+ parsedBody,
988
+ errorCode,
989
+ });
990
+ }
991
+ };
992
+ const throwDefaultError = smithyClient.withBaseException(ResourceGroupsServiceException);
993
+ const de_BadRequestExceptionRes = async (parsedOutput, context) => {
994
+ const contents = smithyClient.map({});
995
+ const data = parsedOutput.body;
996
+ const doc = smithyClient.take(data, {
997
+ Message: smithyClient.expectString,
998
+ });
999
+ Object.assign(contents, doc);
1000
+ const exception = new BadRequestException({
1001
+ $metadata: deserializeMetadata(parsedOutput),
1002
+ ...contents,
1003
+ });
1004
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1005
+ };
1006
+ const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
1007
+ const contents = smithyClient.map({});
1008
+ const data = parsedOutput.body;
1009
+ const doc = smithyClient.take(data, {
1010
+ Message: smithyClient.expectString,
1011
+ });
1012
+ Object.assign(contents, doc);
1013
+ const exception = new ForbiddenException({
1014
+ $metadata: deserializeMetadata(parsedOutput),
1015
+ ...contents,
1016
+ });
1017
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1018
+ };
1019
+ const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
1020
+ const contents = smithyClient.map({});
1021
+ const data = parsedOutput.body;
1022
+ const doc = smithyClient.take(data, {
1023
+ Message: smithyClient.expectString,
1024
+ });
1025
+ Object.assign(contents, doc);
1026
+ const exception = new InternalServerErrorException({
1027
+ $metadata: deserializeMetadata(parsedOutput),
1028
+ ...contents,
1029
+ });
1030
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1031
+ };
1032
+ const de_MethodNotAllowedExceptionRes = async (parsedOutput, context) => {
1033
+ const contents = smithyClient.map({});
1034
+ const data = parsedOutput.body;
1035
+ const doc = smithyClient.take(data, {
1036
+ Message: smithyClient.expectString,
1037
+ });
1038
+ Object.assign(contents, doc);
1039
+ const exception = new MethodNotAllowedException({
1040
+ $metadata: deserializeMetadata(parsedOutput),
1041
+ ...contents,
1042
+ });
1043
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1044
+ };
1045
+ const de_NotFoundExceptionRes = async (parsedOutput, context) => {
1046
+ const contents = smithyClient.map({});
1047
+ const data = parsedOutput.body;
1048
+ const doc = smithyClient.take(data, {
1049
+ Message: smithyClient.expectString,
1050
+ });
1051
+ Object.assign(contents, doc);
1052
+ const exception = new NotFoundException({
1053
+ $metadata: deserializeMetadata(parsedOutput),
1054
+ ...contents,
1055
+ });
1056
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1057
+ };
1058
+ const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
1059
+ const contents = smithyClient.map({});
1060
+ const data = parsedOutput.body;
1061
+ const doc = smithyClient.take(data, {
1062
+ Message: smithyClient.expectString,
1063
+ });
1064
+ Object.assign(contents, doc);
1065
+ const exception = new TooManyRequestsException({
1066
+ $metadata: deserializeMetadata(parsedOutput),
1067
+ ...contents,
1068
+ });
1069
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1070
+ };
1071
+ const de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
1072
+ const contents = smithyClient.map({});
1073
+ const data = parsedOutput.body;
1074
+ const doc = smithyClient.take(data, {
1075
+ Message: smithyClient.expectString,
1076
+ });
1077
+ Object.assign(contents, doc);
1078
+ const exception = new UnauthorizedException({
1079
+ $metadata: deserializeMetadata(parsedOutput),
1080
+ ...contents,
1081
+ });
1082
+ return smithyClient.decorateServiceException(exception, parsedOutput.body);
1083
+ };
1084
+ const de_GroupingStatusesItem = (output, context) => {
1085
+ return smithyClient.take(output, {
1086
+ Action: smithyClient.expectString,
1087
+ ErrorCode: smithyClient.expectString,
1088
+ ErrorMessage: smithyClient.expectString,
1089
+ ResourceArn: smithyClient.expectString,
1090
+ Status: smithyClient.expectString,
1091
+ UpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1092
+ });
1093
+ };
1094
+ const de_GroupingStatusesList = (output, context) => {
1095
+ const retVal = (output || [])
1096
+ .filter((e) => e != null)
1097
+ .map((entry) => {
1098
+ return de_GroupingStatusesItem(entry);
1099
+ });
1100
+ return retVal;
1101
+ };
1102
+ const de_TagSyncTaskItem = (output, context) => {
1103
+ return smithyClient.take(output, {
1104
+ CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
1105
+ ErrorMessage: smithyClient.expectString,
1106
+ GroupArn: smithyClient.expectString,
1107
+ GroupName: smithyClient.expectString,
1108
+ ResourceQuery: smithyClient._json,
1109
+ RoleArn: smithyClient.expectString,
1110
+ Status: smithyClient.expectString,
1111
+ TagKey: smithyClient.expectString,
1112
+ TagValue: smithyClient.expectString,
1113
+ TaskArn: smithyClient.expectString,
1114
+ });
1115
+ };
1116
+ const de_TagSyncTaskList = (output, context) => {
1117
+ const retVal = (output || [])
1118
+ .filter((e) => e != null)
1119
+ .map((entry) => {
1120
+ return de_TagSyncTaskItem(entry);
1121
+ });
1122
+ return retVal;
1123
+ };
1124
+ const deserializeMetadata = (output) => ({
1125
+ httpStatusCode: output.statusCode,
1126
+ requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
1127
+ extendedRequestId: output.headers["x-amz-id-2"],
1128
+ cfId: output.headers["x-amz-cf-id"],
1129
+ });
1130
+ const _MR = "MaxResults";
1131
+ const _NT = "NextToken";
1132
+ const _mR = "maxResults";
1133
+ const _nT = "nextToken";
1134
+
1135
+ class CancelTagSyncTaskCommand extends smithyClient.Command
1136
+ .classBuilder()
1137
+ .ep(commonParams)
1138
+ .m(function (Command, cs, config, o) {
1139
+ return [
1140
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1141
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1142
+ ];
1143
+ })
1144
+ .s("Ardi", "CancelTagSyncTask", {})
1145
+ .n("ResourceGroupsClient", "CancelTagSyncTaskCommand")
1146
+ .f(void 0, void 0)
1147
+ .ser(se_CancelTagSyncTaskCommand)
1148
+ .de(de_CancelTagSyncTaskCommand)
1149
+ .build() {
1150
+ }
1151
+
1152
+ class CreateGroupCommand extends smithyClient.Command
1153
+ .classBuilder()
1154
+ .ep(commonParams)
1155
+ .m(function (Command, cs, config, o) {
1156
+ return [
1157
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1158
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1159
+ ];
1160
+ })
1161
+ .s("Ardi", "CreateGroup", {})
1162
+ .n("ResourceGroupsClient", "CreateGroupCommand")
1163
+ .f(void 0, void 0)
1164
+ .ser(se_CreateGroupCommand)
1165
+ .de(de_CreateGroupCommand)
1166
+ .build() {
1167
+ }
1168
+
1169
+ class DeleteGroupCommand extends smithyClient.Command
1170
+ .classBuilder()
1171
+ .ep(commonParams)
1172
+ .m(function (Command, cs, config, o) {
1173
+ return [
1174
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1175
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1176
+ ];
1177
+ })
1178
+ .s("Ardi", "DeleteGroup", {})
1179
+ .n("ResourceGroupsClient", "DeleteGroupCommand")
1180
+ .f(void 0, void 0)
1181
+ .ser(se_DeleteGroupCommand)
1182
+ .de(de_DeleteGroupCommand)
1183
+ .build() {
1184
+ }
1185
+
1186
+ class GetAccountSettingsCommand extends smithyClient.Command
1187
+ .classBuilder()
1188
+ .ep(commonParams)
1189
+ .m(function (Command, cs, config, o) {
1190
+ return [
1191
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1192
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1193
+ ];
1194
+ })
1195
+ .s("Ardi", "GetAccountSettings", {})
1196
+ .n("ResourceGroupsClient", "GetAccountSettingsCommand")
1197
+ .f(void 0, void 0)
1198
+ .ser(se_GetAccountSettingsCommand)
1199
+ .de(de_GetAccountSettingsCommand)
1200
+ .build() {
1201
+ }
1202
+
1203
+ class GetGroupCommand extends smithyClient.Command
1204
+ .classBuilder()
1205
+ .ep(commonParams)
1206
+ .m(function (Command, cs, config, o) {
1207
+ return [
1208
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1209
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1210
+ ];
1211
+ })
1212
+ .s("Ardi", "GetGroup", {})
1213
+ .n("ResourceGroupsClient", "GetGroupCommand")
1214
+ .f(void 0, void 0)
1215
+ .ser(se_GetGroupCommand)
1216
+ .de(de_GetGroupCommand)
1217
+ .build() {
1218
+ }
1219
+
1220
+ class GetGroupConfigurationCommand extends smithyClient.Command
1221
+ .classBuilder()
1222
+ .ep(commonParams)
1223
+ .m(function (Command, cs, config, o) {
1224
+ return [
1225
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1226
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1227
+ ];
1228
+ })
1229
+ .s("Ardi", "GetGroupConfiguration", {})
1230
+ .n("ResourceGroupsClient", "GetGroupConfigurationCommand")
1231
+ .f(void 0, void 0)
1232
+ .ser(se_GetGroupConfigurationCommand)
1233
+ .de(de_GetGroupConfigurationCommand)
1234
+ .build() {
1235
+ }
1236
+
1237
+ class GetGroupQueryCommand extends smithyClient.Command
1238
+ .classBuilder()
1239
+ .ep(commonParams)
1240
+ .m(function (Command, cs, config, o) {
1241
+ return [
1242
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1243
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1244
+ ];
1245
+ })
1246
+ .s("Ardi", "GetGroupQuery", {})
1247
+ .n("ResourceGroupsClient", "GetGroupQueryCommand")
1248
+ .f(void 0, void 0)
1249
+ .ser(se_GetGroupQueryCommand)
1250
+ .de(de_GetGroupQueryCommand)
1251
+ .build() {
1252
+ }
1253
+
1254
+ class GetTagsCommand extends smithyClient.Command
1255
+ .classBuilder()
1256
+ .ep(commonParams)
1257
+ .m(function (Command, cs, config, o) {
1258
+ return [
1259
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1260
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1261
+ ];
1262
+ })
1263
+ .s("Ardi", "GetTags", {})
1264
+ .n("ResourceGroupsClient", "GetTagsCommand")
1265
+ .f(void 0, void 0)
1266
+ .ser(se_GetTagsCommand)
1267
+ .de(de_GetTagsCommand)
1268
+ .build() {
1269
+ }
1270
+
1271
+ class GetTagSyncTaskCommand extends smithyClient.Command
1272
+ .classBuilder()
1273
+ .ep(commonParams)
1274
+ .m(function (Command, cs, config, o) {
1275
+ return [
1276
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1277
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1278
+ ];
1279
+ })
1280
+ .s("Ardi", "GetTagSyncTask", {})
1281
+ .n("ResourceGroupsClient", "GetTagSyncTaskCommand")
1282
+ .f(void 0, void 0)
1283
+ .ser(se_GetTagSyncTaskCommand)
1284
+ .de(de_GetTagSyncTaskCommand)
1285
+ .build() {
1286
+ }
1287
+
1288
+ class GroupResourcesCommand extends smithyClient.Command
1289
+ .classBuilder()
1290
+ .ep(commonParams)
1291
+ .m(function (Command, cs, config, o) {
1292
+ return [
1293
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1294
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1295
+ ];
1296
+ })
1297
+ .s("Ardi", "GroupResources", {})
1298
+ .n("ResourceGroupsClient", "GroupResourcesCommand")
1299
+ .f(void 0, void 0)
1300
+ .ser(se_GroupResourcesCommand)
1301
+ .de(de_GroupResourcesCommand)
1302
+ .build() {
1303
+ }
1304
+
1305
+ class ListGroupingStatusesCommand extends smithyClient.Command
1306
+ .classBuilder()
1307
+ .ep(commonParams)
1308
+ .m(function (Command, cs, config, o) {
1309
+ return [
1310
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1311
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1312
+ ];
1313
+ })
1314
+ .s("Ardi", "ListGroupingStatuses", {})
1315
+ .n("ResourceGroupsClient", "ListGroupingStatusesCommand")
1316
+ .f(void 0, void 0)
1317
+ .ser(se_ListGroupingStatusesCommand)
1318
+ .de(de_ListGroupingStatusesCommand)
1319
+ .build() {
1320
+ }
1321
+
1322
+ class ListGroupResourcesCommand extends smithyClient.Command
1323
+ .classBuilder()
1324
+ .ep(commonParams)
1325
+ .m(function (Command, cs, config, o) {
1326
+ return [
1327
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1328
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1329
+ ];
1330
+ })
1331
+ .s("Ardi", "ListGroupResources", {})
1332
+ .n("ResourceGroupsClient", "ListGroupResourcesCommand")
1333
+ .f(void 0, void 0)
1334
+ .ser(se_ListGroupResourcesCommand)
1335
+ .de(de_ListGroupResourcesCommand)
1336
+ .build() {
1337
+ }
1338
+
1339
+ class ListGroupsCommand extends smithyClient.Command
1340
+ .classBuilder()
1341
+ .ep(commonParams)
1342
+ .m(function (Command, cs, config, o) {
1343
+ return [
1344
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1345
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1346
+ ];
1347
+ })
1348
+ .s("Ardi", "ListGroups", {})
1349
+ .n("ResourceGroupsClient", "ListGroupsCommand")
1350
+ .f(void 0, void 0)
1351
+ .ser(se_ListGroupsCommand)
1352
+ .de(de_ListGroupsCommand)
1353
+ .build() {
1354
+ }
1355
+
1356
+ class ListTagSyncTasksCommand extends smithyClient.Command
1357
+ .classBuilder()
1358
+ .ep(commonParams)
1359
+ .m(function (Command, cs, config, o) {
1360
+ return [
1361
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1362
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1363
+ ];
1364
+ })
1365
+ .s("Ardi", "ListTagSyncTasks", {})
1366
+ .n("ResourceGroupsClient", "ListTagSyncTasksCommand")
1367
+ .f(void 0, void 0)
1368
+ .ser(se_ListTagSyncTasksCommand)
1369
+ .de(de_ListTagSyncTasksCommand)
1370
+ .build() {
1371
+ }
1372
+
1373
+ class PutGroupConfigurationCommand extends smithyClient.Command
1374
+ .classBuilder()
1375
+ .ep(commonParams)
1376
+ .m(function (Command, cs, config, o) {
1377
+ return [
1378
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1379
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1380
+ ];
1381
+ })
1382
+ .s("Ardi", "PutGroupConfiguration", {})
1383
+ .n("ResourceGroupsClient", "PutGroupConfigurationCommand")
1384
+ .f(void 0, void 0)
1385
+ .ser(se_PutGroupConfigurationCommand)
1386
+ .de(de_PutGroupConfigurationCommand)
1387
+ .build() {
1388
+ }
1389
+
1390
+ class SearchResourcesCommand extends smithyClient.Command
1391
+ .classBuilder()
1392
+ .ep(commonParams)
1393
+ .m(function (Command, cs, config, o) {
1394
+ return [
1395
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1396
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1397
+ ];
1398
+ })
1399
+ .s("Ardi", "SearchResources", {})
1400
+ .n("ResourceGroupsClient", "SearchResourcesCommand")
1401
+ .f(void 0, void 0)
1402
+ .ser(se_SearchResourcesCommand)
1403
+ .de(de_SearchResourcesCommand)
1404
+ .build() {
1405
+ }
1406
+
1407
+ class StartTagSyncTaskCommand extends smithyClient.Command
1408
+ .classBuilder()
1409
+ .ep(commonParams)
1410
+ .m(function (Command, cs, config, o) {
1411
+ return [
1412
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1413
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1414
+ ];
1415
+ })
1416
+ .s("Ardi", "StartTagSyncTask", {})
1417
+ .n("ResourceGroupsClient", "StartTagSyncTaskCommand")
1418
+ .f(void 0, void 0)
1419
+ .ser(se_StartTagSyncTaskCommand)
1420
+ .de(de_StartTagSyncTaskCommand)
1421
+ .build() {
1422
+ }
1423
+
1424
+ class TagCommand extends smithyClient.Command
1425
+ .classBuilder()
1426
+ .ep(commonParams)
1427
+ .m(function (Command, cs, config, o) {
1428
+ return [
1429
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1430
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1431
+ ];
1432
+ })
1433
+ .s("Ardi", "Tag", {})
1434
+ .n("ResourceGroupsClient", "TagCommand")
1435
+ .f(void 0, void 0)
1436
+ .ser(se_TagCommand)
1437
+ .de(de_TagCommand)
1438
+ .build() {
1439
+ }
1440
+
1441
+ class UngroupResourcesCommand extends smithyClient.Command
1442
+ .classBuilder()
1443
+ .ep(commonParams)
1444
+ .m(function (Command, cs, config, o) {
1445
+ return [
1446
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1447
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1448
+ ];
1449
+ })
1450
+ .s("Ardi", "UngroupResources", {})
1451
+ .n("ResourceGroupsClient", "UngroupResourcesCommand")
1452
+ .f(void 0, void 0)
1453
+ .ser(se_UngroupResourcesCommand)
1454
+ .de(de_UngroupResourcesCommand)
1455
+ .build() {
1456
+ }
1457
+
1458
+ class UntagCommand extends smithyClient.Command
1459
+ .classBuilder()
1460
+ .ep(commonParams)
1461
+ .m(function (Command, cs, config, o) {
1462
+ return [
1463
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1464
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1465
+ ];
1466
+ })
1467
+ .s("Ardi", "Untag", {})
1468
+ .n("ResourceGroupsClient", "UntagCommand")
1469
+ .f(void 0, void 0)
1470
+ .ser(se_UntagCommand)
1471
+ .de(de_UntagCommand)
1472
+ .build() {
1473
+ }
1474
+
1475
+ class UpdateAccountSettingsCommand extends smithyClient.Command
1476
+ .classBuilder()
1477
+ .ep(commonParams)
1478
+ .m(function (Command, cs, config, o) {
1479
+ return [
1480
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1481
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1482
+ ];
1483
+ })
1484
+ .s("Ardi", "UpdateAccountSettings", {})
1485
+ .n("ResourceGroupsClient", "UpdateAccountSettingsCommand")
1486
+ .f(void 0, void 0)
1487
+ .ser(se_UpdateAccountSettingsCommand)
1488
+ .de(de_UpdateAccountSettingsCommand)
1489
+ .build() {
1490
+ }
1491
+
1492
+ class UpdateGroupCommand extends smithyClient.Command
1493
+ .classBuilder()
1494
+ .ep(commonParams)
1495
+ .m(function (Command, cs, config, o) {
1496
+ return [
1497
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1498
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1499
+ ];
1500
+ })
1501
+ .s("Ardi", "UpdateGroup", {})
1502
+ .n("ResourceGroupsClient", "UpdateGroupCommand")
1503
+ .f(void 0, void 0)
1504
+ .ser(se_UpdateGroupCommand)
1505
+ .de(de_UpdateGroupCommand)
1506
+ .build() {
1507
+ }
1508
+
1509
+ class UpdateGroupQueryCommand extends smithyClient.Command
1510
+ .classBuilder()
1511
+ .ep(commonParams)
1512
+ .m(function (Command, cs, config, o) {
1513
+ return [
1514
+ middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
1515
+ middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
1516
+ ];
1517
+ })
1518
+ .s("Ardi", "UpdateGroupQuery", {})
1519
+ .n("ResourceGroupsClient", "UpdateGroupQueryCommand")
1520
+ .f(void 0, void 0)
1521
+ .ser(se_UpdateGroupQueryCommand)
1522
+ .de(de_UpdateGroupQueryCommand)
1523
+ .build() {
1524
+ }
1525
+
1526
+ const commands = {
1527
+ CancelTagSyncTaskCommand,
1528
+ CreateGroupCommand,
1529
+ DeleteGroupCommand,
1530
+ GetAccountSettingsCommand,
1531
+ GetGroupCommand,
1532
+ GetGroupConfigurationCommand,
1533
+ GetGroupQueryCommand,
1534
+ GetTagsCommand,
1535
+ GetTagSyncTaskCommand,
1536
+ GroupResourcesCommand,
1537
+ ListGroupingStatusesCommand,
1538
+ ListGroupResourcesCommand,
1539
+ ListGroupsCommand,
1540
+ ListTagSyncTasksCommand,
1541
+ PutGroupConfigurationCommand,
1542
+ SearchResourcesCommand,
1543
+ StartTagSyncTaskCommand,
1544
+ TagCommand,
1545
+ UngroupResourcesCommand,
1546
+ UntagCommand,
1547
+ UpdateAccountSettingsCommand,
1548
+ UpdateGroupCommand,
1549
+ UpdateGroupQueryCommand,
1550
+ };
1551
+ class ResourceGroups extends ResourceGroupsClient {
1552
+ }
1553
+ smithyClient.createAggregatedClient(commands, ResourceGroups);
1685
1554
 
1686
- // src/ResourceGroups.ts
1687
- var commands = {
1688
- CancelTagSyncTaskCommand,
1689
- CreateGroupCommand,
1690
- DeleteGroupCommand,
1691
- GetAccountSettingsCommand,
1692
- GetGroupCommand,
1693
- GetGroupConfigurationCommand,
1694
- GetGroupQueryCommand,
1695
- GetTagsCommand,
1696
- GetTagSyncTaskCommand,
1697
- GroupResourcesCommand,
1698
- ListGroupingStatusesCommand,
1699
- ListGroupResourcesCommand,
1700
- ListGroupsCommand,
1701
- ListTagSyncTasksCommand,
1702
- PutGroupConfigurationCommand,
1703
- SearchResourcesCommand,
1704
- StartTagSyncTaskCommand,
1705
- TagCommand,
1706
- UngroupResourcesCommand,
1707
- UntagCommand,
1708
- UpdateAccountSettingsCommand,
1709
- UpdateGroupCommand,
1710
- UpdateGroupQueryCommand
1711
- };
1712
- var ResourceGroups = class extends ResourceGroupsClient {
1713
- static {
1714
- __name(this, "ResourceGroups");
1715
- }
1716
- };
1717
- (0, import_smithy_client.createAggregatedClient)(commands, ResourceGroups);
1718
-
1719
- // src/pagination/ListGroupResourcesPaginator.ts
1720
-
1721
- var paginateListGroupResources = (0, import_core.createPaginator)(ResourceGroupsClient, ListGroupResourcesCommand, "NextToken", "NextToken", "MaxResults");
1722
-
1723
- // src/pagination/ListGroupingStatusesPaginator.ts
1724
-
1725
- var paginateListGroupingStatuses = (0, import_core.createPaginator)(ResourceGroupsClient, ListGroupingStatusesCommand, "NextToken", "NextToken", "MaxResults");
1726
-
1727
- // src/pagination/ListGroupsPaginator.ts
1728
-
1729
- var paginateListGroups = (0, import_core.createPaginator)(ResourceGroupsClient, ListGroupsCommand, "NextToken", "NextToken", "MaxResults");
1555
+ const paginateListGroupResources = core.createPaginator(ResourceGroupsClient, ListGroupResourcesCommand, "NextToken", "NextToken", "MaxResults");
1730
1556
 
1731
- // src/pagination/ListTagSyncTasksPaginator.ts
1557
+ const paginateListGroupingStatuses = core.createPaginator(ResourceGroupsClient, ListGroupingStatusesCommand, "NextToken", "NextToken", "MaxResults");
1732
1558
 
1733
- var paginateListTagSyncTasks = (0, import_core.createPaginator)(ResourceGroupsClient, ListTagSyncTasksCommand, "NextToken", "NextToken", "MaxResults");
1559
+ const paginateListGroups = core.createPaginator(ResourceGroupsClient, ListGroupsCommand, "NextToken", "NextToken", "MaxResults");
1734
1560
 
1735
- // src/pagination/SearchResourcesPaginator.ts
1561
+ const paginateListTagSyncTasks = core.createPaginator(ResourceGroupsClient, ListTagSyncTasksCommand, "NextToken", "NextToken", "MaxResults");
1736
1562
 
1737
- var paginateSearchResources = (0, import_core.createPaginator)(ResourceGroupsClient, SearchResourcesCommand, "NextToken", "NextToken", "MaxResults");
1738
- // Annotate the CommonJS export names for ESM import in node:
1563
+ const paginateSearchResources = core.createPaginator(ResourceGroupsClient, SearchResourcesCommand, "NextToken", "NextToken", "MaxResults");
1739
1564
 
1740
- 0 && (module.exports = {
1741
- ResourceGroupsServiceException,
1742
- __Client,
1743
- ResourceGroupsClient,
1744
- ResourceGroups,
1745
- $Command,
1746
- CancelTagSyncTaskCommand,
1747
- CreateGroupCommand,
1748
- DeleteGroupCommand,
1749
- GetAccountSettingsCommand,
1750
- GetGroupCommand,
1751
- GetGroupConfigurationCommand,
1752
- GetGroupQueryCommand,
1753
- GetTagSyncTaskCommand,
1754
- GetTagsCommand,
1755
- GroupResourcesCommand,
1756
- ListGroupResourcesCommand,
1757
- ListGroupingStatusesCommand,
1758
- ListGroupsCommand,
1759
- ListTagSyncTasksCommand,
1760
- PutGroupConfigurationCommand,
1761
- SearchResourcesCommand,
1762
- StartTagSyncTaskCommand,
1763
- TagCommand,
1764
- UngroupResourcesCommand,
1765
- UntagCommand,
1766
- UpdateAccountSettingsCommand,
1767
- UpdateGroupCommand,
1768
- UpdateGroupQueryCommand,
1769
- paginateListGroupResources,
1770
- paginateListGroupingStatuses,
1771
- paginateListGroups,
1772
- paginateListTagSyncTasks,
1773
- paginateSearchResources,
1774
- GroupLifecycleEventsDesiredStatus,
1775
- GroupLifecycleEventsStatus,
1776
- BadRequestException,
1777
- ForbiddenException,
1778
- InternalServerErrorException,
1779
- MethodNotAllowedException,
1780
- TooManyRequestsException,
1781
- UnauthorizedException,
1782
- QueryType,
1783
- GroupConfigurationStatus,
1784
- NotFoundException,
1785
- TagSyncTaskStatus,
1786
- ListGroupingStatusesFilterName,
1787
- GroupingType,
1788
- GroupingStatus,
1789
- ResourceFilterName,
1790
- QueryErrorCode,
1791
- ResourceStatusValue,
1792
- GroupFilterName
1565
+ Object.defineProperty(exports, "$Command", {
1566
+ enumerable: true,
1567
+ get: function () { return smithyClient.Command; }
1793
1568
  });
1794
-
1569
+ Object.defineProperty(exports, "__Client", {
1570
+ enumerable: true,
1571
+ get: function () { return smithyClient.Client; }
1572
+ });
1573
+ exports.BadRequestException = BadRequestException;
1574
+ exports.CancelTagSyncTaskCommand = CancelTagSyncTaskCommand;
1575
+ exports.CreateGroupCommand = CreateGroupCommand;
1576
+ exports.DeleteGroupCommand = DeleteGroupCommand;
1577
+ exports.ForbiddenException = ForbiddenException;
1578
+ exports.GetAccountSettingsCommand = GetAccountSettingsCommand;
1579
+ exports.GetGroupCommand = GetGroupCommand;
1580
+ exports.GetGroupConfigurationCommand = GetGroupConfigurationCommand;
1581
+ exports.GetGroupQueryCommand = GetGroupQueryCommand;
1582
+ exports.GetTagSyncTaskCommand = GetTagSyncTaskCommand;
1583
+ exports.GetTagsCommand = GetTagsCommand;
1584
+ exports.GroupConfigurationStatus = GroupConfigurationStatus;
1585
+ exports.GroupFilterName = GroupFilterName;
1586
+ exports.GroupLifecycleEventsDesiredStatus = GroupLifecycleEventsDesiredStatus;
1587
+ exports.GroupLifecycleEventsStatus = GroupLifecycleEventsStatus;
1588
+ exports.GroupResourcesCommand = GroupResourcesCommand;
1589
+ exports.GroupingStatus = GroupingStatus;
1590
+ exports.GroupingType = GroupingType;
1591
+ exports.InternalServerErrorException = InternalServerErrorException;
1592
+ exports.ListGroupResourcesCommand = ListGroupResourcesCommand;
1593
+ exports.ListGroupingStatusesCommand = ListGroupingStatusesCommand;
1594
+ exports.ListGroupingStatusesFilterName = ListGroupingStatusesFilterName;
1595
+ exports.ListGroupsCommand = ListGroupsCommand;
1596
+ exports.ListTagSyncTasksCommand = ListTagSyncTasksCommand;
1597
+ exports.MethodNotAllowedException = MethodNotAllowedException;
1598
+ exports.NotFoundException = NotFoundException;
1599
+ exports.PutGroupConfigurationCommand = PutGroupConfigurationCommand;
1600
+ exports.QueryErrorCode = QueryErrorCode;
1601
+ exports.QueryType = QueryType;
1602
+ exports.ResourceFilterName = ResourceFilterName;
1603
+ exports.ResourceGroups = ResourceGroups;
1604
+ exports.ResourceGroupsClient = ResourceGroupsClient;
1605
+ exports.ResourceGroupsServiceException = ResourceGroupsServiceException;
1606
+ exports.ResourceStatusValue = ResourceStatusValue;
1607
+ exports.SearchResourcesCommand = SearchResourcesCommand;
1608
+ exports.StartTagSyncTaskCommand = StartTagSyncTaskCommand;
1609
+ exports.TagCommand = TagCommand;
1610
+ exports.TagSyncTaskStatus = TagSyncTaskStatus;
1611
+ exports.TooManyRequestsException = TooManyRequestsException;
1612
+ exports.UnauthorizedException = UnauthorizedException;
1613
+ exports.UngroupResourcesCommand = UngroupResourcesCommand;
1614
+ exports.UntagCommand = UntagCommand;
1615
+ exports.UpdateAccountSettingsCommand = UpdateAccountSettingsCommand;
1616
+ exports.UpdateGroupCommand = UpdateGroupCommand;
1617
+ exports.UpdateGroupQueryCommand = UpdateGroupQueryCommand;
1618
+ exports.paginateListGroupResources = paginateListGroupResources;
1619
+ exports.paginateListGroupingStatuses = paginateListGroupingStatuses;
1620
+ exports.paginateListGroups = paginateListGroups;
1621
+ exports.paginateListTagSyncTasks = paginateListTagSyncTasks;
1622
+ exports.paginateSearchResources = paginateSearchResources;