@cdklabs/cdk-ecs-codedeploy 0.0.421 → 0.0.422

package/node_modules/@smithy/core/dist-cjs/submodules/schema/index.js

@@ -1,848 +1,626 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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);
+'use strict';
 
-// src/submodules/schema/index.ts
-var schema_exports = {};
-__export(schema_exports, {
-  ErrorSchema: () => ErrorSchema,
-  ListSchema: () => ListSchema,
-  MapSchema: () => MapSchema,
-  NormalizedSchema: () => NormalizedSchema,
-  OperationSchema: () => OperationSchema,
-  SCHEMA: () => SCHEMA,
-  Schema: () => Schema,
-  SimpleSchema: () => SimpleSchema,
-  StructureSchema: () => StructureSchema,
-  TypeRegistry: () => TypeRegistry,
-  deref: () => deref,
-  deserializerMiddlewareOption: () => deserializerMiddlewareOption,
-  error: () => error,
-  getSchemaSerdePlugin: () => getSchemaSerdePlugin,
-  list: () => list,
-  map: () => map,
-  op: () => op,
-  serializerMiddlewareOption: () => serializerMiddlewareOption,
-  sim: () => sim,
-  struct: () => struct
-});
-module.exports = __toCommonJS(schema_exports);
+var protocolHttp = require('@smithy/protocol-http');
+var utilMiddleware = require('@smithy/util-middleware');
 
-// src/submodules/schema/deref.ts
-var deref = (schemaRef) => {
-  if (typeof schemaRef === "function") {
-    return schemaRef();
-  }
-  return schemaRef;
+const deref = (schemaRef) => {
+    if (typeof schemaRef === "function") {
+        return schemaRef();
+    }
+    return schemaRef;
 };
 
-// src/submodules/schema/middleware/schemaDeserializationMiddleware.ts
-var import_protocol_http = require("@smithy/protocol-http");
-var import_util_middleware = require("@smithy/util-middleware");
-var schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
-  const { response } = await next(args);
-  const { operationSchema } = (0, import_util_middleware.getSmithyContext)(context);
-  try {
-    const parsed = await config.protocol.deserializeResponse(
-      operationSchema,
-      {
-        ...config,
-        ...context
-      },
-      response
-    );
-    return {
-      response,
-      output: parsed
-    };
-  } catch (error2) {
-    Object.defineProperty(error2, "$response", {
-      value: response
-    });
-    if (!("$metadata" in error2)) {
-      const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
-      try {
-        error2.message += "\n  " + hint;
-      } catch (e) {
-        if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
-          console.warn(hint);
-        } else {
-          context.logger?.warn?.(hint);
-        }
-      }
-      if (typeof error2.$responseBodyText !== "undefined") {
-        if (error2.$response) {
-          error2.$response.body = error2.$responseBodyText;
-        }
-      }
-      try {
-        if (import_protocol_http.HttpResponse.isInstance(response)) {
-          const { headers = {} } = response;
-          const headerEntries = Object.entries(headers);
-          error2.$metadata = {
-            httpStatusCode: response.statusCode,
-            requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
-            extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
-            cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
-          };
+const operation = (namespace, name, traits, input, output) => ({
+    name,
+    namespace,
+    traits,
+    input,
+    output,
+});
+
+const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
+    const { response } = await next(args);
+    const { operationSchema } = utilMiddleware.getSmithyContext(context);
+    const [, ns, n, t, i, o] = operationSchema ?? [];
+    try {
+        const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
+            ...config,
+            ...context,
+        }, response);
+        return {
+            response,
+            output: parsed,
+        };
+    }
+    catch (error) {
+        Object.defineProperty(error, "$response", {
+            value: response,
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        });
+        if (!("$metadata" in error)) {
+            const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
+            try {
+                error.message += "\n  " + hint;
+            }
+            catch (e) {
+                if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
+                    console.warn(hint);
+                }
+                else {
+                    context.logger?.warn?.(hint);
+                }
+            }
+            if (typeof error.$responseBodyText !== "undefined") {
+                if (error.$response) {
+                    error.$response.body = error.$responseBodyText;
+                }
+            }
+            try {
+                if (protocolHttp.HttpResponse.isInstance(response)) {
+                    const { headers = {} } = response;
+                    const headerEntries = Object.entries(headers);
+                    error.$metadata = {
+                        httpStatusCode: response.statusCode,
+                        requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
+                        extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
+                        cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries),
+                    };
+                }
+            }
+            catch (e) {
+            }
         }
-      } catch (e) {
-      }
+        throw error;
     }
-    throw error2;
-  }
 };
-var findHeader = (pattern, headers) => {
-  return (headers.find(([k]) => {
-    return k.match(pattern);
-  }) || [void 0, void 0])[1];
+const findHeader = (pattern, headers) => {
+    return (headers.find(([k]) => {
+        return k.match(pattern);
+    }) || [void 0, void 0])[1];
 };
 
-// src/submodules/schema/middleware/schemaSerializationMiddleware.ts
-var import_util_middleware2 = require("@smithy/util-middleware");
-var schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
-  const { operationSchema } = (0, import_util_middleware2.getSmithyContext)(context);
-  const endpoint = context.endpointV2?.url && config.urlParser ? async () => config.urlParser(context.endpointV2.url) : config.endpoint;
-  const request = await config.protocol.serializeRequest(operationSchema, args.input, {
-    ...config,
-    ...context,
-    endpoint
-  });
-  return next({
-    ...args,
-    request
-  });
+const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
+    const { operationSchema } = utilMiddleware.getSmithyContext(context);
+    const [, ns, n, t, i, o] = operationSchema ?? [];
+    const endpoint = context.endpointV2?.url && config.urlParser
+        ? async () => config.urlParser(context.endpointV2.url)
+        : config.endpoint;
+    const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
+        ...config,
+        ...context,
+        endpoint,
+    });
+    return next({
+        ...args,
+        request,
+    });
 };
 
-// src/submodules/schema/middleware/getSchemaSerdePlugin.ts
-var deserializerMiddlewareOption = {
-  name: "deserializerMiddleware",
-  step: "deserialize",
-  tags: ["DESERIALIZER"],
-  override: true
+const deserializerMiddlewareOption = {
+    name: "deserializerMiddleware",
+    step: "deserialize",
+    tags: ["DESERIALIZER"],
+    override: true,
 };
-var serializerMiddlewareOption = {
-  name: "serializerMiddleware",
-  step: "serialize",
-  tags: ["SERIALIZER"],
-  override: true
+const serializerMiddlewareOption = {
+    name: "serializerMiddleware",
+    step: "serialize",
+    tags: ["SERIALIZER"],
+    override: true,
 };
 function getSchemaSerdePlugin(config) {
-  return {
-    applyToStack: (commandStack) => {
-      commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
-      commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
-      config.protocol.setSerdeContext(config);
-    }
-  };
+    return {
+        applyToStack: (commandStack) => {
+            commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
+            commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
+            config.protocol.setSerdeContext(config);
+        },
+    };
 }
 
-// src/submodules/schema/TypeRegistry.ts
-var TypeRegistry = class _TypeRegistry {
-  constructor(namespace, schemas = /* @__PURE__ */ new Map()) {
-    this.namespace = namespace;
-    this.schemas = schemas;
-  }
-  static {
-    this.registries = /* @__PURE__ */ new Map();
-  }
-  /**
-   * @param namespace - specifier.
-   * @returns the schema for that namespace, creating it if necessary.
-   */
-  static for(namespace) {
-    if (!_TypeRegistry.registries.has(namespace)) {
-      _TypeRegistry.registries.set(namespace, new _TypeRegistry(namespace));
-    }
-    return _TypeRegistry.registries.get(namespace);
-  }
-  /**
-   * Adds the given schema to a type registry with the same namespace.
-   *
-   * @param shapeId - to be registered.
-   * @param schema - to be registered.
-   */
-  register(shapeId, schema) {
-    const qualifiedName = this.normalizeShapeId(shapeId);
-    const registry = _TypeRegistry.for(this.getNamespace(shapeId));
-    registry.schemas.set(qualifiedName, schema);
-  }
-  /**
-   * @param shapeId - query.
-   * @returns the schema.
-   */
-  getSchema(shapeId) {
-    const id = this.normalizeShapeId(shapeId);
-    if (!this.schemas.has(id)) {
-      throw new Error(`@smithy/core/schema - schema not found for ${id}`);
-    }
-    return this.schemas.get(id);
-  }
-  /**
-   * The smithy-typescript code generator generates a synthetic (i.e. unmodeled) base exception,
-   * because generated SDKs before the introduction of schemas have the notion of a ServiceBaseException, which
-   * is unique per service/model.
-   *
-   * This is generated under a unique prefix that is combined with the service namespace, and this
-   * method is used to retrieve it.
-   *
-   * The base exception synthetic schema is used when an error is returned by a service, but we cannot
-   * determine what existing schema to use to deserialize it.
-   *
-   * @returns the synthetic base exception of the service namespace associated with this registry instance.
-   */
-  getBaseException() {
-    for (const [id, schema] of this.schemas.entries()) {
-      if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
+class Schema {
+    name;
+    namespace;
+    traits;
+    static assign(instance, values) {
+        const schema = Object.assign(instance, values);
         return schema;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * @param predicate - criterion.
-   * @returns a schema in this registry matching the predicate.
-   */
-  find(predicate) {
-    return [...this.schemas.values()].find(predicate);
-  }
-  /**
-   * Unloads the current TypeRegistry.
-   */
-  destroy() {
-    _TypeRegistry.registries.delete(this.namespace);
-    this.schemas.clear();
-  }
-  normalizeShapeId(shapeId) {
-    if (shapeId.includes("#")) {
-      return shapeId;
-    }
-    return this.namespace + "#" + shapeId;
-  }
-  getNamespace(shapeId) {
-    return this.normalizeShapeId(shapeId).split("#")[0];
-  }
-};
-
-// src/submodules/schema/schemas/Schema.ts
-var Schema = class {
-  constructor(name, traits) {
-    this.name = name;
-    this.traits = traits;
-  }
-};
-
-// src/submodules/schema/schemas/ListSchema.ts
-var ListSchema = class _ListSchema extends Schema {
-  constructor(name, traits, valueSchema) {
-    super(name, traits);
-    this.name = name;
-    this.traits = traits;
-    this.valueSchema = valueSchema;
-    this.symbol = _ListSchema.symbol;
-  }
-  static {
-    this.symbol = Symbol.for("@smithy/core/schema::ListSchema");
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _ListSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const list2 = lhs;
-      return list2.symbol === _ListSchema.symbol;
-    }
-    return isPrototype;
-  }
-};
-function list(namespace, name, traits = {}, valueSchema) {
-  const schema = new ListSchema(
-    namespace + "#" + name,
-    traits,
-    typeof valueSchema === "function" ? valueSchema() : valueSchema
-  );
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
+    }
+    static [Symbol.hasInstance](lhs) {
+        const isPrototype = this.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const list = lhs;
+            return list.symbol === this.symbol;
+        }
+        return isPrototype;
+    }
+    getName() {
+        return this.namespace + "#" + this.name;
+    }
 }
 
-// src/submodules/schema/schemas/MapSchema.ts
-var MapSchema = class _MapSchema extends Schema {
-  constructor(name, traits, keySchema, valueSchema) {
-    super(name, traits);
-    this.name = name;
-    this.traits = traits;
-    this.keySchema = keySchema;
-    this.valueSchema = valueSchema;
-    this.symbol = _MapSchema.symbol;
-  }
-  static {
-    this.symbol = Symbol.for("@smithy/core/schema::MapSchema");
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _MapSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const map2 = lhs;
-      return map2.symbol === _MapSchema.symbol;
-    }
-    return isPrototype;
-  }
-};
-function map(namespace, name, traits = {}, keySchema, valueSchema) {
-  const schema = new MapSchema(
-    namespace + "#" + name,
-    traits,
-    keySchema,
-    typeof valueSchema === "function" ? valueSchema() : valueSchema
-  );
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
+class ListSchema extends Schema {
+    static symbol = Symbol.for("@smithy/lis");
+    name;
+    traits;
+    valueSchema;
+    symbol = ListSchema.symbol;
 }
+const list = (namespace, name, traits, valueSchema) => Schema.assign(new ListSchema(), {
+    name,
+    namespace,
+    traits,
+    valueSchema,
+});
 
-// src/submodules/schema/schemas/OperationSchema.ts
-var OperationSchema = class extends Schema {
-  constructor(name, traits, input, output) {
-    super(name, traits);
-    this.name = name;
-    this.traits = traits;
-    this.input = input;
-    this.output = output;
-  }
-};
-function op(namespace, name, traits = {}, input, output) {
-  const schema = new OperationSchema(namespace + "#" + name, traits, input, output);
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
+class MapSchema extends Schema {
+    static symbol = Symbol.for("@smithy/map");
+    name;
+    traits;
+    keySchema;
+    valueSchema;
+    symbol = MapSchema.symbol;
 }
+const map = (namespace, name, traits, keySchema, valueSchema) => Schema.assign(new MapSchema(), {
+    name,
+    namespace,
+    traits,
+    keySchema,
+    valueSchema,
+});
 
-// src/submodules/schema/schemas/StructureSchema.ts
-var StructureSchema = class _StructureSchema extends Schema {
-  constructor(name, traits, memberNames, memberList) {
-    super(name, traits);
-    this.name = name;
-    this.traits = traits;
-    this.memberNames = memberNames;
-    this.memberList = memberList;
-    this.symbol = _StructureSchema.symbol;
-    this.members = {};
-    for (let i = 0; i < memberNames.length; ++i) {
-      this.members[memberNames[i]] = Array.isArray(memberList[i]) ? memberList[i] : [memberList[i], 0];
-    }
-  }
-  static {
-    this.symbol = Symbol.for("@smithy/core/schema::StructureSchema");
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _StructureSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const struct2 = lhs;
-      return struct2.symbol === _StructureSchema.symbol;
-    }
-    return isPrototype;
-  }
-};
-function struct(namespace, name, traits, memberNames, memberList) {
-  const schema = new StructureSchema(namespace + "#" + name, traits, memberNames, memberList);
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
+class OperationSchema extends Schema {
+    static symbol = Symbol.for("@smithy/ope");
+    name;
+    traits;
+    input;
+    output;
+    symbol = OperationSchema.symbol;
 }
+const op = (namespace, name, traits, input, output) => Schema.assign(new OperationSchema(), {
+    name,
+    namespace,
+    traits,
+    input,
+    output,
+});
 
-// src/submodules/schema/schemas/ErrorSchema.ts
-var ErrorSchema = class _ErrorSchema extends StructureSchema {
-  constructor(name, traits, memberNames, memberList, ctor) {
-    super(name, traits, memberNames, memberList);
-    this.name = name;
-    this.traits = traits;
-    this.memberNames = memberNames;
-    this.memberList = memberList;
-    this.ctor = ctor;
-    this.symbol = _ErrorSchema.symbol;
-  }
-  static {
-    this.symbol = Symbol.for("@smithy/core/schema::ErrorSchema");
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _ErrorSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const err = lhs;
-      return err.symbol === _ErrorSchema.symbol;
-    }
-    return isPrototype;
-  }
-};
-function error(namespace, name, traits = {}, memberNames, memberList, ctor) {
-  const schema = new ErrorSchema(namespace + "#" + name, traits, memberNames, memberList, ctor);
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
+class StructureSchema extends Schema {
+    static symbol = Symbol.for("@smithy/str");
+    name;
+    traits;
+    memberNames;
+    memberList;
+    symbol = StructureSchema.symbol;
 }
+const struct = (namespace, name, traits, memberNames, memberList) => Schema.assign(new StructureSchema(), {
+    name,
+    namespace,
+    traits,
+    memberNames,
+    memberList,
+});
 
-// src/submodules/schema/schemas/sentinels.ts
-var SCHEMA = {
-  BLOB: 21,
-  // 21
-  STREAMING_BLOB: 42,
-  // 42
-  BOOLEAN: 2,
-  // 2
-  STRING: 0,
-  // 0
-  NUMERIC: 1,
-  // 1
-  BIG_INTEGER: 17,
-  // 17
-  BIG_DECIMAL: 19,
-  // 19
-  DOCUMENT: 15,
-  // 15
-  TIMESTAMP_DEFAULT: 4,
-  // 4
-  TIMESTAMP_DATE_TIME: 5,
-  // 5
-  TIMESTAMP_HTTP_DATE: 6,
-  // 6
-  TIMESTAMP_EPOCH_SECONDS: 7,
-  // 7
-  LIST_MODIFIER: 64,
-  // 64
-  MAP_MODIFIER: 128
-  // 128
-};
-
-// src/submodules/schema/schemas/SimpleSchema.ts
-var SimpleSchema = class _SimpleSchema extends Schema {
-  constructor(name, schemaRef, traits) {
-    super(name, traits);
-    this.name = name;
-    this.schemaRef = schemaRef;
-    this.traits = traits;
-    this.symbol = _SimpleSchema.symbol;
-  }
-  static {
-    this.symbol = Symbol.for("@smithy/core/schema::SimpleSchema");
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _SimpleSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const sim2 = lhs;
-      return sim2.symbol === _SimpleSchema.symbol;
-    }
-    return isPrototype;
-  }
-};
-function sim(namespace, name, schemaRef, traits) {
-  const schema = new SimpleSchema(namespace + "#" + name, schemaRef, traits);
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
+class ErrorSchema extends StructureSchema {
+    static symbol = Symbol.for("@smithy/err");
+    ctor;
+    symbol = ErrorSchema.symbol;
 }
+const error = (namespace, name, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), {
+    name,
+    namespace,
+    traits,
+    memberNames,
+    memberList,
+    ctor: null,
+});
 
-// src/submodules/schema/schemas/NormalizedSchema.ts
-var NormalizedSchema = class _NormalizedSchema {
-  /**
-   * @param ref - a polymorphic SchemaRef to be dereferenced/normalized.
-   * @param memberName - optional memberName if this NormalizedSchema should be considered a member schema.
-   */
-  constructor(ref, memberName) {
-    this.ref = ref;
-    this.memberName = memberName;
-    this.symbol = _NormalizedSchema.symbol;
-    const traitStack = [];
-    let _ref = ref;
-    let schema = ref;
-    this._isMemberSchema = false;
-    while (Array.isArray(_ref)) {
-      traitStack.push(_ref[1]);
-      _ref = _ref[0];
-      schema = deref(_ref);
-      this._isMemberSchema = true;
-    }
-    if (traitStack.length > 0) {
-      this.memberTraits = {};
-      for (let i = traitStack.length - 1; i >= 0; --i) {
-        const traitSet = traitStack[i];
-        Object.assign(this.memberTraits, _NormalizedSchema.translateTraits(traitSet));
-      }
-    } else {
-      this.memberTraits = 0;
-    }
-    if (schema instanceof _NormalizedSchema) {
-      this.name = schema.name;
-      this.traits = schema.traits;
-      this._isMemberSchema = schema._isMemberSchema;
-      this.schema = schema.schema;
-      this.memberTraits = Object.assign({}, schema.getMemberTraits(), this.getMemberTraits());
-      this.normalizedTraits = void 0;
-      this.ref = schema.ref;
-      this.memberName = memberName ?? schema.memberName;
-      return;
-    }
-    this.schema = deref(schema);
-    if (this.schema && typeof this.schema === "object") {
-      this.traits = this.schema?.traits ?? {};
-    } else {
-      this.traits = 0;
-    }
-    this.name = (typeof this.schema === "object" ? this.schema?.name : void 0) ?? this.memberName ?? this.getSchemaName();
-    if (this._isMemberSchema && !memberName) {
-      throw new Error(
-        `@smithy/core/schema - NormalizedSchema member schema ${this.getName(
-          true
-        )} must initialize with memberName argument.`
-      );
-    }
-  }
-  static {
-    this.symbol = Symbol.for("@smithy/core/schema::NormalizedSchema");
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _NormalizedSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const ns = lhs;
-      return ns.symbol === _NormalizedSchema.symbol;
-    }
-    return isPrototype;
-  }
-  /**
-   * Static constructor that attempts to avoid wrapping a NormalizedSchema within another.
-   */
-  static of(ref, memberName) {
-    if (ref instanceof _NormalizedSchema) {
-      return ref;
-    }
-    return new _NormalizedSchema(ref, memberName);
-  }
-  /**
-   * @param indicator - numeric indicator for preset trait combination.
-   * @returns equivalent trait object.
-   */
-  static translateTraits(indicator) {
+function translateTraits(indicator) {
     if (typeof indicator === "object") {
-      return indicator;
+        return indicator;
     }
     indicator = indicator | 0;
     const traits = {};
-    if ((indicator & 1) === 1) {
-      traits.httpLabel = 1;
+    let i = 0;
+    for (const trait of [
+        "httpLabel",
+        "idempotent",
+        "idempotencyToken",
+        "sensitive",
+        "httpPayload",
+        "httpResponseCode",
+        "httpQueryParams",
+    ]) {
+        if (((indicator >> i++) & 1) === 1) {
+            traits[trait] = 1;
+        }
     }
-    if ((indicator >> 1 & 1) === 1) {
-      traits.idempotent = 1;
+    return traits;
+}
+
+class NormalizedSchema {
+    ref;
+    memberName;
+    static symbol = Symbol.for("@smithy/nor");
+    symbol = NormalizedSchema.symbol;
+    name;
+    schema;
+    _isMemberSchema;
+    traits;
+    memberTraits;
+    normalizedTraits;
+    constructor(ref, memberName) {
+        this.ref = ref;
+        this.memberName = memberName;
+        const traitStack = [];
+        let _ref = ref;
+        let schema = ref;
+        this._isMemberSchema = false;
+        while (isMemberSchema(_ref)) {
+            traitStack.push(_ref[1]);
+            _ref = _ref[0];
+            schema = deref(_ref);
+            this._isMemberSchema = true;
+        }
+        if (traitStack.length > 0) {
+            this.memberTraits = {};
+            for (let i = traitStack.length - 1; i >= 0; --i) {
+                const traitSet = traitStack[i];
+                Object.assign(this.memberTraits, translateTraits(traitSet));
+            }
+        }
+        else {
+            this.memberTraits = 0;
+        }
+        if (schema instanceof NormalizedSchema) {
+            const computedMemberTraits = this.memberTraits;
+            Object.assign(this, schema);
+            this.memberTraits = Object.assign({}, computedMemberTraits, schema.getMemberTraits(), this.getMemberTraits());
+            this.normalizedTraits = void 0;
+            this.memberName = memberName ?? schema.memberName;
+            return;
+        }
+        this.schema = deref(schema);
+        if (isStaticSchema(this.schema)) {
+            this.name = `${this.schema[1]}#${this.schema[2]}`;
+            this.traits = this.schema[3];
+        }
+        else {
+            this.name = this.memberName ?? String(schema);
+            this.traits = 0;
+        }
+        if (this._isMemberSchema && !memberName) {
+            throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
+        }
     }
-    if ((indicator >> 2 & 1) === 1) {
-      traits.idempotencyToken = 1;
+    static [Symbol.hasInstance](lhs) {
+        const isPrototype = this.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const ns = lhs;
+            return ns.symbol === this.symbol;
+        }
+        return isPrototype;
     }
-    if ((indicator >> 3 & 1) === 1) {
-      traits.sensitive = 1;
+    static of(ref) {
+        const sc = deref(ref);
+        if (sc instanceof NormalizedSchema) {
+            return sc;
+        }
+        if (isMemberSchema(sc)) {
+            const [ns, traits] = sc;
+            if (ns instanceof NormalizedSchema) {
+                Object.assign(ns.getMergedTraits(), translateTraits(traits));
+                return ns;
+            }
+            throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`);
+        }
+        return new NormalizedSchema(sc);
     }
-    if ((indicator >> 4 & 1) === 1) {
-      traits.httpPayload = 1;
+    getSchema() {
+        const sc = this.schema;
+        if (sc[0] === 0) {
+            return sc[4];
+        }
+        return sc;
+    }
+    getName(withNamespace = false) {
+        const { name } = this;
+        const short = !withNamespace && name && name.includes("#");
+        return short ? name.split("#")[1] : name || undefined;
+    }
+    getMemberName() {
+        return this.memberName;
+    }
+    isMemberSchema() {
+        return this._isMemberSchema;
+    }
+    isListSchema() {
+        const sc = this.getSchema();
+        return typeof sc === "number"
+            ? sc >= 64 && sc < 128
+            : sc[0] === 1;
+    }
+    isMapSchema() {
+        const sc = this.getSchema();
+        return typeof sc === "number"
+            ? sc >= 128 && sc <= 0b1111_1111
+            : sc[0] === 2;
+    }
+    isStructSchema() {
+        const sc = this.getSchema();
+        const id = sc[0];
+        return (id === 3 ||
+            id === -3 ||
+            id === 4);
+    }
+    isUnionSchema() {
+        const sc = this.getSchema();
+        return sc[0] === 4;
+    }
+    isBlobSchema() {
+        const sc = this.getSchema();
+        return sc === 21 || sc === 42;
+    }
+    isTimestampSchema() {
+        const sc = this.getSchema();
+        return (typeof sc === "number" &&
+            sc >= 4 &&
+            sc <= 7);
+    }
+    isUnitSchema() {
+        return this.getSchema() === "unit";
+    }
+    isDocumentSchema() {
+        return this.getSchema() === 15;
+    }
+    isStringSchema() {
+        return this.getSchema() === 0;
+    }
+    isBooleanSchema() {
+        return this.getSchema() === 2;
+    }
+    isNumericSchema() {
+        return this.getSchema() === 1;
+    }
+    isBigIntegerSchema() {
+        return this.getSchema() === 17;
+    }
+    isBigDecimalSchema() {
+        return this.getSchema() === 19;
+    }
+    isStreaming() {
+        const { streaming } = this.getMergedTraits();
+        return !!streaming || this.getSchema() === 42;
+    }
+    isIdempotencyToken() {
+        const match = (traits) => (traits & 0b0100) === 0b0100 ||
+            !!traits?.idempotencyToken;
+        const { normalizedTraits, traits, memberTraits } = this;
+        return match(normalizedTraits) || match(traits) || match(memberTraits);
+    }
+    getMergedTraits() {
+        return (this.normalizedTraits ??
+            (this.normalizedTraits = {
+                ...this.getOwnTraits(),
+                ...this.getMemberTraits(),
+            }));
+    }
+    getMemberTraits() {
+        return translateTraits(this.memberTraits);
+    }
+    getOwnTraits() {
+        return translateTraits(this.traits);
+    }
+    getKeySchema() {
+        const [isDoc, isMap] = [this.isDocumentSchema(), this.isMapSchema()];
+        if (!isDoc && !isMap) {
+            throw new Error(`@smithy/core/schema - cannot get key for non-map: ${this.getName(true)}`);
+        }
+        const schema = this.getSchema();
+        const memberSchema = isDoc
+            ? 15
+            : schema[4] ?? 0;
+        return member([memberSchema, 0], "key");
+    }
+    getValueSchema() {
+        const sc = this.getSchema();
+        const [isDoc, isMap, isList] = [this.isDocumentSchema(), this.isMapSchema(), this.isListSchema()];
+        const memberSchema = typeof sc === "number"
+            ? 0b0011_1111 & sc
+            : sc && typeof sc === "object" && (isMap || isList)
+                ? sc[3 + sc[0]]
+                : isDoc
+                    ? 15
+                    : void 0;
+        if (memberSchema != null) {
+            return member([memberSchema, 0], isMap ? "value" : "member");
+        }
+        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`);
+    }
+    getMemberSchema(memberName) {
+        const struct = this.getSchema();
+        if (this.isStructSchema() && struct[4].includes(memberName)) {
+            const i = struct[4].indexOf(memberName);
+            const memberSchema = struct[5][i];
+            return member(isMemberSchema(memberSchema) ? memberSchema : [memberSchema, 0], memberName);
+        }
+        if (this.isDocumentSchema()) {
+            return member([15, 0], memberName);
+        }
+        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no no member=${memberName}.`);
+    }
+    getMemberSchemas() {
+        const buffer = {};
+        try {
+            for (const [k, v] of this.structIterator()) {
+                buffer[k] = v;
+            }
+        }
+        catch (ignored) { }
+        return buffer;
+    }
+    getEventStreamMember() {
+        if (this.isStructSchema()) {
+            for (const [memberName, memberSchema] of this.structIterator()) {
+                if (memberSchema.isStreaming() && memberSchema.isStructSchema()) {
+                    return memberName;
+                }
+            }
+        }
+        return "";
     }
-    if ((indicator >> 5 & 1) === 1) {
-      traits.httpResponseCode = 1;
+    *structIterator() {
+        if (this.isUnitSchema()) {
+            return;
+        }
+        if (!this.isStructSchema()) {
+            throw new Error("@smithy/core/schema - cannot iterate non-struct schema.");
+        }
+        const struct = this.getSchema();
+        for (let i = 0; i < struct[4].length; ++i) {
+            yield [struct[4][i], member([struct[5][i], 0], struct[4][i])];
+        }
     }
-    if ((indicator >> 6 & 1) === 1) {
-      traits.httpQueryParams = 1;
+}
+function member(memberSchema, memberName) {
+    if (memberSchema instanceof NormalizedSchema) {
+        return Object.assign(memberSchema, {
+            memberName,
+            _isMemberSchema: true,
+        });
+    }
+    const internalCtorAccess = NormalizedSchema;
+    return new internalCtorAccess(memberSchema, memberName);
+}
+const isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
+const isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;
+
+class SimpleSchema extends Schema {
+    static symbol = Symbol.for("@smithy/sim");
+    name;
+    schemaRef;
+    traits;
+    symbol = SimpleSchema.symbol;
+}
+const sim = (namespace, name, schemaRef, traits) => Schema.assign(new SimpleSchema(), {
+    name,
+    namespace,
+    traits,
+    schemaRef,
+});
+const simAdapter = (namespace, name, traits, schemaRef) => Schema.assign(new SimpleSchema(), {
+    name,
+    namespace,
+    traits,
+    schemaRef,
+});
+
+const SCHEMA = {
+    BLOB: 0b0001_0101,
+    STREAMING_BLOB: 0b0010_1010,
+    BOOLEAN: 0b0000_0010,
+    STRING: 0b0000_0000,
+    NUMERIC: 0b0000_0001,
+    BIG_INTEGER: 0b0001_0001,
+    BIG_DECIMAL: 0b0001_0011,
+    DOCUMENT: 0b0000_1111,
+    TIMESTAMP_DEFAULT: 0b0000_0100,
+    TIMESTAMP_DATE_TIME: 0b0000_0101,
+    TIMESTAMP_HTTP_DATE: 0b0000_0110,
+    TIMESTAMP_EPOCH_SECONDS: 0b0000_0111,
+    LIST_MODIFIER: 0b0100_0000,
+    MAP_MODIFIER: 0b1000_0000,
+};
+
+class TypeRegistry {
+    namespace;
+    schemas;
+    exceptions;
+    static registries = new Map();
+    constructor(namespace, schemas = new Map(), exceptions = new Map()) {
+        this.namespace = namespace;
+        this.schemas = schemas;
+        this.exceptions = exceptions;
+    }
+    static for(namespace) {
+        if (!TypeRegistry.registries.has(namespace)) {
+            TypeRegistry.registries.set(namespace, new TypeRegistry(namespace));
+        }
+        return TypeRegistry.registries.get(namespace);
     }
-    return traits;
-  }
-  /**
-   * Creates a normalized member schema from the given schema and member name.
-   */
-  static memberFrom(memberSchema, memberName) {
-    if (memberSchema instanceof _NormalizedSchema) {
-      memberSchema.memberName = memberName;
-      memberSchema._isMemberSchema = true;
-      return memberSchema;
-    }
-    return new _NormalizedSchema(memberSchema, memberName);
-  }
-  /**
-   * @returns the underlying non-normalized schema.
-   */
-  getSchema() {
-    if (this.schema instanceof _NormalizedSchema) {
-      return this.schema = this.schema.getSchema();
-    }
-    if (this.schema instanceof SimpleSchema) {
-      return deref(this.schema.schemaRef);
-    }
-    return deref(this.schema);
-  }
-  /**
-   * @param withNamespace - qualifies the name.
-   * @returns e.g. `MyShape` or `com.namespace#MyShape`.
-   */
-  getName(withNamespace = false) {
-    if (!withNamespace) {
-      if (this.name && this.name.includes("#")) {
-        return this.name.split("#")[1];
-      }
-    }
-    return this.name || void 0;
-  }
-  /**
-   * @returns the member name if the schema is a member schema.
-   * @throws Error when the schema isn't a member schema.
-   */
-  getMemberName() {
-    if (!this.isMemberSchema()) {
-      throw new Error(`@smithy/core/schema - cannot get member name on non-member schema: ${this.getName(true)}`);
-    }
-    return this.memberName;
-  }
-  isMemberSchema() {
-    return this._isMemberSchema;
-  }
-  isUnitSchema() {
-    return this.getSchema() === "unit";
-  }
-  /**
-   * boolean methods on this class help control flow in shape serialization and deserialization.
-   */
-  isListSchema() {
-    const inner = this.getSchema();
-    if (typeof inner === "number") {
-      return inner >= SCHEMA.LIST_MODIFIER && inner < SCHEMA.MAP_MODIFIER;
-    }
-    return inner instanceof ListSchema;
-  }
-  isMapSchema() {
-    const inner = this.getSchema();
-    if (typeof inner === "number") {
-      return inner >= SCHEMA.MAP_MODIFIER && inner <= 255;
-    }
-    return inner instanceof MapSchema;
-  }
-  isDocumentSchema() {
-    return this.getSchema() === SCHEMA.DOCUMENT;
-  }
-  isStructSchema() {
-    const inner = this.getSchema();
-    return inner !== null && typeof inner === "object" && "members" in inner || inner instanceof StructureSchema;
-  }
-  isBlobSchema() {
-    return this.getSchema() === SCHEMA.BLOB || this.getSchema() === SCHEMA.STREAMING_BLOB;
-  }
-  isTimestampSchema() {
-    const schema = this.getSchema();
-    return typeof schema === "number" && schema >= SCHEMA.TIMESTAMP_DEFAULT && schema <= SCHEMA.TIMESTAMP_EPOCH_SECONDS;
-  }
-  isStringSchema() {
-    return this.getSchema() === SCHEMA.STRING;
-  }
-  isBooleanSchema() {
-    return this.getSchema() === SCHEMA.BOOLEAN;
-  }
-  isNumericSchema() {
-    return this.getSchema() === SCHEMA.NUMERIC;
-  }
-  isBigIntegerSchema() {
-    return this.getSchema() === SCHEMA.BIG_INTEGER;
-  }
-  isBigDecimalSchema() {
-    return this.getSchema() === SCHEMA.BIG_DECIMAL;
-  }
-  isStreaming() {
-    const streaming = !!this.getMergedTraits().streaming;
-    if (streaming) {
-      return true;
-    }
-    return this.getSchema() === SCHEMA.STREAMING_BLOB;
-  }
-  /**
-   * @returns own traits merged with member traits, where member traits of the same trait key take priority.
-   * This method is cached.
-   */
-  getMergedTraits() {
-    if (this.normalizedTraits) {
-      return this.normalizedTraits;
-    }
-    this.normalizedTraits = {
-      ...this.getOwnTraits(),
-      ...this.getMemberTraits()
-    };
-    return this.normalizedTraits;
-  }
-  /**
-   * @returns only the member traits. If the schema is not a member, this returns empty.
-   */
-  getMemberTraits() {
-    return _NormalizedSchema.translateTraits(this.memberTraits);
-  }
-  /**
-   * @returns only the traits inherent to the shape or member target shape if this schema is a member.
-   * If there are any member traits they are excluded.
-   */
-  getOwnTraits() {
-    return _NormalizedSchema.translateTraits(this.traits);
-  }
-  /**
-   * @returns the map's key's schema. Returns a dummy Document schema if this schema is a Document.
-   *
-   * @throws Error if the schema is not a Map or Document.
-   */
-  getKeySchema() {
-    if (this.isDocumentSchema()) {
-      return _NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "key");
-    }
-    if (!this.isMapSchema()) {
-      throw new Error(`@smithy/core/schema - cannot get key schema for non-map schema: ${this.getName(true)}`);
-    }
-    const schema = this.getSchema();
-    if (typeof schema === "number") {
-      return _NormalizedSchema.memberFrom([63 & schema, 0], "key");
-    }
-    return _NormalizedSchema.memberFrom([schema.keySchema, 0], "key");
-  }
-  /**
-   * @returns the schema of the map's value or list's member.
-   * Returns a dummy Document schema if this schema is a Document.
-   *
-   * @throws Error if the schema is not a Map, List, nor Document.
-   */
-  getValueSchema() {
-    const schema = this.getSchema();
-    if (typeof schema === "number") {
-      if (this.isMapSchema()) {
-        return _NormalizedSchema.memberFrom([63 & schema, 0], "value");
-      } else if (this.isListSchema()) {
-        return _NormalizedSchema.memberFrom([63 & schema, 0], "member");
-      }
-    }
-    if (schema && typeof schema === "object") {
-      if (this.isStructSchema()) {
-        throw new Error(`cannot call getValueSchema() with StructureSchema ${this.getName(true)}`);
-      }
-      const collection = schema;
-      if ("valueSchema" in collection) {
-        if (this.isMapSchema()) {
-          return _NormalizedSchema.memberFrom([collection.valueSchema, 0], "value");
-        } else if (this.isListSchema()) {
-          return _NormalizedSchema.memberFrom([collection.valueSchema, 0], "member");
+    register(shapeId, schema) {
+        const qualifiedName = this.normalizeShapeId(shapeId);
+        const registry = TypeRegistry.for(qualifiedName.split("#")[0]);
+        registry.schemas.set(qualifiedName, schema);
+    }
+    getSchema(shapeId) {
+        const id = this.normalizeShapeId(shapeId);
+        if (!this.schemas.has(id)) {
+            throw new Error(`@smithy/core/schema - schema not found for ${id}`);
         }
-      }
-    }
-    if (this.isDocumentSchema()) {
-      return _NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "value");
-    }
-    throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a value member.`);
-  }
-  /**
-   * @returns the NormalizedSchema for the given member name. The returned instance will return true for `isMemberSchema()`
-   * and will have the member name given.
-   * @param member - which member to retrieve and wrap.
-   *
-   * @throws Error if member does not exist or the schema is neither a document nor structure.
-   * Note that errors are assumed to be structures and unions are considered structures for these purposes.
-   */
-  getMemberSchema(member) {
-    if (this.isStructSchema()) {
-      const struct2 = this.getSchema();
-      if (!(member in struct2.members)) {
-        throw new Error(
-          `@smithy/core/schema - the schema ${this.getName(true)} does not have a member with name=${member}.`
-        );
-      }
-      return _NormalizedSchema.memberFrom(struct2.members[member], member);
-    }
-    if (this.isDocumentSchema()) {
-      return _NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], member);
-    }
-    throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have members.`);
-  }
-  /**
-   * This can be used for checking the members as a hashmap.
-   * Prefer the structIterator method for iteration.
-   *
-   * This does NOT return list and map members, it is only for structures.
-   *
-   * @returns a map of member names to member schemas (normalized).
-   */
-  getMemberSchemas() {
-    const { schema } = this;
-    const struct2 = schema;
-    if (!struct2 || typeof struct2 !== "object") {
-      return {};
-    }
-    if ("members" in struct2) {
-      const buffer = {};
-      for (const member of struct2.memberNames) {
-        buffer[member] = this.getMemberSchema(member);
-      }
-      return buffer;
-    }
-    return {};
-  }
-  /**
-   * Allows iteration over members of a structure schema.
-   * Each yield is a pair of the member name and member schema.
-   *
-   * This avoids the overhead of calling Object.entries(ns.getMemberSchemas()).
-   */
-  *structIterator() {
-    if (this.isUnitSchema()) {
-      return;
-    }
-    if (!this.isStructSchema()) {
-      throw new Error("@smithy/core/schema - cannot acquire structIterator on non-struct schema.");
-    }
-    const struct2 = this.getSchema();
-    for (let i = 0; i < struct2.memberNames.length; ++i) {
-      yield [struct2.memberNames[i], _NormalizedSchema.memberFrom([struct2.memberList[i], 0], struct2.memberNames[i])];
-    }
-  }
-  /**
-   * @returns a last-resort human-readable name for the schema if it has no other identifiers.
-   */
-  getSchemaName() {
-    const schema = this.getSchema();
-    if (typeof schema === "number") {
-      const _schema = 63 & schema;
-      const container = 192 & schema;
-      const type = Object.entries(SCHEMA).find(([, value]) => {
-        return value === _schema;
-      })?.[0] ?? "Unknown";
-      switch (container) {
-        case SCHEMA.MAP_MODIFIER:
-          return `${type}Map`;
-        case SCHEMA.LIST_MODIFIER:
-          return `${type}List`;
-        case 0:
-          return type;
-      }
-    }
-    return "Unknown";
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ErrorSchema,
-  ListSchema,
-  MapSchema,
-  NormalizedSchema,
-  OperationSchema,
-  SCHEMA,
-  Schema,
-  SimpleSchema,
-  StructureSchema,
-  TypeRegistry,
-  deref,
-  deserializerMiddlewareOption,
-  error,
-  getSchemaSerdePlugin,
-  list,
-  map,
-  op,
-  serializerMiddlewareOption,
-  sim,
-  struct
-});
+        return this.schemas.get(id);
+    }
+    registerError(es, ctor) {
+        const $error = es;
+        const registry = TypeRegistry.for($error[1]);
+        registry.schemas.set($error[1] + "#" + $error[2], $error);
+        registry.exceptions.set($error, ctor);
+    }
+    getErrorCtor(es) {
+        const $error = es;
+        const registry = TypeRegistry.for($error[1]);
+        return registry.exceptions.get($error);
+    }
+    getBaseException() {
+        for (const exceptionKey of this.exceptions.keys()) {
+            if (Array.isArray(exceptionKey)) {
+                const [, ns, name] = exceptionKey;
+                const id = ns + "#" + name;
+                if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
+                    return exceptionKey;
+                }
+            }
+        }
+        return undefined;
+    }
+    find(predicate) {
+        return [...this.schemas.values()].find(predicate);
+    }
+    clear() {
+        this.schemas.clear();
+        this.exceptions.clear();
+    }
+    normalizeShapeId(shapeId) {
+        if (shapeId.includes("#")) {
+            return shapeId;
+        }
+        return this.namespace + "#" + shapeId;
+    }
+}
+
+exports.ErrorSchema = ErrorSchema;
+exports.ListSchema = ListSchema;
+exports.MapSchema = MapSchema;
+exports.NormalizedSchema = NormalizedSchema;
+exports.OperationSchema = OperationSchema;
+exports.SCHEMA = SCHEMA;
+exports.Schema = Schema;
+exports.SimpleSchema = SimpleSchema;
+exports.StructureSchema = StructureSchema;
+exports.TypeRegistry = TypeRegistry;
+exports.deref = deref;
+exports.deserializerMiddlewareOption = deserializerMiddlewareOption;
+exports.error = error;
+exports.getSchemaSerdePlugin = getSchemaSerdePlugin;
+exports.isStaticSchema = isStaticSchema;
+exports.list = list;
+exports.map = map;
+exports.op = op;
+exports.operation = operation;
+exports.serializerMiddlewareOption = serializerMiddlewareOption;
+exports.sim = sim;
+exports.simAdapter = simAdapter;
+exports.struct = struct;
+exports.translateTraits = translateTraits;