@gemeentenijmegen/webapp 1.1.8 → 1.1.10

package/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js

@@ -0,0 +1,49 @@
+export class TypeRegistry {
+    constructor(namespace, schemas = new Map()) {
+        this.namespace = namespace;
+        this.schemas = schemas;
+    }
+    static for(namespace) {
+        if (!TypeRegistry.registries.has(namespace)) {
+            TypeRegistry.registries.set(namespace, new TypeRegistry(namespace));
+        }
+        return TypeRegistry.registries.get(namespace);
+    }
+    register(shapeId, schema) {
+        const qualifiedName = this.normalizeShapeId(shapeId);
+        const registry = TypeRegistry.for(this.getNamespace(shapeId));
+        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}`);
+        }
+        return this.schemas.get(id);
+    }
+    getBaseException() {
+        for (const [id, schema] of this.schemas.entries()) {
+            if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
+                return schema;
+            }
+        }
+        return undefined;
+    }
+    find(predicate) {
+        return [...this.schemas.values()].find(predicate);
+    }
+    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];
+    }
+}
+TypeRegistry.registries = new Map();

package/node_modules/@smithy/core/dist-es/submodules/schema/deref.js

@@ -0,0 +1,6 @@
+export const deref = (schemaRef) => {
+    if (typeof schemaRef === "function") {
+        return schemaRef();
+    }
+    return schemaRef;
+};

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

@@ -0,0 +1,12 @@
+export * from "./deref";
+export * from "./middleware/getSchemaSerdePlugin";
+export * from "./schemas/ListSchema";
+export * from "./schemas/MapSchema";
+export * from "./schemas/OperationSchema";
+export * from "./schemas/ErrorSchema";
+export * from "./schemas/NormalizedSchema";
+export * from "./schemas/Schema";
+export * from "./schemas/SimpleSchema";
+export * from "./schemas/StructureSchema";
+export * from "./schemas/sentinels";
+export * from "./TypeRegistry";

package/node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js

@@ -0,0 +1,23 @@
+import { schemaDeserializationMiddleware } from "./schemaDeserializationMiddleware";
+import { schemaSerializationMiddleware } from "./schemaSerializationMiddleware";
+export const deserializerMiddlewareOption = {
+    name: "deserializerMiddleware",
+    step: "deserialize",
+    tags: ["DESERIALIZER"],
+    override: true,
+};
+export const serializerMiddlewareOption = {
+    name: "serializerMiddleware",
+    step: "serialize",
+    tags: ["SERIALIZER"],
+    override: true,
+};
+export function getSchemaSerdePlugin(config) {
+    return {
+        applyToStack: (commandStack) => {
+            commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
+            commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
+            config.protocol.setSerdeContext(config);
+        },
+    };
+}

package/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schema-middleware-types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js

@@ -0,0 +1,60 @@
+import { HttpResponse } from "@smithy/protocol-http";
+import { getSmithyContext } from "@smithy/util-middleware";
+export const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
+    const { response } = await next(args);
+    const { operationSchema } = getSmithyContext(context);
+    try {
+        const parsed = await config.protocol.deserializeResponse(operationSchema, {
+            ...config,
+            ...context,
+        }, response);
+        return {
+            response,
+            output: parsed,
+        };
+    }
+    catch (error) {
+        Object.defineProperty(error, "$response", {
+            value: response,
+        });
+        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 (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) {
+            }
+        }
+        throw error;
+    }
+};
+const findHeader = (pattern, headers) => {
+    return (headers.find(([k]) => {
+        return k.match(pattern);
+    }) || [void 0, void 1])[1];
+};

package/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js

@@ -0,0 +1,16 @@
+import { getSmithyContext } from "@smithy/util-middleware";
+export const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
+    const { operationSchema } = 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,
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js

@@ -0,0 +1,27 @@
+import { TypeRegistry } from "../TypeRegistry";
+import { StructureSchema } from "./StructureSchema";
+export 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 [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;
+    }
+}
+ErrorSchema.symbol = Symbol.for("@smithy/core/schema::ErrorSchema");
+export 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;
+}

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ListSchema.js

@@ -0,0 +1,25 @@
+import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
+export 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 [Symbol.hasInstance](lhs) {
+        const isPrototype = ListSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const list = lhs;
+            return list.symbol === ListSchema.symbol;
+        }
+        return isPrototype;
+    }
+}
+ListSchema.symbol = Symbol.for("@smithy/core/schema::ListSchema");
+export 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;
+}

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/MapSchema.js

@@ -0,0 +1,26 @@
+import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
+export 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 [Symbol.hasInstance](lhs) {
+        const isPrototype = MapSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const map = lhs;
+            return map.symbol === MapSchema.symbol;
+        }
+        return isPrototype;
+    }
+}
+MapSchema.symbol = Symbol.for("@smithy/core/schema::MapSchema");
+export 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;
+}

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js

@@ -0,0 +1,304 @@
+import { deref } from "../deref";
+import { ListSchema } from "./ListSchema";
+import { MapSchema } from "./MapSchema";
+import { SCHEMA } from "./sentinels";
+import { SimpleSchema } from "./SimpleSchema";
+import { StructureSchema } from "./StructureSchema";
+export class NormalizedSchema {
+    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 [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 of(ref, memberName) {
+        if (ref instanceof NormalizedSchema) {
+            return ref;
+        }
+        return new NormalizedSchema(ref, memberName);
+    }
+    static translateTraits(indicator) {
+        if (typeof indicator === "object") {
+            return indicator;
+        }
+        indicator = indicator | 0;
+        const traits = {};
+        if ((indicator & 1) === 1) {
+            traits.httpLabel = 1;
+        }
+        if (((indicator >> 1) & 1) === 1) {
+            traits.idempotent = 1;
+        }
+        if (((indicator >> 2) & 1) === 1) {
+            traits.idempotencyToken = 1;
+        }
+        if (((indicator >> 3) & 1) === 1) {
+            traits.sensitive = 1;
+        }
+        if (((indicator >> 4) & 1) === 1) {
+            traits.httpPayload = 1;
+        }
+        if (((indicator >> 5) & 1) === 1) {
+            traits.httpResponseCode = 1;
+        }
+        if (((indicator >> 6) & 1) === 1) {
+            traits.httpQueryParams = 1;
+        }
+        return traits;
+    }
+    static memberFrom(memberSchema, memberName) {
+        if (memberSchema instanceof NormalizedSchema) {
+            memberSchema.memberName = memberName;
+            memberSchema._isMemberSchema = true;
+            return memberSchema;
+        }
+        return new NormalizedSchema(memberSchema, memberName);
+    }
+    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);
+    }
+    getName(withNamespace = false) {
+        if (!withNamespace) {
+            if (this.name && this.name.includes("#")) {
+                return this.name.split("#")[1];
+            }
+        }
+        return this.name || undefined;
+    }
+    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";
+    }
+    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;
+    }
+    getMergedTraits() {
+        if (this.normalizedTraits) {
+            return this.normalizedTraits;
+        }
+        this.normalizedTraits = {
+            ...this.getOwnTraits(),
+            ...this.getMemberTraits(),
+        };
+        return this.normalizedTraits;
+    }
+    getMemberTraits() {
+        return NormalizedSchema.translateTraits(this.memberTraits);
+    }
+    getOwnTraits() {
+        return NormalizedSchema.translateTraits(this.traits);
+    }
+    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");
+    }
+    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");
+                }
+            }
+        }
+        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.`);
+    }
+    getMemberSchema(member) {
+        if (this.isStructSchema()) {
+            const struct = this.getSchema();
+            if (!(member in struct.members)) {
+                throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a member with name=${member}.`);
+            }
+            return NormalizedSchema.memberFrom(struct.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.`);
+    }
+    getMemberSchemas() {
+        const { schema } = this;
+        const struct = schema;
+        if (!struct || typeof struct !== "object") {
+            return {};
+        }
+        if ("members" in struct) {
+            const buffer = {};
+            for (const member of struct.memberNames) {
+                buffer[member] = this.getMemberSchema(member);
+            }
+            return buffer;
+        }
+        return {};
+    }
+    *structIterator() {
+        if (this.isUnitSchema()) {
+            return;
+        }
+        if (!this.isStructSchema()) {
+            throw new Error("@smithy/core/schema - cannot acquire structIterator on non-struct schema.");
+        }
+        const struct = this.getSchema();
+        for (let i = 0; i < struct.memberNames.length; ++i) {
+            yield [struct.memberNames[i], NormalizedSchema.memberFrom([struct.memberList[i], 0], struct.memberNames[i])];
+        }
+    }
+    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";
+    }
+}
+NormalizedSchema.symbol = Symbol.for("@smithy/core/schema::NormalizedSchema");

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/OperationSchema.js

@@ -0,0 +1,16 @@
+import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
+export class OperationSchema extends Schema {
+    constructor(name, traits, input, output) {
+        super(name, traits);
+        this.name = name;
+        this.traits = traits;
+        this.input = input;
+        this.output = output;
+    }
+}
+export function op(namespace, name, traits = {}, input, output) {
+    const schema = new OperationSchema(namespace + "#" + name, traits, input, output);
+    TypeRegistry.for(namespace).register(name, schema);
+    return schema;
+}

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js

@@ -0,0 +1,6 @@
+export class Schema {
+    constructor(name, traits) {
+        this.name = name;
+        this.traits = traits;
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js

@@ -0,0 +1,25 @@
+import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
+export 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 [Symbol.hasInstance](lhs) {
+        const isPrototype = SimpleSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const sim = lhs;
+            return sim.symbol === SimpleSchema.symbol;
+        }
+        return isPrototype;
+    }
+}
+SimpleSchema.symbol = Symbol.for("@smithy/core/schema::SimpleSchema");
+export function sim(namespace, name, schemaRef, traits) {
+    const schema = new SimpleSchema(namespace + "#" + name, schemaRef, traits);
+    TypeRegistry.for(namespace).register(name, schema);
+    return schema;
+}

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js

@@ -0,0 +1,32 @@
+import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
+export 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 [Symbol.hasInstance](lhs) {
+        const isPrototype = StructureSchema.prototype.isPrototypeOf(lhs);
+        if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+            const struct = lhs;
+            return struct.symbol === StructureSchema.symbol;
+        }
+        return isPrototype;
+    }
+}
+StructureSchema.symbol = Symbol.for("@smithy/core/schema::StructureSchema");
+export function struct(namespace, name, traits, memberNames, memberList) {
+    const schema = new StructureSchema(namespace + "#" + name, traits, memberNames, memberList);
+    TypeRegistry.for(namespace).register(name, schema);
+    return schema;
+}

package/node_modules/@smithy/core/dist-es/submodules/schema/schemas/sentinels.js

@@ -0,0 +1,16 @@
+export const SCHEMA = {
+    BLOB: 21,
+    STREAMING_BLOB: 42,
+    BOOLEAN: 2,
+    STRING: 0,
+    NUMERIC: 1,
+    BIG_INTEGER: 17,
+    BIG_DECIMAL: 19,
+    DOCUMENT: 15,
+    TIMESTAMP_DEFAULT: 4,
+    TIMESTAMP_DATE_TIME: 5,
+    TIMESTAMP_HTTP_DATE: 6,
+    TIMESTAMP_EPOCH_SECONDS: 7,
+    LIST_MODIFIER: 64,
+    MAP_MODIFIER: 128,
+};