@aws-sdk/client-amplifybackend 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,11 +1,3560 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AmplifyBackendServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./AmplifyBackendClient"), exports);
-tslib_1.__exportStar(require("./AmplifyBackend"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var AmplifyBackendServiceException_1 = require("./models/AmplifyBackendServiceException");
-Object.defineProperty(exports, "AmplifyBackendServiceException", { enumerable: true, get: function () { return AmplifyBackendServiceException_1.AmplifyBackendServiceException; } });
+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, {
+  AdditionalConstraintsElement: () => AdditionalConstraintsElement,
+  AmplifyBackend: () => AmplifyBackend,
+  AmplifyBackendClient: () => AmplifyBackendClient,
+  AmplifyBackendServiceException: () => AmplifyBackendServiceException,
+  AuthResources: () => AuthResources,
+  AuthenticatedElement: () => AuthenticatedElement,
+  BackendAuthAppleProviderConfigFilterSensitiveLog: () => BackendAuthAppleProviderConfigFilterSensitiveLog,
+  BackendAuthSocialProviderConfigFilterSensitiveLog: () => BackendAuthSocialProviderConfigFilterSensitiveLog,
+  BadRequestException: () => BadRequestException,
+  CloneBackendCommand: () => CloneBackendCommand,
+  CreateBackendAPICommand: () => CreateBackendAPICommand,
+  CreateBackendAuthCommand: () => CreateBackendAuthCommand,
+  CreateBackendAuthForgotPasswordConfigFilterSensitiveLog: () => CreateBackendAuthForgotPasswordConfigFilterSensitiveLog,
+  CreateBackendAuthOAuthConfigFilterSensitiveLog: () => CreateBackendAuthOAuthConfigFilterSensitiveLog,
+  CreateBackendAuthRequestFilterSensitiveLog: () => CreateBackendAuthRequestFilterSensitiveLog,
+  CreateBackendAuthResourceConfigFilterSensitiveLog: () => CreateBackendAuthResourceConfigFilterSensitiveLog,
+  CreateBackendAuthUserPoolConfigFilterSensitiveLog: () => CreateBackendAuthUserPoolConfigFilterSensitiveLog,
+  CreateBackendAuthVerificationMessageConfigFilterSensitiveLog: () => CreateBackendAuthVerificationMessageConfigFilterSensitiveLog,
+  CreateBackendCommand: () => CreateBackendCommand,
+  CreateBackendConfigCommand: () => CreateBackendConfigCommand,
+  CreateBackendStorageCommand: () => CreateBackendStorageCommand,
+  CreateTokenCommand: () => CreateTokenCommand,
+  DeleteBackendAPICommand: () => DeleteBackendAPICommand,
+  DeleteBackendAuthCommand: () => DeleteBackendAuthCommand,
+  DeleteBackendCommand: () => DeleteBackendCommand,
+  DeleteBackendStorageCommand: () => DeleteBackendStorageCommand,
+  DeleteTokenCommand: () => DeleteTokenCommand,
+  DeliveryMethod: () => DeliveryMethod,
+  EmailSettingsFilterSensitiveLog: () => EmailSettingsFilterSensitiveLog,
+  GatewayTimeoutException: () => GatewayTimeoutException,
+  GenerateBackendAPIModelsCommand: () => GenerateBackendAPIModelsCommand,
+  GetBackendAPICommand: () => GetBackendAPICommand,
+  GetBackendAPIModelsCommand: () => GetBackendAPIModelsCommand,
+  GetBackendAuthCommand: () => GetBackendAuthCommand,
+  GetBackendAuthResponseFilterSensitiveLog: () => GetBackendAuthResponseFilterSensitiveLog,
+  GetBackendCommand: () => GetBackendCommand,
+  GetBackendJobCommand: () => GetBackendJobCommand,
+  GetBackendStorageCommand: () => GetBackendStorageCommand,
+  GetTokenCommand: () => GetTokenCommand,
+  ImportBackendAuthCommand: () => ImportBackendAuthCommand,
+  ImportBackendStorageCommand: () => ImportBackendStorageCommand,
+  ListBackendJobsCommand: () => ListBackendJobsCommand,
+  ListS3BucketsCommand: () => ListS3BucketsCommand,
+  MFAMode: () => MFAMode,
+  MfaTypesElement: () => MfaTypesElement,
+  Mode: () => Mode,
+  NotFoundException: () => NotFoundException,
+  OAuthGrantType: () => OAuthGrantType,
+  OAuthScopesElement: () => OAuthScopesElement,
+  RemoveAllBackendsCommand: () => RemoveAllBackendsCommand,
+  RemoveBackendConfigCommand: () => RemoveBackendConfigCommand,
+  RequiredSignUpAttributesElement: () => RequiredSignUpAttributesElement,
+  ResolutionStrategy: () => ResolutionStrategy,
+  Service: () => Service,
+  ServiceName: () => ServiceName,
+  SignInMethod: () => SignInMethod,
+  SmsSettingsFilterSensitiveLog: () => SmsSettingsFilterSensitiveLog,
+  SocialProviderSettingsFilterSensitiveLog: () => SocialProviderSettingsFilterSensitiveLog,
+  Status: () => Status,
+  TooManyRequestsException: () => TooManyRequestsException,
+  UnAuthenticatedElement: () => UnAuthenticatedElement,
+  UpdateBackendAPICommand: () => UpdateBackendAPICommand,
+  UpdateBackendAuthCommand: () => UpdateBackendAuthCommand,
+  UpdateBackendAuthForgotPasswordConfigFilterSensitiveLog: () => UpdateBackendAuthForgotPasswordConfigFilterSensitiveLog,
+  UpdateBackendAuthOAuthConfigFilterSensitiveLog: () => UpdateBackendAuthOAuthConfigFilterSensitiveLog,
+  UpdateBackendAuthRequestFilterSensitiveLog: () => UpdateBackendAuthRequestFilterSensitiveLog,
+  UpdateBackendAuthResourceConfigFilterSensitiveLog: () => UpdateBackendAuthResourceConfigFilterSensitiveLog,
+  UpdateBackendAuthUserPoolConfigFilterSensitiveLog: () => UpdateBackendAuthUserPoolConfigFilterSensitiveLog,
+  UpdateBackendAuthVerificationMessageConfigFilterSensitiveLog: () => UpdateBackendAuthVerificationMessageConfigFilterSensitiveLog,
+  UpdateBackendConfigCommand: () => UpdateBackendConfigCommand,
+  UpdateBackendJobCommand: () => UpdateBackendJobCommand,
+  UpdateBackendStorageCommand: () => UpdateBackendStorageCommand,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AmplifyBackendClient.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: "amplifybackend"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/AmplifyBackendClient.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/AmplifyBackendClient.ts
+var _AmplifyBackendClient = class _AmplifyBackendClient 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(_AmplifyBackendClient, "AmplifyBackendClient");
+var AmplifyBackendClient = _AmplifyBackendClient;
+
+// src/AmplifyBackend.ts
+
+
+// src/commands/CloneBackendCommand.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/AmplifyBackendServiceException.ts
+
+var _AmplifyBackendServiceException = class _AmplifyBackendServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _AmplifyBackendServiceException.prototype);
+  }
+};
+__name(_AmplifyBackendServiceException, "AmplifyBackendServiceException");
+var AmplifyBackendServiceException = _AmplifyBackendServiceException;
+
+// src/models/models_0.ts
+
+var AdditionalConstraintsElement = {
+  REQUIRE_DIGIT: "REQUIRE_DIGIT",
+  REQUIRE_LOWERCASE: "REQUIRE_LOWERCASE",
+  REQUIRE_SYMBOL: "REQUIRE_SYMBOL",
+  REQUIRE_UPPERCASE: "REQUIRE_UPPERCASE"
+};
+var _BadRequestException = class _BadRequestException extends AmplifyBackendServiceException {
+  /**
+   * @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 _GatewayTimeoutException = class _GatewayTimeoutException extends AmplifyBackendServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "GatewayTimeoutException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "GatewayTimeoutException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _GatewayTimeoutException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_GatewayTimeoutException, "GatewayTimeoutException");
+var GatewayTimeoutException = _GatewayTimeoutException;
+var _NotFoundException = class _NotFoundException extends AmplifyBackendServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+    this.Message = opts.Message;
+    this.ResourceType = opts.ResourceType;
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var _TooManyRequestsException = class _TooManyRequestsException extends AmplifyBackendServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyRequestsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyRequestsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
+    this.LimitType = opts.LimitType;
+    this.Message = opts.Message;
+  }
+};
+__name(_TooManyRequestsException, "TooManyRequestsException");
+var TooManyRequestsException = _TooManyRequestsException;
+var Mode = {
+  AMAZON_COGNITO_USER_POOLS: "AMAZON_COGNITO_USER_POOLS",
+  API_KEY: "API_KEY",
+  AWS_IAM: "AWS_IAM",
+  OPENID_CONNECT: "OPENID_CONNECT"
+};
+var ResolutionStrategy = {
+  AUTOMERGE: "AUTOMERGE",
+  LAMBDA: "LAMBDA",
+  NONE: "NONE",
+  OPTIMISTIC_CONCURRENCY: "OPTIMISTIC_CONCURRENCY"
+};
+var AuthResources = {
+  IDENTITY_POOL_AND_USER_POOL: "IDENTITY_POOL_AND_USER_POOL",
+  USER_POOL_ONLY: "USER_POOL_ONLY"
+};
+var Service = {
+  COGNITO: "COGNITO"
+};
+var DeliveryMethod = {
+  EMAIL: "EMAIL",
+  SMS: "SMS"
+};
+var MFAMode = {
+  OFF: "OFF",
+  ON: "ON",
+  OPTIONAL: "OPTIONAL"
+};
+var MfaTypesElement = {
+  SMS: "SMS",
+  TOTP: "TOTP"
+};
+var OAuthGrantType = {
+  CODE: "CODE",
+  IMPLICIT: "IMPLICIT"
+};
+var OAuthScopesElement = {
+  AWS_COGNITO_SIGNIN_USER_ADMIN: "AWS_COGNITO_SIGNIN_USER_ADMIN",
+  EMAIL: "EMAIL",
+  OPENID: "OPENID",
+  PHONE: "PHONE",
+  PROFILE: "PROFILE"
+};
+var RequiredSignUpAttributesElement = {
+  ADDRESS: "ADDRESS",
+  BIRTHDATE: "BIRTHDATE",
+  EMAIL: "EMAIL",
+  FAMILY_NAME: "FAMILY_NAME",
+  GENDER: "GENDER",
+  GIVEN_NAME: "GIVEN_NAME",
+  LOCALE: "LOCALE",
+  MIDDLE_NAME: "MIDDLE_NAME",
+  NAME: "NAME",
+  NICKNAME: "NICKNAME",
+  PHONE_NUMBER: "PHONE_NUMBER",
+  PICTURE: "PICTURE",
+  PREFERRED_USERNAME: "PREFERRED_USERNAME",
+  PROFILE: "PROFILE",
+  UPDATED_AT: "UPDATED_AT",
+  WEBSITE: "WEBSITE",
+  ZONE_INFO: "ZONE_INFO"
+};
+var SignInMethod = {
+  EMAIL: "EMAIL",
+  EMAIL_AND_PHONE_NUMBER: "EMAIL_AND_PHONE_NUMBER",
+  PHONE_NUMBER: "PHONE_NUMBER",
+  USERNAME: "USERNAME"
+};
+var AuthenticatedElement = {
+  CREATE_AND_UPDATE: "CREATE_AND_UPDATE",
+  DELETE: "DELETE",
+  READ: "READ"
+};
+var UnAuthenticatedElement = {
+  CREATE_AND_UPDATE: "CREATE_AND_UPDATE",
+  DELETE: "DELETE",
+  READ: "READ"
+};
+var ServiceName = {
+  S3: "S3"
+};
+var Status = {
+  LATEST: "LATEST",
+  STALE: "STALE"
+};
+var EmailSettingsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "EmailSettingsFilterSensitiveLog");
+var SmsSettingsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "SmsSettingsFilterSensitiveLog");
+var CreateBackendAuthForgotPasswordConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.EmailSettings && { EmailSettings: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SmsSettings && { SmsSettings: import_smithy_client.SENSITIVE_STRING }
+}), "CreateBackendAuthForgotPasswordConfigFilterSensitiveLog");
+var BackendAuthSocialProviderConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "BackendAuthSocialProviderConfigFilterSensitiveLog");
+var BackendAuthAppleProviderConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "BackendAuthAppleProviderConfigFilterSensitiveLog");
+var SocialProviderSettingsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Facebook && { Facebook: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Google && { Google: import_smithy_client.SENSITIVE_STRING },
+  ...obj.LoginWithAmazon && { LoginWithAmazon: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SignInWithApple && { SignInWithApple: import_smithy_client.SENSITIVE_STRING }
+}), "SocialProviderSettingsFilterSensitiveLog");
+var CreateBackendAuthOAuthConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.SocialProviderSettings && {
+    SocialProviderSettings: SocialProviderSettingsFilterSensitiveLog(obj.SocialProviderSettings)
+  }
+}), "CreateBackendAuthOAuthConfigFilterSensitiveLog");
+var CreateBackendAuthVerificationMessageConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.EmailSettings && { EmailSettings: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SmsSettings && { SmsSettings: import_smithy_client.SENSITIVE_STRING }
+}), "CreateBackendAuthVerificationMessageConfigFilterSensitiveLog");
+var CreateBackendAuthUserPoolConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ForgotPassword && {
+    ForgotPassword: CreateBackendAuthForgotPasswordConfigFilterSensitiveLog(obj.ForgotPassword)
+  },
+  ...obj.OAuth && { OAuth: CreateBackendAuthOAuthConfigFilterSensitiveLog(obj.OAuth) },
+  ...obj.VerificationMessage && {
+    VerificationMessage: CreateBackendAuthVerificationMessageConfigFilterSensitiveLog(obj.VerificationMessage)
+  }
+}), "CreateBackendAuthUserPoolConfigFilterSensitiveLog");
+var CreateBackendAuthResourceConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.UserPoolConfigs && {
+    UserPoolConfigs: CreateBackendAuthUserPoolConfigFilterSensitiveLog(obj.UserPoolConfigs)
+  }
+}), "CreateBackendAuthResourceConfigFilterSensitiveLog");
+var CreateBackendAuthRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ResourceConfig && { ResourceConfig: CreateBackendAuthResourceConfigFilterSensitiveLog(obj.ResourceConfig) }
+}), "CreateBackendAuthRequestFilterSensitiveLog");
+var GetBackendAuthResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ResourceConfig && { ResourceConfig: CreateBackendAuthResourceConfigFilterSensitiveLog(obj.ResourceConfig) }
+}), "GetBackendAuthResponseFilterSensitiveLog");
+var UpdateBackendAuthForgotPasswordConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.EmailSettings && { EmailSettings: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SmsSettings && { SmsSettings: import_smithy_client.SENSITIVE_STRING }
+}), "UpdateBackendAuthForgotPasswordConfigFilterSensitiveLog");
+var UpdateBackendAuthOAuthConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.SocialProviderSettings && {
+    SocialProviderSettings: SocialProviderSettingsFilterSensitiveLog(obj.SocialProviderSettings)
+  }
+}), "UpdateBackendAuthOAuthConfigFilterSensitiveLog");
+var UpdateBackendAuthVerificationMessageConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.EmailSettings && { EmailSettings: import_smithy_client.SENSITIVE_STRING },
+  ...obj.SmsSettings && { SmsSettings: import_smithy_client.SENSITIVE_STRING }
+}), "UpdateBackendAuthVerificationMessageConfigFilterSensitiveLog");
+var UpdateBackendAuthUserPoolConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ForgotPassword && {
+    ForgotPassword: UpdateBackendAuthForgotPasswordConfigFilterSensitiveLog(obj.ForgotPassword)
+  },
+  ...obj.OAuth && { OAuth: UpdateBackendAuthOAuthConfigFilterSensitiveLog(obj.OAuth) },
+  ...obj.VerificationMessage && {
+    VerificationMessage: UpdateBackendAuthVerificationMessageConfigFilterSensitiveLog(obj.VerificationMessage)
+  }
+}), "UpdateBackendAuthUserPoolConfigFilterSensitiveLog");
+var UpdateBackendAuthResourceConfigFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.UserPoolConfigs && {
+    UserPoolConfigs: UpdateBackendAuthUserPoolConfigFilterSensitiveLog(obj.UserPoolConfigs)
+  }
+}), "UpdateBackendAuthResourceConfigFilterSensitiveLog");
+var UpdateBackendAuthRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ResourceConfig && { ResourceConfig: UpdateBackendAuthResourceConfigFilterSensitiveLog(obj.ResourceConfig) }
+}), "UpdateBackendAuthRequestFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_CloneBackendCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/environments/{BackendEnvironmentName}/clone");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      targetEnvironmentName: [, , `TargetEnvironmentName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CloneBackendCommand");
+var se_CreateBackendCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      appId: [, , `AppId`],
+      appName: [, , `AppName`],
+      backendEnvironmentName: [, , `BackendEnvironmentName`],
+      resourceConfig: [, (_) => (0, import_smithy_client._json)(_), `ResourceConfig`],
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateBackendCommand");
+var se_CreateBackendAPICommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/api");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      backendEnvironmentName: [, , `BackendEnvironmentName`],
+      resourceConfig: [, (_) => se_BackendAPIResourceConfig(_, context), `ResourceConfig`],
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateBackendAPICommand");
+var se_CreateBackendAuthCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/auth");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      backendEnvironmentName: [, , `BackendEnvironmentName`],
+      resourceConfig: [, (_) => se_CreateBackendAuthResourceConfig(_, context), `ResourceConfig`],
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateBackendAuthCommand");
+var se_CreateBackendConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/config");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      backendManagerAppId: [, , `BackendManagerAppId`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateBackendConfigCommand");
+var se_CreateBackendStorageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/storage");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      backendEnvironmentName: [, , `BackendEnvironmentName`],
+      resourceConfig: [, (_) => se_CreateBackendStorageResourceConfig(_, context), `ResourceConfig`],
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateBackendStorageCommand");
+var se_CreateTokenCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/backend/{AppId}/challenge");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateTokenCommand");
+var se_DeleteBackendCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/backend/{AppId}/environments/{BackendEnvironmentName}/remove");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteBackendCommand");
+var se_DeleteBackendAPICommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/api/{BackendEnvironmentName}/remove");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceConfig: [, (_) => se_BackendAPIResourceConfig(_, context), `ResourceConfig`],
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteBackendAPICommand");
+var se_DeleteBackendAuthCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/auth/{BackendEnvironmentName}/remove");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteBackendAuthCommand");
+var se_DeleteBackendStorageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/storage/{BackendEnvironmentName}/remove");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceName: [, , `ResourceName`],
+      serviceName: [, , `ServiceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteBackendStorageCommand");
+var se_DeleteTokenCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/backend/{AppId}/challenge/{SessionId}/remove");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("SessionId", () => input.SessionId, "{SessionId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteTokenCommand");
+var se_GenerateBackendAPIModelsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/api/{BackendEnvironmentName}/generateModels");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GenerateBackendAPIModelsCommand");
+var se_GetBackendCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/details");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      backendEnvironmentName: [, , `BackendEnvironmentName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetBackendCommand");
+var se_GetBackendAPICommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/api/{BackendEnvironmentName}/details");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceConfig: [, (_) => se_BackendAPIResourceConfig(_, context), `ResourceConfig`],
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetBackendAPICommand");
+var se_GetBackendAPIModelsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/api/{BackendEnvironmentName}/getModels");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetBackendAPIModelsCommand");
+var se_GetBackendAuthCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/auth/{BackendEnvironmentName}/details");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetBackendAuthCommand");
+var se_GetBackendJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/backend/{AppId}/job/{BackendEnvironmentName}/{JobId}");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  b.p("JobId", () => input.JobId, "{JobId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetBackendJobCommand");
+var se_GetBackendStorageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/storage/{BackendEnvironmentName}/details");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetBackendStorageCommand");
+var se_GetTokenCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/backend/{AppId}/challenge/{SessionId}");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("SessionId", () => input.SessionId, "{SessionId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTokenCommand");
+var se_ImportBackendAuthCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/auth/{BackendEnvironmentName}/import");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      identityPoolId: [, , `IdentityPoolId`],
+      nativeClientId: [, , `NativeClientId`],
+      userPoolId: [, , `UserPoolId`],
+      webClientId: [, , `WebClientId`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ImportBackendAuthCommand");
+var se_ImportBackendStorageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/storage/{BackendEnvironmentName}/import");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      bucketName: [, , `BucketName`],
+      serviceName: [, , `ServiceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ImportBackendStorageCommand");
+var se_ListBackendJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/job/{BackendEnvironmentName}");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      jobId: [, , `JobId`],
+      maxResults: [, , `MaxResults`],
+      nextToken: [, , `NextToken`],
+      operation: [, , `Operation`],
+      status: [, , `Status`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListBackendJobsCommand");
+var se_ListS3BucketsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/s3Buckets");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      nextToken: [, , `NextToken`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListS3BucketsCommand");
+var se_RemoveAllBackendsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/remove");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      cleanAmplifyApp: [, , `CleanAmplifyApp`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_RemoveAllBackendsCommand");
+var se_RemoveBackendConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/backend/{AppId}/config/remove");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_RemoveBackendConfigCommand");
+var se_UpdateBackendAPICommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/api/{BackendEnvironmentName}");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceConfig: [, (_) => se_BackendAPIResourceConfig(_, context), `ResourceConfig`],
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateBackendAPICommand");
+var se_UpdateBackendAuthCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/auth/{BackendEnvironmentName}");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceConfig: [, (_) => se_UpdateBackendAuthResourceConfig(_, context), `ResourceConfig`],
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateBackendAuthCommand");
+var se_UpdateBackendConfigCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/config/update");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      loginAuthConfig: [, (_) => se_LoginAuthConfigReqObj(_, context), `LoginAuthConfig`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateBackendConfigCommand");
+var se_UpdateBackendJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/job/{BackendEnvironmentName}/{JobId}");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  b.p("JobId", () => input.JobId, "{JobId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      operation: [, , `Operation`],
+      status: [, , `Status`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateBackendJobCommand");
+var se_UpdateBackendStorageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/backend/{AppId}/storage/{BackendEnvironmentName}");
+  b.p("AppId", () => input.AppId, "{AppId}", false);
+  b.p("BackendEnvironmentName", () => input.BackendEnvironmentName, "{BackendEnvironmentName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceConfig: [, (_) => se_UpdateBackendStorageResourceConfig(_, context), `ResourceConfig`],
+      resourceName: [, , `ResourceName`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateBackendStorageCommand");
+var de_CloneBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CloneBackendCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CloneBackendCommand");
+var de_CloneBackendCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CloneBackendCommandError");
+var de_CreateBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateBackendCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateBackendCommand");
+var de_CreateBackendCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateBackendCommandError");
+var de_CreateBackendAPICommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateBackendAPICommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateBackendAPICommand");
+var de_CreateBackendAPICommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateBackendAPICommandError");
+var de_CreateBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateBackendAuthCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateBackendAuthCommand");
+var de_CreateBackendAuthCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateBackendAuthCommandError");
+var de_CreateBackendConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateBackendConfigCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateBackendConfigCommand");
+var de_CreateBackendConfigCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateBackendConfigCommandError");
+var de_CreateBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateBackendStorageCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateBackendStorageCommand");
+var de_CreateBackendStorageCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateBackendStorageCommandError");
+var de_CreateTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateTokenCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    ChallengeCode: [, import_smithy_client.expectString, `challengeCode`],
+    SessionId: [, import_smithy_client.expectString, `sessionId`],
+    Ttl: [, import_smithy_client.expectString, `ttl`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateTokenCommand");
+var de_CreateTokenCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateTokenCommandError");
+var de_DeleteBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteBackendCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteBackendCommand");
+var de_DeleteBackendCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteBackendCommandError");
+var de_DeleteBackendAPICommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteBackendAPICommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteBackendAPICommand");
+var de_DeleteBackendAPICommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteBackendAPICommandError");
+var de_DeleteBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteBackendAuthCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteBackendAuthCommand");
+var de_DeleteBackendAuthCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteBackendAuthCommandError");
+var de_DeleteBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteBackendStorageCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteBackendStorageCommand");
+var de_DeleteBackendStorageCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteBackendStorageCommandError");
+var de_DeleteTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteTokenCommandError(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, {
+    IsSuccess: [, import_smithy_client.expectBoolean, `isSuccess`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteTokenCommand");
+var de_DeleteTokenCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteTokenCommandError");
+var de_GenerateBackendAPIModelsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GenerateBackendAPIModelsCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GenerateBackendAPIModelsCommand");
+var de_GenerateBackendAPIModelsCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GenerateBackendAPIModelsCommandError");
+var de_GetBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetBackendCommandError(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, {
+    AmplifyFeatureFlags: [, import_smithy_client.expectString, `amplifyFeatureFlags`],
+    AmplifyMetaConfig: [, import_smithy_client.expectString, `amplifyMetaConfig`],
+    AppId: [, import_smithy_client.expectString, `appId`],
+    AppName: [, import_smithy_client.expectString, `appName`],
+    BackendEnvironmentList: [, import_smithy_client._json, `backendEnvironmentList`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetBackendCommand");
+var de_GetBackendCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetBackendCommandError");
+var de_GetBackendAPICommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetBackendAPICommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    ResourceConfig: [, (_) => de_BackendAPIResourceConfig(_, context), `resourceConfig`],
+    ResourceName: [, import_smithy_client.expectString, `resourceName`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetBackendAPICommand");
+var de_GetBackendAPICommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetBackendAPICommandError");
+var de_GetBackendAPIModelsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetBackendAPIModelsCommandError(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, {
+    ModelIntrospectionSchema: [, import_smithy_client.expectString, `modelIntrospectionSchema`],
+    Models: [, import_smithy_client.expectString, `models`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetBackendAPIModelsCommand");
+var de_GetBackendAPIModelsCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetBackendAPIModelsCommandError");
+var de_GetBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetBackendAuthCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    ResourceConfig: [, (_) => de_CreateBackendAuthResourceConfig(_, context), `resourceConfig`],
+    ResourceName: [, import_smithy_client.expectString, `resourceName`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetBackendAuthCommand");
+var de_GetBackendAuthCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetBackendAuthCommandError");
+var de_GetBackendJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetBackendJobCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    CreateTime: [, import_smithy_client.expectString, `createTime`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`],
+    UpdateTime: [, import_smithy_client.expectString, `updateTime`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetBackendJobCommand");
+var de_GetBackendJobCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetBackendJobCommandError");
+var de_GetBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetBackendStorageCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    ResourceConfig: [, (_) => de_GetBackendStorageResourceConfig(_, context), `resourceConfig`],
+    ResourceName: [, import_smithy_client.expectString, `resourceName`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetBackendStorageCommand");
+var de_GetBackendStorageCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetBackendStorageCommandError");
+var de_GetTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTokenCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    ChallengeCode: [, import_smithy_client.expectString, `challengeCode`],
+    SessionId: [, import_smithy_client.expectString, `sessionId`],
+    Ttl: [, import_smithy_client.expectString, `ttl`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTokenCommand");
+var de_GetTokenCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTokenCommandError");
+var de_ImportBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ImportBackendAuthCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ImportBackendAuthCommand");
+var de_ImportBackendAuthCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ImportBackendAuthCommandError");
+var de_ImportBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ImportBackendStorageCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ImportBackendStorageCommand");
+var de_ImportBackendStorageCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ImportBackendStorageCommandError");
+var de_ListBackendJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListBackendJobsCommandError(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, {
+    Jobs: [, (_) => de_ListOfBackendJobRespObj(_, context), `jobs`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListBackendJobsCommand");
+var de_ListBackendJobsCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListBackendJobsCommandError");
+var de_ListS3BucketsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListS3BucketsCommandError(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, {
+    Buckets: [, (_) => de_ListOfS3BucketInfo(_, context), `buckets`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListS3BucketsCommand");
+var de_ListS3BucketsCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListS3BucketsCommandError");
+var de_RemoveAllBackendsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_RemoveAllBackendsCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_RemoveAllBackendsCommand");
+var de_RemoveAllBackendsCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RemoveAllBackendsCommandError");
+var de_RemoveBackendConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_RemoveBackendConfigCommandError(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, {
+    Error: [, import_smithy_client.expectString, `error`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_RemoveBackendConfigCommand");
+var de_RemoveBackendConfigCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RemoveBackendConfigCommandError");
+var de_UpdateBackendAPICommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateBackendAPICommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateBackendAPICommand");
+var de_UpdateBackendAPICommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateBackendAPICommandError");
+var de_UpdateBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateBackendAuthCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateBackendAuthCommand");
+var de_UpdateBackendAuthCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateBackendAuthCommandError");
+var de_UpdateBackendConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateBackendConfigCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendManagerAppId: [, import_smithy_client.expectString, `backendManagerAppId`],
+    Error: [, import_smithy_client.expectString, `error`],
+    LoginAuthConfig: [, (_) => de_LoginAuthConfigReqObj(_, context), `loginAuthConfig`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateBackendConfigCommand");
+var de_UpdateBackendConfigCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateBackendConfigCommandError");
+var de_UpdateBackendJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateBackendJobCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    CreateTime: [, import_smithy_client.expectString, `createTime`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`],
+    UpdateTime: [, import_smithy_client.expectString, `updateTime`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateBackendJobCommand");
+var de_UpdateBackendJobCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateBackendJobCommandError");
+var de_UpdateBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateBackendStorageCommandError(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, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateBackendStorageCommand");
+var de_UpdateBackendStorageCommandError = /* @__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.amplifybackend#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "GatewayTimeoutException":
+    case "com.amazonaws.amplifybackend#GatewayTimeoutException":
+      throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.amplifybackend#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.amplifybackend#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateBackendStorageCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(AmplifyBackendServiceException);
+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, `message`]
+  });
+  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_GatewayTimeoutExceptionRes = /* @__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, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new GatewayTimeoutException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_GatewayTimeoutExceptionRes");
+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, `message`],
+    ResourceType: [, import_smithy_client.expectString, `resourceType`]
+  });
+  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, {
+    LimitType: [, import_smithy_client.expectString, `limitType`],
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new TooManyRequestsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyRequestsExceptionRes");
+var se_BackendAPIAppSyncAuthSettings = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    cognitoUserPoolId: [, , `CognitoUserPoolId`],
+    description: [, , `Description`],
+    expirationTime: [, import_smithy_client.serializeFloat, `ExpirationTime`],
+    openIDAuthTTL: [, , `OpenIDAuthTTL`],
+    openIDClientId: [, , `OpenIDClientId`],
+    openIDIatTTL: [, , `OpenIDIatTTL`],
+    openIDIssueURL: [, , `OpenIDIssueURL`],
+    openIDProviderName: [, , `OpenIDProviderName`]
+  });
+}, "se_BackendAPIAppSyncAuthSettings");
+var se_BackendAPIAuthType = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    mode: [, , `Mode`],
+    settings: [, (_) => se_BackendAPIAppSyncAuthSettings(_, context), `Settings`]
+  });
+}, "se_BackendAPIAuthType");
+var se_BackendAPIConflictResolution = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    resolutionStrategy: [, , `ResolutionStrategy`]
+  });
+}, "se_BackendAPIConflictResolution");
+var se_BackendAPIResourceConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    additionalAuthTypes: [, (_) => se_ListOfBackendAPIAuthType(_, context), `AdditionalAuthTypes`],
+    apiName: [, , `ApiName`],
+    conflictResolution: [, (_) => se_BackendAPIConflictResolution(_, context), `ConflictResolution`],
+    defaultAuthType: [, (_) => se_BackendAPIAuthType(_, context), `DefaultAuthType`],
+    service: [, , `Service`],
+    transformSchema: [, , `TransformSchema`]
+  });
+}, "se_BackendAPIResourceConfig");
+var se_BackendAuthAppleProviderConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    client_id: [, , `ClientId`],
+    key_id: [, , `KeyId`],
+    private_key: [, , `PrivateKey`],
+    team_id: [, , `TeamId`]
+  });
+}, "se_BackendAuthAppleProviderConfig");
+var se_BackendAuthSocialProviderConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    client_id: [, , `ClientId`],
+    client_secret: [, , `ClientSecret`]
+  });
+}, "se_BackendAuthSocialProviderConfig");
+var se_BackendStoragePermissions = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    authenticated: [, import_smithy_client._json, `Authenticated`],
+    unAuthenticated: [, import_smithy_client._json, `UnAuthenticated`]
+  });
+}, "se_BackendStoragePermissions");
+var se_CreateBackendAuthForgotPasswordConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    deliveryMethod: [, , `DeliveryMethod`],
+    emailSettings: [, (_) => se_EmailSettings(_, context), `EmailSettings`],
+    smsSettings: [, (_) => se_SmsSettings(_, context), `SmsSettings`]
+  });
+}, "se_CreateBackendAuthForgotPasswordConfig");
+var se_CreateBackendAuthIdentityPoolConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    identityPoolName: [, , `IdentityPoolName`],
+    unauthenticatedLogin: [, , `UnauthenticatedLogin`]
+  });
+}, "se_CreateBackendAuthIdentityPoolConfig");
+var se_CreateBackendAuthMFAConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    MFAMode: [],
+    settings: [, (_) => se_Settings(_, context), `Settings`]
+  });
+}, "se_CreateBackendAuthMFAConfig");
+var se_CreateBackendAuthOAuthConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    domainPrefix: [, , `DomainPrefix`],
+    oAuthGrantType: [, , `OAuthGrantType`],
+    oAuthScopes: [, import_smithy_client._json, `OAuthScopes`],
+    redirectSignInURIs: [, import_smithy_client._json, `RedirectSignInURIs`],
+    redirectSignOutURIs: [, import_smithy_client._json, `RedirectSignOutURIs`],
+    socialProviderSettings: [, (_) => se_SocialProviderSettings(_, context), `SocialProviderSettings`]
+  });
+}, "se_CreateBackendAuthOAuthConfig");
+var se_CreateBackendAuthPasswordPolicyConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    additionalConstraints: [, import_smithy_client._json, `AdditionalConstraints`],
+    minimumLength: [, import_smithy_client.serializeFloat, `MinimumLength`]
+  });
+}, "se_CreateBackendAuthPasswordPolicyConfig");
+var se_CreateBackendAuthResourceConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    authResources: [, , `AuthResources`],
+    identityPoolConfigs: [, (_) => se_CreateBackendAuthIdentityPoolConfig(_, context), `IdentityPoolConfigs`],
+    service: [, , `Service`],
+    userPoolConfigs: [, (_) => se_CreateBackendAuthUserPoolConfig(_, context), `UserPoolConfigs`]
+  });
+}, "se_CreateBackendAuthResourceConfig");
+var se_CreateBackendAuthUserPoolConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    forgotPassword: [, (_) => se_CreateBackendAuthForgotPasswordConfig(_, context), `ForgotPassword`],
+    mfa: [, (_) => se_CreateBackendAuthMFAConfig(_, context), `Mfa`],
+    oAuth: [, (_) => se_CreateBackendAuthOAuthConfig(_, context), `OAuth`],
+    passwordPolicy: [, (_) => se_CreateBackendAuthPasswordPolicyConfig(_, context), `PasswordPolicy`],
+    requiredSignUpAttributes: [, import_smithy_client._json, `RequiredSignUpAttributes`],
+    signInMethod: [, , `SignInMethod`],
+    userPoolName: [, , `UserPoolName`],
+    verificationMessage: [, (_) => se_CreateBackendAuthVerificationMessageConfig(_, context), `VerificationMessage`]
+  });
+}, "se_CreateBackendAuthUserPoolConfig");
+var se_CreateBackendAuthVerificationMessageConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    deliveryMethod: [, , `DeliveryMethod`],
+    emailSettings: [, (_) => se_EmailSettings(_, context), `EmailSettings`],
+    smsSettings: [, (_) => se_SmsSettings(_, context), `SmsSettings`]
+  });
+}, "se_CreateBackendAuthVerificationMessageConfig");
+var se_CreateBackendStorageResourceConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    bucketName: [, , `BucketName`],
+    permissions: [, (_) => se_BackendStoragePermissions(_, context), `Permissions`],
+    serviceName: [, , `ServiceName`]
+  });
+}, "se_CreateBackendStorageResourceConfig");
+var se_EmailSettings = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    emailMessage: [, , `EmailMessage`],
+    emailSubject: [, , `EmailSubject`]
+  });
+}, "se_EmailSettings");
+var se_ListOfBackendAPIAuthType = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_BackendAPIAuthType(entry, context);
+  });
+}, "se_ListOfBackendAPIAuthType");
+var se_LoginAuthConfigReqObj = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    aws_cognito_identity_pool_id: [, , `AwsCognitoIdentityPoolId`],
+    aws_cognito_region: [, , `AwsCognitoRegion`],
+    aws_user_pools_id: [, , `AwsUserPoolsId`],
+    aws_user_pools_web_client_id: [, , `AwsUserPoolsWebClientId`]
+  });
+}, "se_LoginAuthConfigReqObj");
+var se_Settings = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    mfaTypes: [, import_smithy_client._json, `MfaTypes`],
+    smsMessage: [, , `SmsMessage`]
+  });
+}, "se_Settings");
+var se_SmsSettings = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    smsMessage: [, , `SmsMessage`]
+  });
+}, "se_SmsSettings");
+var se_SocialProviderSettings = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Facebook: (_) => se_BackendAuthSocialProviderConfig(_, context),
+    Google: (_) => se_BackendAuthSocialProviderConfig(_, context),
+    LoginWithAmazon: (_) => se_BackendAuthSocialProviderConfig(_, context),
+    SignInWithApple: (_) => se_BackendAuthAppleProviderConfig(_, context)
+  });
+}, "se_SocialProviderSettings");
+var se_UpdateBackendAuthForgotPasswordConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    deliveryMethod: [, , `DeliveryMethod`],
+    emailSettings: [, (_) => se_EmailSettings(_, context), `EmailSettings`],
+    smsSettings: [, (_) => se_SmsSettings(_, context), `SmsSettings`]
+  });
+}, "se_UpdateBackendAuthForgotPasswordConfig");
+var se_UpdateBackendAuthIdentityPoolConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    unauthenticatedLogin: [, , `UnauthenticatedLogin`]
+  });
+}, "se_UpdateBackendAuthIdentityPoolConfig");
+var se_UpdateBackendAuthMFAConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    MFAMode: [],
+    settings: [, (_) => se_Settings(_, context), `Settings`]
+  });
+}, "se_UpdateBackendAuthMFAConfig");
+var se_UpdateBackendAuthOAuthConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    domainPrefix: [, , `DomainPrefix`],
+    oAuthGrantType: [, , `OAuthGrantType`],
+    oAuthScopes: [, import_smithy_client._json, `OAuthScopes`],
+    redirectSignInURIs: [, import_smithy_client._json, `RedirectSignInURIs`],
+    redirectSignOutURIs: [, import_smithy_client._json, `RedirectSignOutURIs`],
+    socialProviderSettings: [, (_) => se_SocialProviderSettings(_, context), `SocialProviderSettings`]
+  });
+}, "se_UpdateBackendAuthOAuthConfig");
+var se_UpdateBackendAuthPasswordPolicyConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    additionalConstraints: [, import_smithy_client._json, `AdditionalConstraints`],
+    minimumLength: [, import_smithy_client.serializeFloat, `MinimumLength`]
+  });
+}, "se_UpdateBackendAuthPasswordPolicyConfig");
+var se_UpdateBackendAuthResourceConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    authResources: [, , `AuthResources`],
+    identityPoolConfigs: [, (_) => se_UpdateBackendAuthIdentityPoolConfig(_, context), `IdentityPoolConfigs`],
+    service: [, , `Service`],
+    userPoolConfigs: [, (_) => se_UpdateBackendAuthUserPoolConfig(_, context), `UserPoolConfigs`]
+  });
+}, "se_UpdateBackendAuthResourceConfig");
+var se_UpdateBackendAuthUserPoolConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    forgotPassword: [, (_) => se_UpdateBackendAuthForgotPasswordConfig(_, context), `ForgotPassword`],
+    mfa: [, (_) => se_UpdateBackendAuthMFAConfig(_, context), `Mfa`],
+    oAuth: [, (_) => se_UpdateBackendAuthOAuthConfig(_, context), `OAuth`],
+    passwordPolicy: [, (_) => se_UpdateBackendAuthPasswordPolicyConfig(_, context), `PasswordPolicy`],
+    verificationMessage: [, (_) => se_UpdateBackendAuthVerificationMessageConfig(_, context), `VerificationMessage`]
+  });
+}, "se_UpdateBackendAuthUserPoolConfig");
+var se_UpdateBackendAuthVerificationMessageConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    deliveryMethod: [, , `DeliveryMethod`],
+    emailSettings: [, (_) => se_EmailSettings(_, context), `EmailSettings`],
+    smsSettings: [, (_) => se_SmsSettings(_, context), `SmsSettings`]
+  });
+}, "se_UpdateBackendAuthVerificationMessageConfig");
+var se_UpdateBackendStorageResourceConfig = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    permissions: [, (_) => se_BackendStoragePermissions(_, context), `Permissions`],
+    serviceName: [, , `ServiceName`]
+  });
+}, "se_UpdateBackendStorageResourceConfig");
+var de_BackendAPIAppSyncAuthSettings = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CognitoUserPoolId: [, import_smithy_client.expectString, `cognitoUserPoolId`],
+    Description: [, import_smithy_client.expectString, `description`],
+    ExpirationTime: [, import_smithy_client.limitedParseDouble, `expirationTime`],
+    OpenIDAuthTTL: [, import_smithy_client.expectString, `openIDAuthTTL`],
+    OpenIDClientId: [, import_smithy_client.expectString, `openIDClientId`],
+    OpenIDIatTTL: [, import_smithy_client.expectString, `openIDIatTTL`],
+    OpenIDIssueURL: [, import_smithy_client.expectString, `openIDIssueURL`],
+    OpenIDProviderName: [, import_smithy_client.expectString, `openIDProviderName`]
+  });
+}, "de_BackendAPIAppSyncAuthSettings");
+var de_BackendAPIAuthType = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Mode: [, import_smithy_client.expectString, `mode`],
+    Settings: [, (_) => de_BackendAPIAppSyncAuthSettings(_, context), `settings`]
+  });
+}, "de_BackendAPIAuthType");
+var de_BackendAPIConflictResolution = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ResolutionStrategy: [, import_smithy_client.expectString, `resolutionStrategy`]
+  });
+}, "de_BackendAPIConflictResolution");
+var de_BackendAPIResourceConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdditionalAuthTypes: [, (_) => de_ListOfBackendAPIAuthType(_, context), `additionalAuthTypes`],
+    ApiName: [, import_smithy_client.expectString, `apiName`],
+    ConflictResolution: [, (_) => de_BackendAPIConflictResolution(_, context), `conflictResolution`],
+    DefaultAuthType: [, (_) => de_BackendAPIAuthType(_, context), `defaultAuthType`],
+    Service: [, import_smithy_client.expectString, `service`],
+    TransformSchema: [, import_smithy_client.expectString, `transformSchema`]
+  });
+}, "de_BackendAPIResourceConfig");
+var de_BackendAuthAppleProviderConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ClientId: [, import_smithy_client.expectString, `client_id`],
+    KeyId: [, import_smithy_client.expectString, `key_id`],
+    PrivateKey: [, import_smithy_client.expectString, `private_key`],
+    TeamId: [, import_smithy_client.expectString, `team_id`]
+  });
+}, "de_BackendAuthAppleProviderConfig");
+var de_BackendAuthSocialProviderConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ClientId: [, import_smithy_client.expectString, `client_id`],
+    ClientSecret: [, import_smithy_client.expectString, `client_secret`]
+  });
+}, "de_BackendAuthSocialProviderConfig");
+var de_BackendJobRespObj = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AppId: [, import_smithy_client.expectString, `appId`],
+    BackendEnvironmentName: [, import_smithy_client.expectString, `backendEnvironmentName`],
+    CreateTime: [, import_smithy_client.expectString, `createTime`],
+    Error: [, import_smithy_client.expectString, `error`],
+    JobId: [, import_smithy_client.expectString, `jobId`],
+    Operation: [, import_smithy_client.expectString, `operation`],
+    Status: [, import_smithy_client.expectString, `status`],
+    UpdateTime: [, import_smithy_client.expectString, `updateTime`]
+  });
+}, "de_BackendJobRespObj");
+var de_BackendStoragePermissions = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Authenticated: [, import_smithy_client._json, `authenticated`],
+    UnAuthenticated: [, import_smithy_client._json, `unAuthenticated`]
+  });
+}, "de_BackendStoragePermissions");
+var de_CreateBackendAuthForgotPasswordConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DeliveryMethod: [, import_smithy_client.expectString, `deliveryMethod`],
+    EmailSettings: [, (_) => de_EmailSettings(_, context), `emailSettings`],
+    SmsSettings: [, (_) => de_SmsSettings(_, context), `smsSettings`]
+  });
+}, "de_CreateBackendAuthForgotPasswordConfig");
+var de_CreateBackendAuthIdentityPoolConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    IdentityPoolName: [, import_smithy_client.expectString, `identityPoolName`],
+    UnauthenticatedLogin: [, import_smithy_client.expectBoolean, `unauthenticatedLogin`]
+  });
+}, "de_CreateBackendAuthIdentityPoolConfig");
+var de_CreateBackendAuthMFAConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MFAMode: import_smithy_client.expectString,
+    Settings: [, (_) => de_Settings(_, context), `settings`]
+  });
+}, "de_CreateBackendAuthMFAConfig");
+var de_CreateBackendAuthOAuthConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DomainPrefix: [, import_smithy_client.expectString, `domainPrefix`],
+    OAuthGrantType: [, import_smithy_client.expectString, `oAuthGrantType`],
+    OAuthScopes: [, import_smithy_client._json, `oAuthScopes`],
+    RedirectSignInURIs: [, import_smithy_client._json, `redirectSignInURIs`],
+    RedirectSignOutURIs: [, import_smithy_client._json, `redirectSignOutURIs`],
+    SocialProviderSettings: [, (_) => de_SocialProviderSettings(_, context), `socialProviderSettings`]
+  });
+}, "de_CreateBackendAuthOAuthConfig");
+var de_CreateBackendAuthPasswordPolicyConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdditionalConstraints: [, import_smithy_client._json, `additionalConstraints`],
+    MinimumLength: [, import_smithy_client.limitedParseDouble, `minimumLength`]
+  });
+}, "de_CreateBackendAuthPasswordPolicyConfig");
+var de_CreateBackendAuthResourceConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AuthResources: [, import_smithy_client.expectString, `authResources`],
+    IdentityPoolConfigs: [, (_) => de_CreateBackendAuthIdentityPoolConfig(_, context), `identityPoolConfigs`],
+    Service: [, import_smithy_client.expectString, `service`],
+    UserPoolConfigs: [, (_) => de_CreateBackendAuthUserPoolConfig(_, context), `userPoolConfigs`]
+  });
+}, "de_CreateBackendAuthResourceConfig");
+var de_CreateBackendAuthUserPoolConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ForgotPassword: [, (_) => de_CreateBackendAuthForgotPasswordConfig(_, context), `forgotPassword`],
+    Mfa: [, (_) => de_CreateBackendAuthMFAConfig(_, context), `mfa`],
+    OAuth: [, (_) => de_CreateBackendAuthOAuthConfig(_, context), `oAuth`],
+    PasswordPolicy: [, (_) => de_CreateBackendAuthPasswordPolicyConfig(_, context), `passwordPolicy`],
+    RequiredSignUpAttributes: [, import_smithy_client._json, `requiredSignUpAttributes`],
+    SignInMethod: [, import_smithy_client.expectString, `signInMethod`],
+    UserPoolName: [, import_smithy_client.expectString, `userPoolName`],
+    VerificationMessage: [
+      ,
+      (_) => de_CreateBackendAuthVerificationMessageConfig(_, context),
+      `verificationMessage`
+    ]
+  });
+}, "de_CreateBackendAuthUserPoolConfig");
+var de_CreateBackendAuthVerificationMessageConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DeliveryMethod: [, import_smithy_client.expectString, `deliveryMethod`],
+    EmailSettings: [, (_) => de_EmailSettings(_, context), `emailSettings`],
+    SmsSettings: [, (_) => de_SmsSettings(_, context), `smsSettings`]
+  });
+}, "de_CreateBackendAuthVerificationMessageConfig");
+var de_EmailSettings = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    EmailMessage: [, import_smithy_client.expectString, `emailMessage`],
+    EmailSubject: [, import_smithy_client.expectString, `emailSubject`]
+  });
+}, "de_EmailSettings");
+var de_GetBackendStorageResourceConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BucketName: [, import_smithy_client.expectString, `bucketName`],
+    Imported: [, import_smithy_client.expectBoolean, `imported`],
+    Permissions: [, (_) => de_BackendStoragePermissions(_, context), `permissions`],
+    ServiceName: [, import_smithy_client.expectString, `serviceName`]
+  });
+}, "de_GetBackendStorageResourceConfig");
+var de_ListOfBackendAPIAuthType = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_BackendAPIAuthType(entry, context);
+  });
+  return retVal;
+}, "de_ListOfBackendAPIAuthType");
+var de_ListOfBackendJobRespObj = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_BackendJobRespObj(entry, context);
+  });
+  return retVal;
+}, "de_ListOfBackendJobRespObj");
+var de_ListOfS3BucketInfo = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_S3BucketInfo(entry, context);
+  });
+  return retVal;
+}, "de_ListOfS3BucketInfo");
+var de_LoginAuthConfigReqObj = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AwsCognitoIdentityPoolId: [, import_smithy_client.expectString, `aws_cognito_identity_pool_id`],
+    AwsCognitoRegion: [, import_smithy_client.expectString, `aws_cognito_region`],
+    AwsUserPoolsId: [, import_smithy_client.expectString, `aws_user_pools_id`],
+    AwsUserPoolsWebClientId: [, import_smithy_client.expectString, `aws_user_pools_web_client_id`]
+  });
+}, "de_LoginAuthConfigReqObj");
+var de_S3BucketInfo = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreationDate: [, import_smithy_client.expectString, `creationDate`],
+    Name: [, import_smithy_client.expectString, `name`]
+  });
+}, "de_S3BucketInfo");
+var de_Settings = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MfaTypes: [, import_smithy_client._json, `mfaTypes`],
+    SmsMessage: [, import_smithy_client.expectString, `smsMessage`]
+  });
+}, "de_Settings");
+var de_SmsSettings = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    SmsMessage: [, import_smithy_client.expectString, `smsMessage`]
+  });
+}, "de_SmsSettings");
+var de_SocialProviderSettings = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Facebook: (_) => de_BackendAuthSocialProviderConfig(_, context),
+    Google: (_) => de_BackendAuthSocialProviderConfig(_, context),
+    LoginWithAmazon: (_) => de_BackendAuthSocialProviderConfig(_, context),
+    SignInWithApple: (_) => de_BackendAuthAppleProviderConfig(_, context)
+  });
+}, "de_SocialProviderSettings");
+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 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/CloneBackendCommand.ts
+var _CloneBackendCommand = class _CloneBackendCommand 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("AmplifyBackend", "CloneBackend", {}).n("AmplifyBackendClient", "CloneBackendCommand").f(void 0, void 0).ser(se_CloneBackendCommand).de(de_CloneBackendCommand).build() {
+};
+__name(_CloneBackendCommand, "CloneBackendCommand");
+var CloneBackendCommand = _CloneBackendCommand;
+
+// src/commands/CreateBackendAPICommand.ts
+
+
+
+
+var _CreateBackendAPICommand = class _CreateBackendAPICommand 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("AmplifyBackend", "CreateBackendAPI", {}).n("AmplifyBackendClient", "CreateBackendAPICommand").f(void 0, void 0).ser(se_CreateBackendAPICommand).de(de_CreateBackendAPICommand).build() {
+};
+__name(_CreateBackendAPICommand, "CreateBackendAPICommand");
+var CreateBackendAPICommand = _CreateBackendAPICommand;
+
+// src/commands/CreateBackendAuthCommand.ts
+
+
+
+
+var _CreateBackendAuthCommand = class _CreateBackendAuthCommand 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("AmplifyBackend", "CreateBackendAuth", {}).n("AmplifyBackendClient", "CreateBackendAuthCommand").f(CreateBackendAuthRequestFilterSensitiveLog, void 0).ser(se_CreateBackendAuthCommand).de(de_CreateBackendAuthCommand).build() {
+};
+__name(_CreateBackendAuthCommand, "CreateBackendAuthCommand");
+var CreateBackendAuthCommand = _CreateBackendAuthCommand;
+
+// src/commands/CreateBackendCommand.ts
+
+
+
+
+var _CreateBackendCommand = class _CreateBackendCommand 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("AmplifyBackend", "CreateBackend", {}).n("AmplifyBackendClient", "CreateBackendCommand").f(void 0, void 0).ser(se_CreateBackendCommand).de(de_CreateBackendCommand).build() {
+};
+__name(_CreateBackendCommand, "CreateBackendCommand");
+var CreateBackendCommand = _CreateBackendCommand;
+
+// src/commands/CreateBackendConfigCommand.ts
+
+
+
+
+var _CreateBackendConfigCommand = class _CreateBackendConfigCommand 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("AmplifyBackend", "CreateBackendConfig", {}).n("AmplifyBackendClient", "CreateBackendConfigCommand").f(void 0, void 0).ser(se_CreateBackendConfigCommand).de(de_CreateBackendConfigCommand).build() {
+};
+__name(_CreateBackendConfigCommand, "CreateBackendConfigCommand");
+var CreateBackendConfigCommand = _CreateBackendConfigCommand;
+
+// src/commands/CreateBackendStorageCommand.ts
+
+
+
+
+var _CreateBackendStorageCommand = class _CreateBackendStorageCommand 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("AmplifyBackend", "CreateBackendStorage", {}).n("AmplifyBackendClient", "CreateBackendStorageCommand").f(void 0, void 0).ser(se_CreateBackendStorageCommand).de(de_CreateBackendStorageCommand).build() {
+};
+__name(_CreateBackendStorageCommand, "CreateBackendStorageCommand");
+var CreateBackendStorageCommand = _CreateBackendStorageCommand;
+
+// src/commands/CreateTokenCommand.ts
+
+
+
+
+var _CreateTokenCommand = class _CreateTokenCommand 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("AmplifyBackend", "CreateToken", {}).n("AmplifyBackendClient", "CreateTokenCommand").f(void 0, void 0).ser(se_CreateTokenCommand).de(de_CreateTokenCommand).build() {
+};
+__name(_CreateTokenCommand, "CreateTokenCommand");
+var CreateTokenCommand = _CreateTokenCommand;
+
+// src/commands/DeleteBackendAPICommand.ts
+
+
+
+
+var _DeleteBackendAPICommand = class _DeleteBackendAPICommand 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("AmplifyBackend", "DeleteBackendAPI", {}).n("AmplifyBackendClient", "DeleteBackendAPICommand").f(void 0, void 0).ser(se_DeleteBackendAPICommand).de(de_DeleteBackendAPICommand).build() {
+};
+__name(_DeleteBackendAPICommand, "DeleteBackendAPICommand");
+var DeleteBackendAPICommand = _DeleteBackendAPICommand;
+
+// src/commands/DeleteBackendAuthCommand.ts
+
+
+
+
+var _DeleteBackendAuthCommand = class _DeleteBackendAuthCommand 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("AmplifyBackend", "DeleteBackendAuth", {}).n("AmplifyBackendClient", "DeleteBackendAuthCommand").f(void 0, void 0).ser(se_DeleteBackendAuthCommand).de(de_DeleteBackendAuthCommand).build() {
+};
+__name(_DeleteBackendAuthCommand, "DeleteBackendAuthCommand");
+var DeleteBackendAuthCommand = _DeleteBackendAuthCommand;
+
+// src/commands/DeleteBackendCommand.ts
+
+
+
+
+var _DeleteBackendCommand = class _DeleteBackendCommand 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("AmplifyBackend", "DeleteBackend", {}).n("AmplifyBackendClient", "DeleteBackendCommand").f(void 0, void 0).ser(se_DeleteBackendCommand).de(de_DeleteBackendCommand).build() {
+};
+__name(_DeleteBackendCommand, "DeleteBackendCommand");
+var DeleteBackendCommand = _DeleteBackendCommand;
+
+// src/commands/DeleteBackendStorageCommand.ts
+
+
+
+
+var _DeleteBackendStorageCommand = class _DeleteBackendStorageCommand 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("AmplifyBackend", "DeleteBackendStorage", {}).n("AmplifyBackendClient", "DeleteBackendStorageCommand").f(void 0, void 0).ser(se_DeleteBackendStorageCommand).de(de_DeleteBackendStorageCommand).build() {
+};
+__name(_DeleteBackendStorageCommand, "DeleteBackendStorageCommand");
+var DeleteBackendStorageCommand = _DeleteBackendStorageCommand;
+
+// src/commands/DeleteTokenCommand.ts
+
+
+
+
+var _DeleteTokenCommand = class _DeleteTokenCommand 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("AmplifyBackend", "DeleteToken", {}).n("AmplifyBackendClient", "DeleteTokenCommand").f(void 0, void 0).ser(se_DeleteTokenCommand).de(de_DeleteTokenCommand).build() {
+};
+__name(_DeleteTokenCommand, "DeleteTokenCommand");
+var DeleteTokenCommand = _DeleteTokenCommand;
+
+// src/commands/GenerateBackendAPIModelsCommand.ts
+
+
+
+
+var _GenerateBackendAPIModelsCommand = class _GenerateBackendAPIModelsCommand 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("AmplifyBackend", "GenerateBackendAPIModels", {}).n("AmplifyBackendClient", "GenerateBackendAPIModelsCommand").f(void 0, void 0).ser(se_GenerateBackendAPIModelsCommand).de(de_GenerateBackendAPIModelsCommand).build() {
+};
+__name(_GenerateBackendAPIModelsCommand, "GenerateBackendAPIModelsCommand");
+var GenerateBackendAPIModelsCommand = _GenerateBackendAPIModelsCommand;
+
+// src/commands/GetBackendAPICommand.ts
+
+
+
+
+var _GetBackendAPICommand = class _GetBackendAPICommand 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("AmplifyBackend", "GetBackendAPI", {}).n("AmplifyBackendClient", "GetBackendAPICommand").f(void 0, void 0).ser(se_GetBackendAPICommand).de(de_GetBackendAPICommand).build() {
+};
+__name(_GetBackendAPICommand, "GetBackendAPICommand");
+var GetBackendAPICommand = _GetBackendAPICommand;
+
+// src/commands/GetBackendAPIModelsCommand.ts
+
+
+
+
+var _GetBackendAPIModelsCommand = class _GetBackendAPIModelsCommand 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("AmplifyBackend", "GetBackendAPIModels", {}).n("AmplifyBackendClient", "GetBackendAPIModelsCommand").f(void 0, void 0).ser(se_GetBackendAPIModelsCommand).de(de_GetBackendAPIModelsCommand).build() {
+};
+__name(_GetBackendAPIModelsCommand, "GetBackendAPIModelsCommand");
+var GetBackendAPIModelsCommand = _GetBackendAPIModelsCommand;
+
+// src/commands/GetBackendAuthCommand.ts
+
+
+
+
+var _GetBackendAuthCommand = class _GetBackendAuthCommand 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("AmplifyBackend", "GetBackendAuth", {}).n("AmplifyBackendClient", "GetBackendAuthCommand").f(void 0, GetBackendAuthResponseFilterSensitiveLog).ser(se_GetBackendAuthCommand).de(de_GetBackendAuthCommand).build() {
+};
+__name(_GetBackendAuthCommand, "GetBackendAuthCommand");
+var GetBackendAuthCommand = _GetBackendAuthCommand;
+
+// src/commands/GetBackendCommand.ts
+
+
+
+
+var _GetBackendCommand = class _GetBackendCommand 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("AmplifyBackend", "GetBackend", {}).n("AmplifyBackendClient", "GetBackendCommand").f(void 0, void 0).ser(se_GetBackendCommand).de(de_GetBackendCommand).build() {
+};
+__name(_GetBackendCommand, "GetBackendCommand");
+var GetBackendCommand = _GetBackendCommand;
+
+// src/commands/GetBackendJobCommand.ts
+
+
+
+
+var _GetBackendJobCommand = class _GetBackendJobCommand 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("AmplifyBackend", "GetBackendJob", {}).n("AmplifyBackendClient", "GetBackendJobCommand").f(void 0, void 0).ser(se_GetBackendJobCommand).de(de_GetBackendJobCommand).build() {
+};
+__name(_GetBackendJobCommand, "GetBackendJobCommand");
+var GetBackendJobCommand = _GetBackendJobCommand;
+
+// src/commands/GetBackendStorageCommand.ts
+
+
+
+
+var _GetBackendStorageCommand = class _GetBackendStorageCommand 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("AmplifyBackend", "GetBackendStorage", {}).n("AmplifyBackendClient", "GetBackendStorageCommand").f(void 0, void 0).ser(se_GetBackendStorageCommand).de(de_GetBackendStorageCommand).build() {
+};
+__name(_GetBackendStorageCommand, "GetBackendStorageCommand");
+var GetBackendStorageCommand = _GetBackendStorageCommand;
+
+// src/commands/GetTokenCommand.ts
+
+
+
+
+var _GetTokenCommand = class _GetTokenCommand 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("AmplifyBackend", "GetToken", {}).n("AmplifyBackendClient", "GetTokenCommand").f(void 0, void 0).ser(se_GetTokenCommand).de(de_GetTokenCommand).build() {
+};
+__name(_GetTokenCommand, "GetTokenCommand");
+var GetTokenCommand = _GetTokenCommand;
+
+// src/commands/ImportBackendAuthCommand.ts
+
+
+
+
+var _ImportBackendAuthCommand = class _ImportBackendAuthCommand 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("AmplifyBackend", "ImportBackendAuth", {}).n("AmplifyBackendClient", "ImportBackendAuthCommand").f(void 0, void 0).ser(se_ImportBackendAuthCommand).de(de_ImportBackendAuthCommand).build() {
+};
+__name(_ImportBackendAuthCommand, "ImportBackendAuthCommand");
+var ImportBackendAuthCommand = _ImportBackendAuthCommand;
+
+// src/commands/ImportBackendStorageCommand.ts
+
+
+
+
+var _ImportBackendStorageCommand = class _ImportBackendStorageCommand 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("AmplifyBackend", "ImportBackendStorage", {}).n("AmplifyBackendClient", "ImportBackendStorageCommand").f(void 0, void 0).ser(se_ImportBackendStorageCommand).de(de_ImportBackendStorageCommand).build() {
+};
+__name(_ImportBackendStorageCommand, "ImportBackendStorageCommand");
+var ImportBackendStorageCommand = _ImportBackendStorageCommand;
+
+// src/commands/ListBackendJobsCommand.ts
+
+
+
+
+var _ListBackendJobsCommand = class _ListBackendJobsCommand 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("AmplifyBackend", "ListBackendJobs", {}).n("AmplifyBackendClient", "ListBackendJobsCommand").f(void 0, void 0).ser(se_ListBackendJobsCommand).de(de_ListBackendJobsCommand).build() {
+};
+__name(_ListBackendJobsCommand, "ListBackendJobsCommand");
+var ListBackendJobsCommand = _ListBackendJobsCommand;
+
+// src/commands/ListS3BucketsCommand.ts
+
+
+
+
+var _ListS3BucketsCommand = class _ListS3BucketsCommand 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("AmplifyBackend", "ListS3Buckets", {}).n("AmplifyBackendClient", "ListS3BucketsCommand").f(void 0, void 0).ser(se_ListS3BucketsCommand).de(de_ListS3BucketsCommand).build() {
+};
+__name(_ListS3BucketsCommand, "ListS3BucketsCommand");
+var ListS3BucketsCommand = _ListS3BucketsCommand;
+
+// src/commands/RemoveAllBackendsCommand.ts
+
+
+
+
+var _RemoveAllBackendsCommand = class _RemoveAllBackendsCommand 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("AmplifyBackend", "RemoveAllBackends", {}).n("AmplifyBackendClient", "RemoveAllBackendsCommand").f(void 0, void 0).ser(se_RemoveAllBackendsCommand).de(de_RemoveAllBackendsCommand).build() {
+};
+__name(_RemoveAllBackendsCommand, "RemoveAllBackendsCommand");
+var RemoveAllBackendsCommand = _RemoveAllBackendsCommand;
+
+// src/commands/RemoveBackendConfigCommand.ts
+
+
+
+
+var _RemoveBackendConfigCommand = class _RemoveBackendConfigCommand 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("AmplifyBackend", "RemoveBackendConfig", {}).n("AmplifyBackendClient", "RemoveBackendConfigCommand").f(void 0, void 0).ser(se_RemoveBackendConfigCommand).de(de_RemoveBackendConfigCommand).build() {
+};
+__name(_RemoveBackendConfigCommand, "RemoveBackendConfigCommand");
+var RemoveBackendConfigCommand = _RemoveBackendConfigCommand;
+
+// src/commands/UpdateBackendAPICommand.ts
+
+
+
+
+var _UpdateBackendAPICommand = class _UpdateBackendAPICommand 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("AmplifyBackend", "UpdateBackendAPI", {}).n("AmplifyBackendClient", "UpdateBackendAPICommand").f(void 0, void 0).ser(se_UpdateBackendAPICommand).de(de_UpdateBackendAPICommand).build() {
+};
+__name(_UpdateBackendAPICommand, "UpdateBackendAPICommand");
+var UpdateBackendAPICommand = _UpdateBackendAPICommand;
+
+// src/commands/UpdateBackendAuthCommand.ts
+
+
+
+
+var _UpdateBackendAuthCommand = class _UpdateBackendAuthCommand 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("AmplifyBackend", "UpdateBackendAuth", {}).n("AmplifyBackendClient", "UpdateBackendAuthCommand").f(UpdateBackendAuthRequestFilterSensitiveLog, void 0).ser(se_UpdateBackendAuthCommand).de(de_UpdateBackendAuthCommand).build() {
+};
+__name(_UpdateBackendAuthCommand, "UpdateBackendAuthCommand");
+var UpdateBackendAuthCommand = _UpdateBackendAuthCommand;
+
+// src/commands/UpdateBackendConfigCommand.ts
+
+
+
+
+var _UpdateBackendConfigCommand = class _UpdateBackendConfigCommand 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("AmplifyBackend", "UpdateBackendConfig", {}).n("AmplifyBackendClient", "UpdateBackendConfigCommand").f(void 0, void 0).ser(se_UpdateBackendConfigCommand).de(de_UpdateBackendConfigCommand).build() {
+};
+__name(_UpdateBackendConfigCommand, "UpdateBackendConfigCommand");
+var UpdateBackendConfigCommand = _UpdateBackendConfigCommand;
+
+// src/commands/UpdateBackendJobCommand.ts
+
+
+
+
+var _UpdateBackendJobCommand = class _UpdateBackendJobCommand 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("AmplifyBackend", "UpdateBackendJob", {}).n("AmplifyBackendClient", "UpdateBackendJobCommand").f(void 0, void 0).ser(se_UpdateBackendJobCommand).de(de_UpdateBackendJobCommand).build() {
+};
+__name(_UpdateBackendJobCommand, "UpdateBackendJobCommand");
+var UpdateBackendJobCommand = _UpdateBackendJobCommand;
+
+// src/commands/UpdateBackendStorageCommand.ts
+
+
+
+
+var _UpdateBackendStorageCommand = class _UpdateBackendStorageCommand 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("AmplifyBackend", "UpdateBackendStorage", {}).n("AmplifyBackendClient", "UpdateBackendStorageCommand").f(void 0, void 0).ser(se_UpdateBackendStorageCommand).de(de_UpdateBackendStorageCommand).build() {
+};
+__name(_UpdateBackendStorageCommand, "UpdateBackendStorageCommand");
+var UpdateBackendStorageCommand = _UpdateBackendStorageCommand;
+
+// src/AmplifyBackend.ts
+var commands = {
+  CloneBackendCommand,
+  CreateBackendCommand,
+  CreateBackendAPICommand,
+  CreateBackendAuthCommand,
+  CreateBackendConfigCommand,
+  CreateBackendStorageCommand,
+  CreateTokenCommand,
+  DeleteBackendCommand,
+  DeleteBackendAPICommand,
+  DeleteBackendAuthCommand,
+  DeleteBackendStorageCommand,
+  DeleteTokenCommand,
+  GenerateBackendAPIModelsCommand,
+  GetBackendCommand,
+  GetBackendAPICommand,
+  GetBackendAPIModelsCommand,
+  GetBackendAuthCommand,
+  GetBackendJobCommand,
+  GetBackendStorageCommand,
+  GetTokenCommand,
+  ImportBackendAuthCommand,
+  ImportBackendStorageCommand,
+  ListBackendJobsCommand,
+  ListS3BucketsCommand,
+  RemoveAllBackendsCommand,
+  RemoveBackendConfigCommand,
+  UpdateBackendAPICommand,
+  UpdateBackendAuthCommand,
+  UpdateBackendConfigCommand,
+  UpdateBackendJobCommand,
+  UpdateBackendStorageCommand
+};
+var _AmplifyBackend = class _AmplifyBackend extends AmplifyBackendClient {
+};
+__name(_AmplifyBackend, "AmplifyBackend");
+var AmplifyBackend = _AmplifyBackend;
+(0, import_smithy_client.createAggregatedClient)(commands, AmplifyBackend);
+
+// 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 = {
+  AdditionalConstraintsElement,
+  AmplifyBackend,
+  AmplifyBackendClient,
+  AmplifyBackendServiceException,
+  AuthResources,
+  AuthenticatedElement,
+  BackendAuthAppleProviderConfigFilterSensitiveLog,
+  BackendAuthSocialProviderConfigFilterSensitiveLog,
+  BadRequestException,
+  CloneBackendCommand,
+  CreateBackendAPICommand,
+  CreateBackendAuthCommand,
+  CreateBackendAuthForgotPasswordConfigFilterSensitiveLog,
+  CreateBackendAuthOAuthConfigFilterSensitiveLog,
+  CreateBackendAuthRequestFilterSensitiveLog,
+  CreateBackendAuthResourceConfigFilterSensitiveLog,
+  CreateBackendAuthUserPoolConfigFilterSensitiveLog,
+  CreateBackendAuthVerificationMessageConfigFilterSensitiveLog,
+  CreateBackendCommand,
+  CreateBackendConfigCommand,
+  CreateBackendStorageCommand,
+  CreateTokenCommand,
+  DeleteBackendAPICommand,
+  DeleteBackendAuthCommand,
+  DeleteBackendCommand,
+  DeleteBackendStorageCommand,
+  DeleteTokenCommand,
+  DeliveryMethod,
+  EmailSettingsFilterSensitiveLog,
+  GatewayTimeoutException,
+  GenerateBackendAPIModelsCommand,
+  GetBackendAPICommand,
+  GetBackendAPIModelsCommand,
+  GetBackendAuthCommand,
+  GetBackendAuthResponseFilterSensitiveLog,
+  GetBackendCommand,
+  GetBackendJobCommand,
+  GetBackendStorageCommand,
+  GetTokenCommand,
+  ImportBackendAuthCommand,
+  ImportBackendStorageCommand,
+  ListBackendJobsCommand,
+  ListS3BucketsCommand,
+  MFAMode,
+  MfaTypesElement,
+  Mode,
+  NotFoundException,
+  OAuthGrantType,
+  OAuthScopesElement,
+  RemoveAllBackendsCommand,
+  RemoveBackendConfigCommand,
+  RequiredSignUpAttributesElement,
+  ResolutionStrategy,
+  Service,
+  ServiceName,
+  SignInMethod,
+  SmsSettingsFilterSensitiveLog,
+  SocialProviderSettingsFilterSensitiveLog,
+  Status,
+  TooManyRequestsException,
+  UnAuthenticatedElement,
+  UpdateBackendAPICommand,
+  UpdateBackendAuthCommand,
+  UpdateBackendAuthForgotPasswordConfigFilterSensitiveLog,
+  UpdateBackendAuthOAuthConfigFilterSensitiveLog,
+  UpdateBackendAuthRequestFilterSensitiveLog,
+  UpdateBackendAuthResourceConfigFilterSensitiveLog,
+  UpdateBackendAuthUserPoolConfigFilterSensitiveLog,
+  UpdateBackendAuthVerificationMessageConfigFilterSensitiveLog,
+  UpdateBackendConfigCommand,
+  UpdateBackendJobCommand,
+  UpdateBackendStorageCommand,
+  __Client
+});
+