@aws-sdk/client-resource-groups 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,2025 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceGroupsServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ResourceGroupsClient"), exports);
-tslib_1.__exportStar(require("./ResourceGroups"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var ResourceGroupsServiceException_1 = require("./models/ResourceGroupsServiceException");
-Object.defineProperty(exports, "ResourceGroupsServiceException", { enumerable: true, get: function () { return ResourceGroupsServiceException_1.ResourceGroupsServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BadRequestException: () => BadRequestException,
+  CreateGroupCommand: () => CreateGroupCommand,
+  DeleteGroupCommand: () => DeleteGroupCommand,
+  ForbiddenException: () => ForbiddenException,
+  GetAccountSettingsCommand: () => GetAccountSettingsCommand,
+  GetGroupCommand: () => GetGroupCommand,
+  GetGroupConfigurationCommand: () => GetGroupConfigurationCommand,
+  GetGroupQueryCommand: () => GetGroupQueryCommand,
+  GetTagsCommand: () => GetTagsCommand,
+  GroupConfigurationStatus: () => GroupConfigurationStatus,
+  GroupFilterName: () => GroupFilterName,
+  GroupLifecycleEventsDesiredStatus: () => GroupLifecycleEventsDesiredStatus,
+  GroupLifecycleEventsStatus: () => GroupLifecycleEventsStatus,
+  GroupResourcesCommand: () => GroupResourcesCommand,
+  InternalServerErrorException: () => InternalServerErrorException,
+  ListGroupResourcesCommand: () => ListGroupResourcesCommand,
+  ListGroupsCommand: () => ListGroupsCommand,
+  MethodNotAllowedException: () => MethodNotAllowedException,
+  NotFoundException: () => NotFoundException,
+  PutGroupConfigurationCommand: () => PutGroupConfigurationCommand,
+  QueryErrorCode: () => QueryErrorCode,
+  QueryType: () => QueryType,
+  ResourceFilterName: () => ResourceFilterName,
+  ResourceGroups: () => ResourceGroups,
+  ResourceGroupsClient: () => ResourceGroupsClient,
+  ResourceGroupsServiceException: () => ResourceGroupsServiceException,
+  ResourceStatusValue: () => ResourceStatusValue,
+  SearchResourcesCommand: () => SearchResourcesCommand,
+  TagCommand: () => TagCommand,
+  TooManyRequestsException: () => TooManyRequestsException,
+  UnauthorizedException: () => UnauthorizedException,
+  UngroupResourcesCommand: () => UngroupResourcesCommand,
+  UntagCommand: () => UntagCommand,
+  UpdateAccountSettingsCommand: () => UpdateAccountSettingsCommand,
+  UpdateGroupCommand: () => UpdateGroupCommand,
+  UpdateGroupQueryCommand: () => UpdateGroupQueryCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateListGroupResources: () => paginateListGroupResources,
+  paginateListGroups: () => paginateListGroups,
+  paginateSearchResources: () => paginateSearchResources
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ResourceGroupsClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "resource-groups"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ResourceGroupsClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/ResourceGroupsClient.ts
+var _ResourceGroupsClient = class _ResourceGroupsClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_ResourceGroupsClient, "ResourceGroupsClient");
+var ResourceGroupsClient = _ResourceGroupsClient;
+
+// src/ResourceGroups.ts
+
+
+// src/commands/CreateGroupCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+
+// src/models/ResourceGroupsServiceException.ts
+
+var _ResourceGroupsServiceException = class _ResourceGroupsServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ResourceGroupsServiceException.prototype);
+  }
+};
+__name(_ResourceGroupsServiceException, "ResourceGroupsServiceException");
+var ResourceGroupsServiceException = _ResourceGroupsServiceException;
+
+// src/models/models_0.ts
+var GroupLifecycleEventsDesiredStatus = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE"
+};
+var GroupLifecycleEventsStatus = {
+  ACTIVE: "ACTIVE",
+  ERROR: "ERROR",
+  INACTIVE: "INACTIVE",
+  IN_PROGRESS: "IN_PROGRESS"
+};
+var _BadRequestException = class _BadRequestException extends ResourceGroupsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var QueryType = {
+  CLOUDFORMATION_STACK_1_0: "CLOUDFORMATION_STACK_1_0",
+  TAG_FILTERS_1_0: "TAG_FILTERS_1_0"
+};
+var GroupConfigurationStatus = {
+  UPDATE_COMPLETE: "UPDATE_COMPLETE",
+  UPDATE_FAILED: "UPDATE_FAILED",
+  UPDATING: "UPDATING"
+};
+var _ForbiddenException = class _ForbiddenException extends ResourceGroupsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ForbiddenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ForbiddenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ForbiddenException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ForbiddenException, "ForbiddenException");
+var ForbiddenException = _ForbiddenException;
+var _InternalServerErrorException = class _InternalServerErrorException extends ResourceGroupsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerErrorException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerErrorException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerErrorException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalServerErrorException, "InternalServerErrorException");
+var InternalServerErrorException = _InternalServerErrorException;
+var _MethodNotAllowedException = class _MethodNotAllowedException extends ResourceGroupsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MethodNotAllowedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MethodNotAllowedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MethodNotAllowedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_MethodNotAllowedException, "MethodNotAllowedException");
+var MethodNotAllowedException = _MethodNotAllowedException;
+var _TooManyRequestsException = class _TooManyRequestsException extends ResourceGroupsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyRequestsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyRequestsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_TooManyRequestsException, "TooManyRequestsException");
+var TooManyRequestsException = _TooManyRequestsException;
+var _NotFoundException = class _NotFoundException extends ResourceGroupsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var ResourceFilterName = {
+  ResourceType: "resource-type"
+};
+var QueryErrorCode = {
+  CLOUDFORMATION_STACK_INACTIVE: "CLOUDFORMATION_STACK_INACTIVE",
+  CLOUDFORMATION_STACK_NOT_EXISTING: "CLOUDFORMATION_STACK_NOT_EXISTING",
+  CLOUDFORMATION_STACK_UNASSUMABLE_ROLE: "CLOUDFORMATION_STACK_UNASSUMABLE_ROLE"
+};
+var ResourceStatusValue = {
+  Pending: "PENDING"
+};
+var _UnauthorizedException = class _UnauthorizedException extends ResourceGroupsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnauthorizedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnauthorizedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnauthorizedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_UnauthorizedException, "UnauthorizedException");
+var UnauthorizedException = _UnauthorizedException;
+var GroupFilterName = {
+  ConfigurationType: "configuration-type",
+  ResourceType: "resource-type"
+};
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/groups");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Configuration: (_) => (0, import_smithy_client._json)(_),
+      Description: [],
+      Name: [],
+      ResourceQuery: (_) => (0, import_smithy_client._json)(_),
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateGroupCommand");
+var se_DeleteGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/delete-group");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Group: [],
+      GroupName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteGroupCommand");
+var se_GetAccountSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/get-account-settings");
+  let body;
+  body = "";
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetAccountSettingsCommand");
+var se_GetGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/get-group");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Group: [],
+      GroupName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetGroupCommand");
+var se_GetGroupConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/get-group-configuration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Group: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetGroupConfigurationCommand");
+var se_GetGroupQueryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/get-group-query");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Group: [],
+      GroupName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetGroupQueryCommand");
+var se_GetTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/resources/{Arn}/tags");
+  b.p("Arn", () => input.Arn, "{Arn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTagsCommand");
+var se_GroupResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/group-resources");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Group: [],
+      ResourceArns: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GroupResourcesCommand");
+var se_ListGroupResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/list-group-resources");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Filters: (_) => (0, import_smithy_client._json)(_),
+      Group: [],
+      GroupName: [],
+      MaxResults: [],
+      NextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListGroupResourcesCommand");
+var se_ListGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/groups-list");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Filters: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListGroupsCommand");
+var se_PutGroupConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/put-group-configuration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Configuration: (_) => (0, import_smithy_client._json)(_),
+      Group: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutGroupConfigurationCommand");
+var se_SearchResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/resources/search");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      NextToken: [],
+      ResourceQuery: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_SearchResourcesCommand");
+var se_TagCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/resources/{Arn}/tags");
+  b.p("Arn", () => input.Arn, "{Arn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_TagCommand");
+var se_UngroupResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ungroup-resources");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Group: [],
+      ResourceArns: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UngroupResourcesCommand");
+var se_UntagCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/resources/{Arn}/tags");
+  b.p("Arn", () => input.Arn, "{Arn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Keys: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_UntagCommand");
+var se_UpdateAccountSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/update-account-settings");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      GroupLifecycleEventsDesiredStatus: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateAccountSettingsCommand");
+var se_UpdateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/update-group");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Description: [],
+      Group: [],
+      GroupName: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateGroupCommand");
+var se_UpdateGroupQueryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/update-group-query");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Group: [],
+      GroupName: [],
+      ResourceQuery: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateGroupQueryCommand");
+var de_CreateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Group: import_smithy_client._json,
+    GroupConfiguration: import_smithy_client._json,
+    ResourceQuery: import_smithy_client._json,
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateGroupCommand");
+var de_CreateGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateGroupCommandError");
+var de_DeleteGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Group: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteGroupCommand");
+var de_DeleteGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteGroupCommandError");
+var de_GetAccountSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetAccountSettingsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    AccountSettings: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetAccountSettingsCommand");
+var de_GetAccountSettingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAccountSettingsCommandError");
+var de_GetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Group: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGroupCommand");
+var de_GetGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetGroupCommandError");
+var de_GetGroupConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGroupConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    GroupConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGroupConfigurationCommand");
+var de_GetGroupConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetGroupConfigurationCommandError");
+var de_GetGroupQueryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGroupQueryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    GroupQuery: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGroupQueryCommand");
+var de_GetGroupQueryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetGroupQueryCommandError");
+var de_GetTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTagsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTagsCommand");
+var de_GetTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTagsCommandError");
+var de_GroupResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GroupResourcesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Failed: import_smithy_client._json,
+    Pending: import_smithy_client._json,
+    Succeeded: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GroupResourcesCommand");
+var de_GroupResourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GroupResourcesCommandError");
+var de_ListGroupResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListGroupResourcesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    QueryErrors: import_smithy_client._json,
+    ResourceIdentifiers: import_smithy_client._json,
+    Resources: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListGroupResourcesCommand");
+var de_ListGroupResourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.resourcegroups#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListGroupResourcesCommandError");
+var de_ListGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListGroupsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    GroupIdentifiers: import_smithy_client._json,
+    Groups: import_smithy_client._json,
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListGroupsCommand");
+var de_ListGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListGroupsCommandError");
+var de_PutGroupConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 202 && output.statusCode >= 300) {
+    return de_PutGroupConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutGroupConfigurationCommand");
+var de_PutGroupConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutGroupConfigurationCommandError");
+var de_SearchResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_SearchResourcesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    QueryErrors: import_smithy_client._json,
+    ResourceIdentifiers: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_SearchResourcesCommand");
+var de_SearchResourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    case "UnauthorizedException":
+    case "com.amazonaws.resourcegroups#UnauthorizedException":
+      throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchResourcesCommandError");
+var de_TagCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_TagCommand");
+var de_TagCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagCommandError");
+var de_UngroupResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UngroupResourcesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Failed: import_smithy_client._json,
+    Pending: import_smithy_client._json,
+    Succeeded: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UngroupResourcesCommand");
+var de_UngroupResourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UngroupResourcesCommandError");
+var de_UntagCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    Keys: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UntagCommand");
+var de_UntagCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagCommandError");
+var de_UpdateAccountSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateAccountSettingsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    AccountSettings: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateAccountSettingsCommand");
+var de_UpdateAccountSettingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateAccountSettingsCommandError");
+var de_UpdateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Group: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateGroupCommand");
+var de_UpdateGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateGroupCommandError");
+var de_UpdateGroupQueryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateGroupQueryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    GroupQuery: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateGroupQueryCommand");
+var de_UpdateGroupQueryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.resourcegroups#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.resourcegroups#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.resourcegroups#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "MethodNotAllowedException":
+    case "com.amazonaws.resourcegroups#MethodNotAllowedException":
+      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.resourcegroups#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.resourcegroups#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateGroupQueryCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(ResourceGroupsServiceException);
+var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new BadRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_BadRequestExceptionRes");
+var de_ForbiddenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ForbiddenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ForbiddenExceptionRes");
+var de_InternalServerErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerErrorExceptionRes");
+var de_MethodNotAllowedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new MethodNotAllowedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_MethodNotAllowedExceptionRes");
+var de_NotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new NotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_NotFoundExceptionRes");
+var de_TooManyRequestsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new TooManyRequestsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyRequestsExceptionRes");
+var de_UnauthorizedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new UnauthorizedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_UnauthorizedExceptionRes");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var _MR = "MaxResults";
+var _NT = "NextToken";
+var _mR = "maxResults";
+var _nT = "nextToken";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CreateGroupCommand.ts
+var _CreateGroupCommand = class _CreateGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "CreateGroup", {}).n("ResourceGroupsClient", "CreateGroupCommand").f(void 0, void 0).ser(se_CreateGroupCommand).de(de_CreateGroupCommand).build() {
+};
+__name(_CreateGroupCommand, "CreateGroupCommand");
+var CreateGroupCommand = _CreateGroupCommand;
+
+// src/commands/DeleteGroupCommand.ts
+
+
+
+
+var _DeleteGroupCommand = class _DeleteGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "DeleteGroup", {}).n("ResourceGroupsClient", "DeleteGroupCommand").f(void 0, void 0).ser(se_DeleteGroupCommand).de(de_DeleteGroupCommand).build() {
+};
+__name(_DeleteGroupCommand, "DeleteGroupCommand");
+var DeleteGroupCommand = _DeleteGroupCommand;
+
+// src/commands/GetAccountSettingsCommand.ts
+
+
+
+
+var _GetAccountSettingsCommand = class _GetAccountSettingsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "GetAccountSettings", {}).n("ResourceGroupsClient", "GetAccountSettingsCommand").f(void 0, void 0).ser(se_GetAccountSettingsCommand).de(de_GetAccountSettingsCommand).build() {
+};
+__name(_GetAccountSettingsCommand, "GetAccountSettingsCommand");
+var GetAccountSettingsCommand = _GetAccountSettingsCommand;
+
+// src/commands/GetGroupCommand.ts
+
+
+
+
+var _GetGroupCommand = class _GetGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "GetGroup", {}).n("ResourceGroupsClient", "GetGroupCommand").f(void 0, void 0).ser(se_GetGroupCommand).de(de_GetGroupCommand).build() {
+};
+__name(_GetGroupCommand, "GetGroupCommand");
+var GetGroupCommand = _GetGroupCommand;
+
+// src/commands/GetGroupConfigurationCommand.ts
+
+
+
+
+var _GetGroupConfigurationCommand = class _GetGroupConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "GetGroupConfiguration", {}).n("ResourceGroupsClient", "GetGroupConfigurationCommand").f(void 0, void 0).ser(se_GetGroupConfigurationCommand).de(de_GetGroupConfigurationCommand).build() {
+};
+__name(_GetGroupConfigurationCommand, "GetGroupConfigurationCommand");
+var GetGroupConfigurationCommand = _GetGroupConfigurationCommand;
+
+// src/commands/GetGroupQueryCommand.ts
+
+
+
+
+var _GetGroupQueryCommand = class _GetGroupQueryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "GetGroupQuery", {}).n("ResourceGroupsClient", "GetGroupQueryCommand").f(void 0, void 0).ser(se_GetGroupQueryCommand).de(de_GetGroupQueryCommand).build() {
+};
+__name(_GetGroupQueryCommand, "GetGroupQueryCommand");
+var GetGroupQueryCommand = _GetGroupQueryCommand;
+
+// src/commands/GetTagsCommand.ts
+
+
+
+
+var _GetTagsCommand = class _GetTagsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "GetTags", {}).n("ResourceGroupsClient", "GetTagsCommand").f(void 0, void 0).ser(se_GetTagsCommand).de(de_GetTagsCommand).build() {
+};
+__name(_GetTagsCommand, "GetTagsCommand");
+var GetTagsCommand = _GetTagsCommand;
+
+// src/commands/GroupResourcesCommand.ts
+
+
+
+
+var _GroupResourcesCommand = class _GroupResourcesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "GroupResources", {}).n("ResourceGroupsClient", "GroupResourcesCommand").f(void 0, void 0).ser(se_GroupResourcesCommand).de(de_GroupResourcesCommand).build() {
+};
+__name(_GroupResourcesCommand, "GroupResourcesCommand");
+var GroupResourcesCommand = _GroupResourcesCommand;
+
+// src/commands/ListGroupResourcesCommand.ts
+
+
+
+
+var _ListGroupResourcesCommand = class _ListGroupResourcesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "ListGroupResources", {}).n("ResourceGroupsClient", "ListGroupResourcesCommand").f(void 0, void 0).ser(se_ListGroupResourcesCommand).de(de_ListGroupResourcesCommand).build() {
+};
+__name(_ListGroupResourcesCommand, "ListGroupResourcesCommand");
+var ListGroupResourcesCommand = _ListGroupResourcesCommand;
+
+// src/commands/ListGroupsCommand.ts
+
+
+
+
+var _ListGroupsCommand = class _ListGroupsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "ListGroups", {}).n("ResourceGroupsClient", "ListGroupsCommand").f(void 0, void 0).ser(se_ListGroupsCommand).de(de_ListGroupsCommand).build() {
+};
+__name(_ListGroupsCommand, "ListGroupsCommand");
+var ListGroupsCommand = _ListGroupsCommand;
+
+// src/commands/PutGroupConfigurationCommand.ts
+
+
+
+
+var _PutGroupConfigurationCommand = class _PutGroupConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "PutGroupConfiguration", {}).n("ResourceGroupsClient", "PutGroupConfigurationCommand").f(void 0, void 0).ser(se_PutGroupConfigurationCommand).de(de_PutGroupConfigurationCommand).build() {
+};
+__name(_PutGroupConfigurationCommand, "PutGroupConfigurationCommand");
+var PutGroupConfigurationCommand = _PutGroupConfigurationCommand;
+
+// src/commands/SearchResourcesCommand.ts
+
+
+
+
+var _SearchResourcesCommand = class _SearchResourcesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "SearchResources", {}).n("ResourceGroupsClient", "SearchResourcesCommand").f(void 0, void 0).ser(se_SearchResourcesCommand).de(de_SearchResourcesCommand).build() {
+};
+__name(_SearchResourcesCommand, "SearchResourcesCommand");
+var SearchResourcesCommand = _SearchResourcesCommand;
+
+// src/commands/TagCommand.ts
+
+
+
+
+var _TagCommand = class _TagCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "Tag", {}).n("ResourceGroupsClient", "TagCommand").f(void 0, void 0).ser(se_TagCommand).de(de_TagCommand).build() {
+};
+__name(_TagCommand, "TagCommand");
+var TagCommand = _TagCommand;
+
+// src/commands/UngroupResourcesCommand.ts
+
+
+
+
+var _UngroupResourcesCommand = class _UngroupResourcesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "UngroupResources", {}).n("ResourceGroupsClient", "UngroupResourcesCommand").f(void 0, void 0).ser(se_UngroupResourcesCommand).de(de_UngroupResourcesCommand).build() {
+};
+__name(_UngroupResourcesCommand, "UngroupResourcesCommand");
+var UngroupResourcesCommand = _UngroupResourcesCommand;
+
+// src/commands/UntagCommand.ts
+
+
+
+
+var _UntagCommand = class _UntagCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "Untag", {}).n("ResourceGroupsClient", "UntagCommand").f(void 0, void 0).ser(se_UntagCommand).de(de_UntagCommand).build() {
+};
+__name(_UntagCommand, "UntagCommand");
+var UntagCommand = _UntagCommand;
+
+// src/commands/UpdateAccountSettingsCommand.ts
+
+
+
+
+var _UpdateAccountSettingsCommand = class _UpdateAccountSettingsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "UpdateAccountSettings", {}).n("ResourceGroupsClient", "UpdateAccountSettingsCommand").f(void 0, void 0).ser(se_UpdateAccountSettingsCommand).de(de_UpdateAccountSettingsCommand).build() {
+};
+__name(_UpdateAccountSettingsCommand, "UpdateAccountSettingsCommand");
+var UpdateAccountSettingsCommand = _UpdateAccountSettingsCommand;
+
+// src/commands/UpdateGroupCommand.ts
+
+
+
+
+var _UpdateGroupCommand = class _UpdateGroupCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "UpdateGroup", {}).n("ResourceGroupsClient", "UpdateGroupCommand").f(void 0, void 0).ser(se_UpdateGroupCommand).de(de_UpdateGroupCommand).build() {
+};
+__name(_UpdateGroupCommand, "UpdateGroupCommand");
+var UpdateGroupCommand = _UpdateGroupCommand;
+
+// src/commands/UpdateGroupQueryCommand.ts
+
+
+
+
+var _UpdateGroupQueryCommand = class _UpdateGroupQueryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Ardi", "UpdateGroupQuery", {}).n("ResourceGroupsClient", "UpdateGroupQueryCommand").f(void 0, void 0).ser(se_UpdateGroupQueryCommand).de(de_UpdateGroupQueryCommand).build() {
+};
+__name(_UpdateGroupQueryCommand, "UpdateGroupQueryCommand");
+var UpdateGroupQueryCommand = _UpdateGroupQueryCommand;
+
+// src/ResourceGroups.ts
+var commands = {
+  CreateGroupCommand,
+  DeleteGroupCommand,
+  GetAccountSettingsCommand,
+  GetGroupCommand,
+  GetGroupConfigurationCommand,
+  GetGroupQueryCommand,
+  GetTagsCommand,
+  GroupResourcesCommand,
+  ListGroupResourcesCommand,
+  ListGroupsCommand,
+  PutGroupConfigurationCommand,
+  SearchResourcesCommand,
+  TagCommand,
+  UngroupResourcesCommand,
+  UntagCommand,
+  UpdateAccountSettingsCommand,
+  UpdateGroupCommand,
+  UpdateGroupQueryCommand
+};
+var _ResourceGroups = class _ResourceGroups extends ResourceGroupsClient {
+};
+__name(_ResourceGroups, "ResourceGroups");
+var ResourceGroups = _ResourceGroups;
+(0, import_smithy_client.createAggregatedClient)(commands, ResourceGroups);
+
+// src/pagination/ListGroupResourcesPaginator.ts
+
+var paginateListGroupResources = (0, import_core.createPaginator)(ResourceGroupsClient, ListGroupResourcesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListGroupsPaginator.ts
+
+var paginateListGroups = (0, import_core.createPaginator)(ResourceGroupsClient, ListGroupsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/SearchResourcesPaginator.ts
+
+var paginateSearchResources = (0, import_core.createPaginator)(ResourceGroupsClient, SearchResourcesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BadRequestException,
+  CreateGroupCommand,
+  DeleteGroupCommand,
+  ForbiddenException,
+  GetAccountSettingsCommand,
+  GetGroupCommand,
+  GetGroupConfigurationCommand,
+  GetGroupQueryCommand,
+  GetTagsCommand,
+  GroupConfigurationStatus,
+  GroupFilterName,
+  GroupLifecycleEventsDesiredStatus,
+  GroupLifecycleEventsStatus,
+  GroupResourcesCommand,
+  InternalServerErrorException,
+  ListGroupResourcesCommand,
+  ListGroupsCommand,
+  MethodNotAllowedException,
+  NotFoundException,
+  PutGroupConfigurationCommand,
+  QueryErrorCode,
+  QueryType,
+  ResourceFilterName,
+  ResourceGroups,
+  ResourceGroupsClient,
+  ResourceGroupsServiceException,
+  ResourceStatusValue,
+  SearchResourcesCommand,
+  TagCommand,
+  TooManyRequestsException,
+  UnauthorizedException,
+  UngroupResourcesCommand,
+  UntagCommand,
+  UpdateAccountSettingsCommand,
+  UpdateGroupCommand,
+  UpdateGroupQueryCommand,
+  __Client,
+  paginateListGroupResources,
+  paginateListGroups,
+  paginateSearchResources
+});