lambda-live-debugger/node_modules/@aws-sdk/client-cloudformation/dist-cjs/index.js

Debug Lambda functions locally like it is running in the cloud

"use strict";
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, {
  AccountFilterType: () => AccountFilterType,
  AccountGateStatus: () => AccountGateStatus,
  ActivateOrganizationsAccessCommand: () => ActivateOrganizationsAccessCommand,
  ActivateTypeCommand: () => ActivateTypeCommand,
  AlreadyExistsException: () => AlreadyExistsException,
  AttributeChangeType: () => AttributeChangeType,
  BatchDescribeTypeConfigurationsCommand: () => BatchDescribeTypeConfigurationsCommand,
  CFNRegistryException: () => CFNRegistryException,
  CallAs: () => CallAs,
  CancelUpdateStackCommand: () => CancelUpdateStackCommand,
  Capability: () => Capability,
  Category: () => Category,
  ChangeAction: () => ChangeAction,
  ChangeSetHooksStatus: () => ChangeSetHooksStatus,
  ChangeSetNotFoundException: () => ChangeSetNotFoundException,
  ChangeSetStatus: () => ChangeSetStatus,
  ChangeSetType: () => ChangeSetType,
  ChangeSource: () => ChangeSource,
  ChangeType: () => ChangeType,
  CloudFormation: () => CloudFormation,
  CloudFormationClient: () => CloudFormationClient,
  CloudFormationServiceException: () => CloudFormationServiceException,
  ConcurrencyMode: () => ConcurrencyMode,
  ConcurrentResourcesLimitExceededException: () => ConcurrentResourcesLimitExceededException,
  ContinueUpdateRollbackCommand: () => ContinueUpdateRollbackCommand,
  CreateChangeSetCommand: () => CreateChangeSetCommand,
  CreateGeneratedTemplateCommand: () => CreateGeneratedTemplateCommand,
  CreateStackCommand: () => CreateStackCommand,
  CreateStackInstancesCommand: () => CreateStackInstancesCommand,
  CreateStackSetCommand: () => CreateStackSetCommand,
  CreatedButModifiedException: () => CreatedButModifiedException,
  DeactivateOrganizationsAccessCommand: () => DeactivateOrganizationsAccessCommand,
  DeactivateTypeCommand: () => DeactivateTypeCommand,
  DeleteChangeSetCommand: () => DeleteChangeSetCommand,
  DeleteGeneratedTemplateCommand: () => DeleteGeneratedTemplateCommand,
  DeleteStackCommand: () => DeleteStackCommand,
  DeleteStackInstancesCommand: () => DeleteStackInstancesCommand,
  DeleteStackSetCommand: () => DeleteStackSetCommand,
  DeprecatedStatus: () => DeprecatedStatus,
  DeregisterTypeCommand: () => DeregisterTypeCommand,
  DescribeAccountLimitsCommand: () => DescribeAccountLimitsCommand,
  DescribeChangeSetCommand: () => DescribeChangeSetCommand,
  DescribeChangeSetHooksCommand: () => DescribeChangeSetHooksCommand,
  DescribeGeneratedTemplateCommand: () => DescribeGeneratedTemplateCommand,
  DescribeOrganizationsAccessCommand: () => DescribeOrganizationsAccessCommand,
  DescribePublisherCommand: () => DescribePublisherCommand,
  DescribeResourceScanCommand: () => DescribeResourceScanCommand,
  DescribeStackDriftDetectionStatusCommand: () => DescribeStackDriftDetectionStatusCommand,
  DescribeStackEventsCommand: () => DescribeStackEventsCommand,
  DescribeStackInstanceCommand: () => DescribeStackInstanceCommand,
  DescribeStackResourceCommand: () => DescribeStackResourceCommand,
  DescribeStackResourceDriftsCommand: () => DescribeStackResourceDriftsCommand,
  DescribeStackResourcesCommand: () => DescribeStackResourcesCommand,
  DescribeStackSetCommand: () => DescribeStackSetCommand,
  DescribeStackSetOperationCommand: () => DescribeStackSetOperationCommand,
  DescribeStacksCommand: () => DescribeStacksCommand,
  DescribeTypeCommand: () => DescribeTypeCommand,
  DescribeTypeRegistrationCommand: () => DescribeTypeRegistrationCommand,
  DetailedStatus: () => DetailedStatus,
  DetectStackDriftCommand: () => DetectStackDriftCommand,
  DetectStackResourceDriftCommand: () => DetectStackResourceDriftCommand,
  DetectStackSetDriftCommand: () => DetectStackSetDriftCommand,
  DifferenceType: () => DifferenceType,
  EstimateTemplateCostCommand: () => EstimateTemplateCostCommand,
  EvaluationType: () => EvaluationType,
  ExecuteChangeSetCommand: () => ExecuteChangeSetCommand,
  ExecutionStatus: () => ExecutionStatus,
  GeneratedTemplateDeletionPolicy: () => GeneratedTemplateDeletionPolicy,
  GeneratedTemplateNotFoundException: () => GeneratedTemplateNotFoundException,
  GeneratedTemplateResourceStatus: () => GeneratedTemplateResourceStatus,
  GeneratedTemplateStatus: () => GeneratedTemplateStatus,
  GeneratedTemplateUpdateReplacePolicy: () => GeneratedTemplateUpdateReplacePolicy,
  GetGeneratedTemplateCommand: () => GetGeneratedTemplateCommand,
  GetStackPolicyCommand: () => GetStackPolicyCommand,
  GetTemplateCommand: () => GetTemplateCommand,
  GetTemplateSummaryCommand: () => GetTemplateSummaryCommand,
  HandlerErrorCode: () => HandlerErrorCode,
  HookFailureMode: () => HookFailureMode,
  HookInvocationPoint: () => HookInvocationPoint,
  HookStatus: () => HookStatus,
  HookTargetType: () => HookTargetType,
  IdentityProvider: () => IdentityProvider,
  ImportStacksToStackSetCommand: () => ImportStacksToStackSetCommand,
  InsufficientCapabilitiesException: () => InsufficientCapabilitiesException,
  InvalidChangeSetStatusException: () => InvalidChangeSetStatusException,
  InvalidOperationException: () => InvalidOperationException,
  InvalidStateTransitionException: () => InvalidStateTransitionException,
  LimitExceededException: () => LimitExceededException,
  ListChangeSetsCommand: () => ListChangeSetsCommand,
  ListExportsCommand: () => ListExportsCommand,
  ListGeneratedTemplatesCommand: () => ListGeneratedTemplatesCommand,
  ListImportsCommand: () => ListImportsCommand,
  ListResourceScanRelatedResourcesCommand: () => ListResourceScanRelatedResourcesCommand,
  ListResourceScanResourcesCommand: () => ListResourceScanResourcesCommand,
  ListResourceScansCommand: () => ListResourceScansCommand,
  ListStackInstanceResourceDriftsCommand: () => ListStackInstanceResourceDriftsCommand,
  ListStackInstancesCommand: () => ListStackInstancesCommand,
  ListStackResourcesCommand: () => ListStackResourcesCommand,
  ListStackSetAutoDeploymentTargetsCommand: () => ListStackSetAutoDeploymentTargetsCommand,
  ListStackSetOperationResultsCommand: () => ListStackSetOperationResultsCommand,
  ListStackSetOperationsCommand: () => ListStackSetOperationsCommand,
  ListStackSetsCommand: () => ListStackSetsCommand,
  ListStacksCommand: () => ListStacksCommand,
  ListTypeRegistrationsCommand: () => ListTypeRegistrationsCommand,
  ListTypeVersionsCommand: () => ListTypeVersionsCommand,
  ListTypesCommand: () => ListTypesCommand,
  NameAlreadyExistsException: () => NameAlreadyExistsException,
  OnFailure: () => OnFailure,
  OnStackFailure: () => OnStackFailure,
  OperationIdAlreadyExistsException: () => OperationIdAlreadyExistsException,
  OperationInProgressException: () => OperationInProgressException,
  OperationNotFoundException: () => OperationNotFoundException,
  OperationResultFilterName: () => OperationResultFilterName,
  OperationStatus: () => OperationStatus,
  OperationStatusCheckFailedException: () => OperationStatusCheckFailedException,
  OrganizationStatus: () => OrganizationStatus,
  PermissionModels: () => PermissionModels,
  PolicyAction: () => PolicyAction,
  ProvisioningType: () => ProvisioningType,
  PublishTypeCommand: () => PublishTypeCommand,
  PublisherStatus: () => PublisherStatus,
  RecordHandlerProgressCommand: () => RecordHandlerProgressCommand,
  RegionConcurrencyType: () => RegionConcurrencyType,
  RegisterPublisherCommand: () => RegisterPublisherCommand,
  RegisterTypeCommand: () => RegisterTypeCommand,
  RegistrationStatus: () => RegistrationStatus,
  RegistryType: () => RegistryType,
  Replacement: () => Replacement,
  RequiresRecreation: () => RequiresRecreation,
  ResourceAttribute: () => ResourceAttribute,
  ResourceScanInProgressException: () => ResourceScanInProgressException,
  ResourceScanLimitExceededException: () => ResourceScanLimitExceededException,
  ResourceScanNotFoundException: () => ResourceScanNotFoundException,
  ResourceScanStatus: () => ResourceScanStatus,
  ResourceSignalStatus: () => ResourceSignalStatus,
  ResourceStatus: () => ResourceStatus,
  RollbackStackCommand: () => RollbackStackCommand,
  SetStackPolicyCommand: () => SetStackPolicyCommand,
  SetTypeConfigurationCommand: () => SetTypeConfigurationCommand,
  SetTypeDefaultVersionCommand: () => SetTypeDefaultVersionCommand,
  SignalResourceCommand: () => SignalResourceCommand,
  StackDriftDetectionStatus: () => StackDriftDetectionStatus,
  StackDriftStatus: () => StackDriftStatus,
  StackInstanceDetailedStatus: () => StackInstanceDetailedStatus,
  StackInstanceFilterName: () => StackInstanceFilterName,
  StackInstanceNotFoundException: () => StackInstanceNotFoundException,
  StackInstanceStatus: () => StackInstanceStatus,
  StackNotFoundException: () => StackNotFoundException,
  StackResourceDriftStatus: () => StackResourceDriftStatus,
  StackSetDriftDetectionStatus: () => StackSetDriftDetectionStatus,
  StackSetDriftStatus: () => StackSetDriftStatus,
  StackSetNotEmptyException: () => StackSetNotEmptyException,
  StackSetNotFoundException: () => StackSetNotFoundException,
  StackSetOperationAction: () => StackSetOperationAction,
  StackSetOperationResultStatus: () => StackSetOperationResultStatus,
  StackSetOperationStatus: () => StackSetOperationStatus,
  StackSetStatus: () => StackSetStatus,
  StackStatus: () => StackStatus,
  StaleRequestException: () => StaleRequestException,
  StartResourceScanCommand: () => StartResourceScanCommand,
  StopStackSetOperationCommand: () => StopStackSetOperationCommand,
  TemplateFormat: () => TemplateFormat,
  TemplateStage: () => TemplateStage,
  TestTypeCommand: () => TestTypeCommand,
  ThirdPartyType: () => ThirdPartyType,
  TokenAlreadyExistsException: () => TokenAlreadyExistsException,
  TypeConfigurationNotFoundException: () => TypeConfigurationNotFoundException,
  TypeNotFoundException: () => TypeNotFoundException,
  TypeTestsStatus: () => TypeTestsStatus,
  UpdateGeneratedTemplateCommand: () => UpdateGeneratedTemplateCommand,
  UpdateStackCommand: () => UpdateStackCommand,
  UpdateStackInstancesCommand: () => UpdateStackInstancesCommand,
  UpdateStackSetCommand: () => UpdateStackSetCommand,
  UpdateTerminationProtectionCommand: () => UpdateTerminationProtectionCommand,
  ValidateTemplateCommand: () => ValidateTemplateCommand,
  VersionBump: () => VersionBump,
  Visibility: () => Visibility,
  WarningType: () => WarningType,
  __Client: () => import_smithy_client.Client,
  paginateDescribeAccountLimits: () => paginateDescribeAccountLimits,
  paginateDescribeStackEvents: () => paginateDescribeStackEvents,
  paginateDescribeStackResourceDrifts: () => paginateDescribeStackResourceDrifts,
  paginateDescribeStacks: () => paginateDescribeStacks,
  paginateListChangeSets: () => paginateListChangeSets,
  paginateListExports: () => paginateListExports,
  paginateListGeneratedTemplates: () => paginateListGeneratedTemplates,
  paginateListImports: () => paginateListImports,
  paginateListResourceScanRelatedResources: () => paginateListResourceScanRelatedResources,
  paginateListResourceScanResources: () => paginateListResourceScanResources,
  paginateListResourceScans: () => paginateListResourceScans,
  paginateListStackInstances: () => paginateListStackInstances,
  paginateListStackResources: () => paginateListStackResources,
  paginateListStackSetOperationResults: () => paginateListStackSetOperationResults,
  paginateListStackSetOperations: () => paginateListStackSetOperations,
  paginateListStackSets: () => paginateListStackSets,
  paginateListStacks: () => paginateListStacks,
  paginateListTypeRegistrations: () => paginateListTypeRegistrations,
  paginateListTypeVersions: () => paginateListTypeVersions,
  paginateListTypes: () => paginateListTypes,
  waitForChangeSetCreateComplete: () => waitForChangeSetCreateComplete,
  waitForStackCreateComplete: () => waitForStackCreateComplete,
  waitForStackDeleteComplete: () => waitForStackDeleteComplete,
  waitForStackExists: () => waitForStackExists,
  waitForStackImportComplete: () => waitForStackImportComplete,
  waitForStackRollbackComplete: () => waitForStackRollbackComplete,
  waitForStackUpdateComplete: () => waitForStackUpdateComplete,
  waitForTypeRegistrationComplete: () => waitForTypeRegistrationComplete,
  waitUntilChangeSetCreateComplete: () => waitUntilChangeSetCreateComplete,
  waitUntilStackCreateComplete: () => waitUntilStackCreateComplete,
  waitUntilStackDeleteComplete: () => waitUntilStackDeleteComplete,
  waitUntilStackExists: () => waitUntilStackExists,
  waitUntilStackImportComplete: () => waitUntilStackImportComplete,
  waitUntilStackRollbackComplete: () => waitUntilStackRollbackComplete,
  waitUntilStackUpdateComplete: () => waitUntilStackUpdateComplete,
  waitUntilTypeRegistrationComplete: () => waitUntilTypeRegistrationComplete
});
module.exports = __toCommonJS(src_exports);

// src/CloudFormationClient.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_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
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");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return {
    ...options,
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "cloudformation"
  };
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/CloudFormationClient.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");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
  let _credentials = runtimeConfig.credentials;
  return {
    setHttpAuthScheme(httpAuthScheme) {
      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
      if (index === -1) {
        _httpAuthSchemes.push(httpAuthScheme);
      } else {
        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
      }
    },
    httpAuthSchemes() {
      return _httpAuthSchemes;
    },
    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
      _httpAuthSchemeProvider = httpAuthSchemeProvider;
    },
    httpAuthSchemeProvider() {
      return _httpAuthSchemeProvider;
    },
    setCredentials(credentials) {
      _credentials = credentials;
    },
    credentials() {
      return _credentials;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
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)),
    ...asPartial(getHttpAuthExtensionConfiguration(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),
    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
  };
}, "resolveRuntimeExtensions");

// src/CloudFormationClient.ts
var _CloudFormationClient = class _CloudFormationClient 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_user_agent.resolveUserAgentConfig)(_config_5);
    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_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_user_agent.getUserAgentPlugin)(this.config));
    this.middlewareStack.use(
      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: this.getDefaultHttpAuthSchemeParametersProvider(),
        identityProviderConfigProvider: this.getIdentityProviderConfigProvider()
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(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();
  }
  getDefaultHttpAuthSchemeParametersProvider() {
    return import_httpAuthSchemeProvider.defaultCloudFormationHttpAuthSchemeParametersProvider;
  }
  getIdentityProviderConfigProvider() {
    return async (config) => new import_core.DefaultIdentityProviderConfig({
      "aws.auth#sigv4": config.credentials
    });
  }
};
__name(_CloudFormationClient, "CloudFormationClient");
var CloudFormationClient = _CloudFormationClient;

// src/CloudFormation.ts


// src/commands/ActivateOrganizationsAccessCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");

var import_types = require("@smithy/types");

// src/protocols/Aws_query.ts
var import_core2 = require("@aws-sdk/core");


var import_uuid = require("uuid");

// src/models/CloudFormationServiceException.ts

var _CloudFormationServiceException = class _CloudFormationServiceException extends import_smithy_client.ServiceException {
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _CloudFormationServiceException.prototype);
  }
};
__name(_CloudFormationServiceException, "CloudFormationServiceException");
var CloudFormationServiceException = _CloudFormationServiceException;

// src/models/models_0.ts
var AccountFilterType = {
  DIFFERENCE: "DIFFERENCE",
  INTERSECTION: "INTERSECTION",
  NONE: "NONE",
  UNION: "UNION"
};
var AccountGateStatus = {
  FAILED: "FAILED",
  SKIPPED: "SKIPPED",
  SUCCEEDED: "SUCCEEDED"
};
var _InvalidOperationException = class _InvalidOperationException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidOperationException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidOperationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidOperationException.prototype);
    this.Message = opts.Message;
  }
};
__name(_InvalidOperationException, "InvalidOperationException");
var InvalidOperationException = _InvalidOperationException;
var _OperationNotFoundException = class _OperationNotFoundException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "OperationNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "OperationNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _OperationNotFoundException.prototype);
    this.Message = opts.Message;
  }
};
__name(_OperationNotFoundException, "OperationNotFoundException");
var OperationNotFoundException = _OperationNotFoundException;
var ThirdPartyType = {
  HOOK: "HOOK",
  MODULE: "MODULE",
  RESOURCE: "RESOURCE"
};
var VersionBump = {
  MAJOR: "MAJOR",
  MINOR: "MINOR"
};
var _CFNRegistryException = class _CFNRegistryException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CFNRegistryException",
      $fault: "client",
      ...opts
    });
    this.name = "CFNRegistryException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _CFNRegistryException.prototype);
    this.Message = opts.Message;
  }
};
__name(_CFNRegistryException, "CFNRegistryException");
var CFNRegistryException = _CFNRegistryException;
var _TypeNotFoundException = class _TypeNotFoundException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TypeNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "TypeNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TypeNotFoundException.prototype);
    this.Message = opts.Message;
  }
};
__name(_TypeNotFoundException, "TypeNotFoundException");
var TypeNotFoundException = _TypeNotFoundException;
var _AlreadyExistsException = class _AlreadyExistsException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "AlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "AlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _AlreadyExistsException.prototype);
    this.Message = opts.Message;
  }
};
__name(_AlreadyExistsException, "AlreadyExistsException");
var AlreadyExistsException = _AlreadyExistsException;
var AttributeChangeType = {
  Add: "Add",
  Modify: "Modify",
  Remove: "Remove"
};
var _TypeConfigurationNotFoundException = class _TypeConfigurationNotFoundException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TypeConfigurationNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "TypeConfigurationNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TypeConfigurationNotFoundException.prototype);
    this.Message = opts.Message;
  }
};
__name(_TypeConfigurationNotFoundException, "TypeConfigurationNotFoundException");
var TypeConfigurationNotFoundException = _TypeConfigurationNotFoundException;
var CallAs = {
  DELEGATED_ADMIN: "DELEGATED_ADMIN",
  SELF: "SELF"
};
var _TokenAlreadyExistsException = class _TokenAlreadyExistsException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TokenAlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "TokenAlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TokenAlreadyExistsException.prototype);
    this.Message = opts.Message;
  }
};
__name(_TokenAlreadyExistsException, "TokenAlreadyExistsException");
var TokenAlreadyExistsException = _TokenAlreadyExistsException;
var Capability = {
  CAPABILITY_AUTO_EXPAND: "CAPABILITY_AUTO_EXPAND",
  CAPABILITY_IAM: "CAPABILITY_IAM",
  CAPABILITY_NAMED_IAM: "CAPABILITY_NAMED_IAM"
};
var Category = {
  ACTIVATED: "ACTIVATED",
  AWS_TYPES: "AWS_TYPES",
  REGISTERED: "REGISTERED",
  THIRD_PARTY: "THIRD_PARTY"
};
var ChangeAction = {
  Add: "Add",
  Dynamic: "Dynamic",
  Import: "Import",
  Modify: "Modify",
  Remove: "Remove"
};
var ChangeSource = {
  Automatic: "Automatic",
  DirectModification: "DirectModification",
  ParameterReference: "ParameterReference",
  ResourceAttribute: "ResourceAttribute",
  ResourceReference: "ResourceReference"
};
var EvaluationType = {
  Dynamic: "Dynamic",
  Static: "Static"
};
var ResourceAttribute = {
  CreationPolicy: "CreationPolicy",
  DeletionPolicy: "DeletionPolicy",
  Metadata: "Metadata",
  Properties: "Properties",
  Tags: "Tags",
  UpdatePolicy: "UpdatePolicy",
  UpdateReplacePolicy: "UpdateReplacePolicy"
};
var RequiresRecreation = {
  Always: "Always",
  Conditionally: "Conditionally",
  Never: "Never"
};
var PolicyAction = {
  Delete: "Delete",
  ReplaceAndDelete: "ReplaceAndDelete",
  ReplaceAndRetain: "ReplaceAndRetain",
  ReplaceAndSnapshot: "ReplaceAndSnapshot",
  Retain: "Retain",
  Snapshot: "Snapshot"
};
var Replacement = {
  Conditional: "Conditional",
  False: "False",
  True: "True"
};
var ChangeType = {
  Resource: "Resource"
};
var HookFailureMode = {
  FAIL: "FAIL",
  WARN: "WARN"
};
var HookInvocationPoint = {
  PRE_PROVISION: "PRE_PROVISION"
};
var HookTargetType = {
  RESOURCE: "RESOURCE"
};
var ChangeSetHooksStatus = {
  PLANNED: "PLANNED",
  PLANNING: "PLANNING",
  UNAVAILABLE: "UNAVAILABLE"
};
var _ChangeSetNotFoundException = class _ChangeSetNotFoundException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ChangeSetNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ChangeSetNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ChangeSetNotFoundException.prototype);
    this.Message = opts.Message;
  }
};
__name(_ChangeSetNotFoundException, "ChangeSetNotFoundException");
var ChangeSetNotFoundException = _ChangeSetNotFoundException;
var ChangeSetStatus = {
  CREATE_COMPLETE: "CREATE_COMPLETE",
  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
  CREATE_PENDING: "CREATE_PENDING",
  DELETE_COMPLETE: "DELETE_COMPLETE",
  DELETE_FAILED: "DELETE_FAILED",
  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
  DELETE_PENDING: "DELETE_PENDING",
  FAILED: "FAILED"
};
var ExecutionStatus = {
  AVAILABLE: "AVAILABLE",
  EXECUTE_COMPLETE: "EXECUTE_COMPLETE",
  EXECUTE_FAILED: "EXECUTE_FAILED",
  EXECUTE_IN_PROGRESS: "EXECUTE_IN_PROGRESS",
  OBSOLETE: "OBSOLETE",
  UNAVAILABLE: "UNAVAILABLE"
};
var ChangeSetType = {
  CREATE: "CREATE",
  IMPORT: "IMPORT",
  UPDATE: "UPDATE"
};
var OnStackFailure = {
  DELETE: "DELETE",
  DO_NOTHING: "DO_NOTHING",
  ROLLBACK: "ROLLBACK"
};
var _InsufficientCapabilitiesException = class _InsufficientCapabilitiesException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InsufficientCapabilitiesException",
      $fault: "client",
      ...opts
    });
    this.name = "InsufficientCapabilitiesException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InsufficientCapabilitiesException.prototype);
    this.Message = opts.Message;
  }
};
__name(_InsufficientCapabilitiesException, "InsufficientCapabilitiesException");
var InsufficientCapabilitiesException = _InsufficientCapabilitiesException;
var _LimitExceededException = class _LimitExceededException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "LimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "LimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _LimitExceededException.prototype);
    this.Message = opts.Message;
  }
};
__name(_LimitExceededException, "LimitExceededException");
var LimitExceededException = _LimitExceededException;
var _ConcurrentResourcesLimitExceededException = class _ConcurrentResourcesLimitExceededException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ConcurrentResourcesLimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "ConcurrentResourcesLimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ConcurrentResourcesLimitExceededException.prototype);
    this.Message = opts.Message;
  }
};
__name(_ConcurrentResourcesLimitExceededException, "ConcurrentResourcesLimitExceededException");
var ConcurrentResourcesLimitExceededException = _ConcurrentResourcesLimitExceededException;
var GeneratedTemplateDeletionPolicy = {
  DELETE: "DELETE",
  RETAIN: "RETAIN"
};
var GeneratedTemplateUpdateReplacePolicy = {
  DELETE: "DELETE",
  RETAIN: "RETAIN"
};
var OnFailure = {
  DELETE: "DELETE",
  DO_NOTHING: "DO_NOTHING",
  ROLLBACK: "ROLLBACK"
};
var ConcurrencyMode = {
  SOFT_FAILURE_TOLERANCE: "SOFT_FAILURE_TOLERANCE",
  STRICT_FAILURE_TOLERANCE: "STRICT_FAILURE_TOLERANCE"
};
var RegionConcurrencyType = {
  PARALLEL: "PARALLEL",
  SEQUENTIAL: "SEQUENTIAL"
};
var _OperationIdAlreadyExistsException = class _OperationIdAlreadyExistsException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "OperationIdAlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "OperationIdAlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _OperationIdAlreadyExistsException.prototype);
    this.Message = opts.Message;
  }
};
__name(_OperationIdAlreadyExistsException, "OperationIdAlreadyExistsException");
var OperationIdAlreadyExistsException = _OperationIdAlreadyExistsException;
var _OperationInProgressException = class _OperationInProgressException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "OperationInProgressException",
      $fault: "client",
      ...opts
    });
    this.name = "OperationInProgressException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _OperationInProgressException.prototype);
    this.Message = opts.Message;
  }
};
__name(_OperationInProgressException, "OperationInProgressException");
var OperationInProgressException = _OperationInProgressException;
var _StackSetNotFoundException = class _StackSetNotFoundException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "StackSetNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "StackSetNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _StackSetNotFoundException.prototype);
    this.Message = opts.Message;
  }
};
__name(_StackSetNotFoundException, "StackSetNotFoundException");
var StackSetNotFoundException = _StackSetNotFoundException;
var _StaleRequestException = class _StaleRequestException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "StaleRequestException",
      $fault: "client",
      ...opts
    });
    this.name = "StaleRequestException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _StaleRequestException.prototype);
    this.Message = opts.Message;
  }
};
__name(_StaleRequestException, "StaleRequestException");
var StaleRequestException = _StaleRequestException;
var _CreatedButModifiedException = class _CreatedButModifiedException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CreatedButModifiedException",
      $fault: "client",
      ...opts
    });
    this.name = "CreatedButModifiedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _CreatedButModifiedException.prototype);
    this.Message = opts.Message;
  }
};
__name(_CreatedButModifiedException, "CreatedButModifiedException");
var CreatedButModifiedException = _CreatedButModifiedException;
var PermissionModels = {
  SELF_MANAGED: "SELF_MANAGED",
  SERVICE_MANAGED: "SERVICE_MANAGED"
};
var _NameAlreadyExistsException = class _NameAlreadyExistsException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "NameAlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "NameAlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _NameAlreadyExistsException.prototype);
    this.Message = opts.Message;
  }
};
__name(_NameAlreadyExistsException, "NameAlreadyExistsException");
var NameAlreadyExistsException = _NameAlreadyExistsException;
var _InvalidChangeSetStatusException = class _InvalidChangeSetStatusException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidChangeSetStatusException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidChangeSetStatusException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidChangeSetStatusException.prototype);
    this.Message = opts.Message;
  }
};
__name(_InvalidChangeSetStatusException, "InvalidChangeSetStatusException");
var InvalidChangeSetStatusException = _InvalidChangeSetStatusException;
var _GeneratedTemplateNotFoundException = class _GeneratedTemplateNotFoundException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "GeneratedTemplateNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "GeneratedTemplateNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _GeneratedTemplateNotFoundException.prototype);
    this.Message = opts.Message;
  }
};
__name(_GeneratedTemplateNotFoundException, "GeneratedTemplateNotFoundException");
var GeneratedTemplateNotFoundException = _GeneratedTemplateNotFoundException;
var _StackSetNotEmptyException = class _StackSetNotEmptyException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "StackSetNotEmptyException",
      $fault: "client",
      ...opts
    });
    this.name = "StackSetNotEmptyException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _StackSetNotEmptyException.prototype);
    this.Message = opts.Message;
  }
};
__name(_StackSetNotEmptyException, "StackSetNotEmptyException");
var StackSetNotEmptyException = _StackSetNotEmptyException;
var RegistryType = {
  HOOK: "HOOK",
  MODULE: "MODULE",
  RESOURCE: "RESOURCE"
};
var GeneratedTemplateResourceStatus = {
  COMPLETE: "COMPLETE",
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS",
  PENDING: "PENDING"
};
var WarningType = {
  MUTUALLY_EXCLUSIVE_PROPERTIES: "MUTUALLY_EXCLUSIVE_PROPERTIES",
  MUTUALLY_EXCLUSIVE_TYPES: "MUTUALLY_EXCLUSIVE_TYPES",
  UNSUPPORTED_PROPERTIES: "UNSUPPORTED_PROPERTIES"
};
var GeneratedTemplateStatus = {
  COMPLETE: "COMPLETE",
  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
  CREATE_PENDING: "CREATE_PENDING",
  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
  DELETE_PENDING: "DELETE_PENDING",
  FAILED: "FAILED",
  UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
  UPDATE_PENDING: "UPDATE_PENDING"
};
var OrganizationStatus = {
  DISABLED: "DISABLED",
  DISABLED_PERMANENTLY: "DISABLED_PERMANENTLY",
  ENABLED: "ENABLED"
};
var IdentityProvider = {
  AWS_Marketplace: "AWS_Marketplace",
  Bitbucket: "Bitbucket",
  GitHub: "GitHub"
};
var PublisherStatus = {
  UNVERIFIED: "UNVERIFIED",
  VERIFIED: "VERIFIED"
};
var ResourceScanStatus = {
  COMPLETE: "COMPLETE",
  EXPIRED: "EXPIRED",
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS"
};
var _ResourceScanNotFoundException = class _ResourceScanNotFoundException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceScanNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceScanNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceScanNotFoundException.prototype);
    this.Message = opts.Message;
  }
};
__name(_ResourceScanNotFoundException, "ResourceScanNotFoundException");
var ResourceScanNotFoundException = _ResourceScanNotFoundException;
var StackDriftDetectionStatus = {
  DETECTION_COMPLETE: "DETECTION_COMPLETE",
  DETECTION_FAILED: "DETECTION_FAILED",
  DETECTION_IN_PROGRESS: "DETECTION_IN_PROGRESS"
};
var StackDriftStatus = {
  DRIFTED: "DRIFTED",
  IN_SYNC: "IN_SYNC",
  NOT_CHECKED: "NOT_CHECKED",
  UNKNOWN: "UNKNOWN"
};
var DetailedStatus = {
  CONFIGURATION_COMPLETE: "CONFIGURATION_COMPLETE",
  VALIDATION_FAILED: "VALIDATION_FAILED"
};
var HookStatus = {
  HOOK_COMPLETE_FAILED: "HOOK_COMPLETE_FAILED",
  HOOK_COMPLETE_SUCCEEDED: "HOOK_COMPLETE_SUCCEEDED",
  HOOK_FAILED: "HOOK_FAILED",
  HOOK_IN_PROGRESS: "HOOK_IN_PROGRESS"
};
var ResourceStatus = {
  CREATE_COMPLETE: "CREATE_COMPLETE",
  CREATE_FAILED: "CREATE_FAILED",
  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
  DELETE_COMPLETE: "DELETE_COMPLETE",
  DELETE_FAILED: "DELETE_FAILED",
  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
  DELETE_SKIPPED: "DELETE_SKIPPED",
  IMPORT_COMPLETE: "IMPORT_COMPLETE",
  IMPORT_FAILED: "IMPORT_FAILED",
  IMPORT_IN_PROGRESS: "IMPORT_IN_PROGRESS",
  IMPORT_ROLLBACK_COMPLETE: "IMPORT_ROLLBACK_COMPLETE",
  IMPORT_ROLLBACK_FAILED: "IMPORT_ROLLBACK_FAILED",
  IMPORT_ROLLBACK_IN_PROGRESS: "IMPORT_ROLLBACK_IN_PROGRESS",
  ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE",
  ROLLBACK_FAILED: "ROLLBACK_FAILED",
  ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",
  UPDATE_COMPLETE: "UPDATE_COMPLETE",
  UPDATE_FAILED: "UPDATE_FAILED",
  UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
  UPDATE_ROLLBACK_COMPLETE: "UPDATE_ROLLBACK_COMPLETE",
  UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED",
  UPDATE_ROLLBACK_IN_PROGRESS: "UPDATE_ROLLBACK_IN_PROGRESS"
};
var StackInstanceDetailedStatus = {
  CANCELLED: "CANCELLED",
  FAILED: "FAILED",
  FAILED_IMPORT: "FAILED_IMPORT",
  INOPERABLE: "INOPERABLE",
  PENDING: "PENDING",
  RUNNING: "RUNNING",
  SKIPPED_SUSPENDED_ACCOUNT: "SKIPPED_SUSPENDED_ACCOUNT",
  SUCCEEDED: "SUCCEEDED"
};
var StackInstanceStatus = {
  CURRENT: "CURRENT",
  INOPERABLE: "INOPERABLE",
  OUTDATED: "OUTDATED"
};
var _StackInstanceNotFoundException = class _StackInstanceNotFoundException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "StackInstanceNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "StackInstanceNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _StackInstanceNotFoundException.prototype);
    this.Message = opts.Message;
  }
};
__name(_StackInstanceNotFoundException, "StackInstanceNotFoundException");
var StackInstanceNotFoundException = _StackInstanceNotFoundException;
var StackResourceDriftStatus = {
  DELETED: "DELETED",
  IN_SYNC: "IN_SYNC",
  MODIFIED: "MODIFIED",
  NOT_CHECKED: "NOT_CHECKED"
};
var DifferenceType = {
  ADD: "ADD",
  NOT_EQUAL: "NOT_EQUAL",
  REMOVE: "REMOVE"
};
var StackStatus = {
  CREATE_COMPLETE: "CREATE_COMPLETE",
  CREATE_FAILED: "CREATE_FAILED",
  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
  DELETE_COMPLETE: "DELETE_COMPLETE",
  DELETE_FAILED: "DELETE_FAILED",
  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
  IMPORT_COMPLETE: "IMPORT_COMPLETE",
  IMPORT_IN_PROGRESS: "IMPORT_IN_PROGRESS",
  IMPORT_ROLLBACK_COMPLETE: "IMPORT_ROLLBACK_COMPLETE",
  IMPORT_ROLLBACK_FAILED: "IMPORT_ROLLBACK_FAILED",
  IMPORT_ROLLBACK_IN_PROGRESS: "IMPORT_ROLLBACK_IN_PROGRESS",
  REVIEW_IN_PROGRESS: "REVIEW_IN_PROGRESS",
  ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE",
  ROLLBACK_FAILED: "ROLLBACK_FAILED",
  ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS",
  UPDATE_COMPLETE: "UPDATE_COMPLETE",
  UPDATE_COMPLETE_CLEANUP_IN_PROGRESS: "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
  UPDATE_FAILED: "UPDATE_FAILED",
  UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
  UPDATE_ROLLBACK_COMPLETE: "UPDATE_ROLLBACK_COMPLETE",
  UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS: "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
  UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED",
  UPDATE_ROLLBACK_IN_PROGRESS: "UPDATE_ROLLBACK_IN_PROGRESS"
};
var StackSetDriftDetectionStatus = {
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS",
  PARTIAL_SUCCESS: "PARTIAL_SUCCESS",
  STOPPED: "STOPPED"
};
var StackSetDriftStatus = {
  DRIFTED: "DRIFTED",
  IN_SYNC: "IN_SYNC",
  NOT_CHECKED: "NOT_CHECKED"
};
var StackSetStatus = {
  ACTIVE: "ACTIVE",
  DELETED: "DELETED"
};
var StackSetOperationAction = {
  CREATE: "CREATE",
  DELETE: "DELETE",
  DETECT_DRIFT: "DETECT_DRIFT",
  UPDATE: "UPDATE"
};
var StackSetOperationStatus = {
  FAILED: "FAILED",
  QUEUED: "QUEUED",
  RUNNING: "RUNNING",
  STOPPED: "STOPPED",
  STOPPING: "STOPPING",
  SUCCEEDED: "SUCCEEDED"
};
var DeprecatedStatus = {
  DEPRECATED: "DEPRECATED",
  LIVE: "LIVE"
};
var ProvisioningType = {
  FULLY_MUTABLE: "FULLY_MUTABLE",
  IMMUTABLE: "IMMUTABLE",
  NON_PROVISIONABLE: "NON_PROVISIONABLE"
};
var TypeTestsStatus = {
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS",
  NOT_TESTED: "NOT_TESTED",
  PASSED: "PASSED"
};
var Visibility = {
  PRIVATE: "PRIVATE",
  PUBLIC: "PUBLIC"
};
var RegistrationStatus = {
  COMPLETE: "COMPLETE",
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS"
};
var TemplateFormat = {
  JSON: "JSON",
  YAML: "YAML"
};
var TemplateStage = {
  Original: "Original",
  Processed: "Processed"
};
var _StackNotFoundException = class _StackNotFoundException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "StackNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "StackNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _StackNotFoundException.prototype);
    this.Message = opts.Message;
  }
};
__name(_StackNotFoundException, "StackNotFoundException");
var StackNotFoundException = _StackNotFoundException;
var _ResourceScanInProgressException = class _ResourceScanInProgressException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceScanInProgressException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceScanInProgressException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceScanInProgressException.prototype);
    this.Message = opts.Message;
  }
};
__name(_ResourceScanInProgressException, "ResourceScanInProgressException");
var ResourceScanInProgressException = _ResourceScanInProgressException;
var StackInstanceFilterName = {
  DETAILED_STATUS: "DETAILED_STATUS",
  DRIFT_STATUS: "DRIFT_STATUS",
  LAST_OPERATION_ID: "LAST_OPERATION_ID"
};
var OperationResultFilterName = {
  OPERATION_RESULT_STATUS: "OPERATION_RESULT_STATUS"
};
var StackSetOperationResultStatus = {
  CANCELLED: "CANCELLED",
  FAILED: "FAILED",
  PENDING: "PENDING",
  RUNNING: "RUNNING",
  SUCCEEDED: "SUCCEEDED"
};
var _InvalidStateTransitionException = class _InvalidStateTransitionException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidStateTransitionException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidStateTransitionException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidStateTransitionException.prototype);
    this.Message = opts.Message;
  }
};
__name(_InvalidStateTransitionException, "InvalidStateTransitionException");
var InvalidStateTransitionException = _InvalidStateTransitionException;
var _OperationStatusCheckFailedException = class _OperationStatusCheckFailedException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "OperationStatusCheckFailedException",
      $fault: "client",
      ...opts
    });
    this.name = "OperationStatusCheckFailedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _OperationStatusCheckFailedException.prototype);
    this.Message = opts.Message;
  }
};
__name(_OperationStatusCheckFailedException, "OperationStatusCheckFailedException");
var OperationStatusCheckFailedException = _OperationStatusCheckFailedException;
var OperationStatus = {
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS",
  PENDING: "PENDING",
  SUCCESS: "SUCCESS"
};
var HandlerErrorCode = {
  AccessDenied: "AccessDenied",
  AlreadyExists: "AlreadyExists",
  GeneralServiceException: "GeneralServiceException",
  HandlerInternalFailure: "HandlerInternalFailure",
  InternalFailure: "InternalFailure",
  InvalidCredentials: "InvalidCredentials",
  InvalidRequest: "InvalidRequest",
  InvalidTypeConfiguration: "InvalidTypeConfiguration",
  NetworkFailure: "NetworkFailure",
  NonCompliant: "NonCompliant",
  NotFound: "NotFound",
  NotUpdatable: "NotUpdatable",
  ResourceConflict: "ResourceConflict",
  ServiceInternalError: "ServiceInternalError",
  ServiceLimitExceeded: "ServiceLimitExceeded",
  ServiceTimeout: "NotStabilized",
  Throttling: "Throttling",
  Unknown: "Unknown",
  UnsupportedTarget: "UnsupportedTarget"
};

// src/models/models_1.ts
var ResourceSignalStatus = {
  FAILURE: "FAILURE",
  SUCCESS: "SUCCESS"
};
var _ResourceScanLimitExceededException = class _ResourceScanLimitExceededException extends CloudFormationServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceScanLimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceScanLimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceScanLimitExceededException.prototype);
    this.Message = opts.Message;
  }
};
__name(_ResourceScanLimitExceededException, "ResourceScanLimitExceededException");
var ResourceScanLimitExceededException = _ResourceScanLimitExceededException;

// src/protocols/Aws_query.ts
var se_ActivateOrganizationsAccessCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_ActivateOrganizationsAccessInput(input, context),
    [_A]: _AOA,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ActivateOrganizationsAccessCommand");
var se_ActivateTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_ActivateTypeInput(input, context),
    [_A]: _AT,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ActivateTypeCommand");
var se_BatchDescribeTypeConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_BatchDescribeTypeConfigurationsInput(input, context),
    [_A]: _BDTC,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_BatchDescribeTypeConfigurationsCommand");
var se_CancelUpdateStackCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_CancelUpdateStackInput(input, context),
    [_A]: _CUS,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CancelUpdateStackCommand");
var se_ContinueUpdateRollbackCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_ContinueUpdateRollbackInput(input, context),
    [_A]: _CUR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ContinueUpdateRollbackCommand");
var se_CreateChangeSetCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se