@mavogel/awscdk-rootmail 0.0.320 → 0.0.322

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

@@ -1,27 +1,17 @@
-import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
 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;
+    constructor() {
+        super(...arguments);
         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;
 }
+ErrorSchema.symbol = Symbol.for("@smithy/err");
+export const error = (namespace, name, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), {
+    name,
+    namespace,
+    traits,
+    memberNames,
+    memberList,
+    ctor: null,
+});

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

@@ -1,25 +1,14 @@
-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;
+    constructor() {
+        super(...arguments);
         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;
 }
+ListSchema.symbol = Symbol.for("@smithy/lis");
+export const list = (namespace, name, traits, valueSchema) => Schema.assign(new ListSchema(), {
+    name,
+    namespace,
+    traits,
+    valueSchema,
+});

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

@@ -1,26 +1,15 @@
-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;
+    constructor() {
+        super(...arguments);
         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;
 }
+MapSchema.symbol = Symbol.for("@smithy/map");
+export const map = (namespace, name, traits, keySchema, valueSchema) => Schema.assign(new MapSchema(), {
+    name,
+    namespace,
+    traits,
+    keySchema,
+    valueSchema,
+});

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

@@ -1,6 +1,7 @@
 import { deref } from "../deref";
 import { ListSchema } from "./ListSchema";
 import { MapSchema } from "./MapSchema";
+import { Schema } from "./Schema";
 import { SCHEMA } from "./sentinels";
 import { SimpleSchema } from "./SimpleSchema";
 import { StructureSchema } from "./StructureSchema";
@@ -30,13 +31,10 @@ export class NormalizedSchema {
             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());
+            const computedMemberTraits = this.memberTraits;
+            Object.assign(this, schema);
+            this.memberTraits = Object.assign({}, computedMemberTraits, schema.getMemberTraits(), this.getMemberTraits());
             this.normalizedTraits = void 0;
-            this.ref = schema.ref;
             this.memberName = memberName ?? schema.memberName;
             return;
         }
@@ -48,24 +46,27 @@ export class NormalizedSchema {
             this.traits = 0;
         }
         this.name =
-            (typeof this.schema === "object" ? this.schema?.name : void 0) ?? this.memberName ?? this.getSchemaName();
+            (this.schema instanceof Schema ? this.schema.getName?.() : 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.`);
+            throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
         }
     }
     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;
+        return Schema[Symbol.hasInstance].bind(this)(lhs);
     }
-    static of(ref, memberName) {
+    static of(ref) {
         if (ref instanceof NormalizedSchema) {
             return ref;
         }
-        return new NormalizedSchema(ref, memberName);
+        if (Array.isArray(ref)) {
+            const [ns, traits] = ref;
+            if (ns instanceof NormalizedSchema) {
+                Object.assign(ns.getMergedTraits(), NormalizedSchema.translateTraits(traits));
+                return ns;
+            }
+            throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`);
+        }
+        return new NormalizedSchema(ref);
     }
     static translateTraits(indicator) {
         if (typeof indicator === "object") {
@@ -73,40 +74,26 @@ export class NormalizedSchema {
         }
         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;
+        let i = 0;
+        for (const trait of [
+            "httpLabel",
+            "idempotent",
+            "idempotencyToken",
+            "sensitive",
+            "httpPayload",
+            "httpResponseCode",
+            "httpQueryParams",
+        ]) {
+            if (((indicator >> i++) & 1) === 1) {
+                traits[trait] = 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());
+            Object.assign(this, { schema: this.schema.getSchema() });
+            return this.schema;
         }
         if (this.schema instanceof SimpleSchema) {
             return deref(this.schema.schemaRef);
@@ -123,7 +110,7 @@ export class NormalizedSchema {
     }
     getMemberName() {
         if (!this.isMemberSchema()) {
-            throw new Error(`@smithy/core/schema - cannot get member name on non-member schema: ${this.getName(true)}`);
+            throw new Error(`@smithy/core/schema - non-member schema: ${this.getName(true)}`);
         }
         return this.memberName;
     }
@@ -147,9 +134,6 @@ export class NormalizedSchema {
         }
         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;
@@ -161,6 +145,9 @@ export class NormalizedSchema {
         const schema = this.getSchema();
         return typeof schema === "number" && schema >= SCHEMA.TIMESTAMP_DEFAULT && schema <= SCHEMA.TIMESTAMP_EPOCH_SECONDS;
     }
+    isDocumentSchema() {
+        return this.getSchema() === SCHEMA.DOCUMENT;
+    }
     isStringSchema() {
         return this.getSchema() === SCHEMA.STRING;
     }
@@ -184,23 +171,29 @@ export class NormalizedSchema {
         return this.getSchema() === SCHEMA.STREAMING_BLOB;
     }
     isIdempotencyToken() {
-        if (typeof this.traits === "number") {
-            return (this.traits & 0b0100) === 0b0100;
+        if (this.normalizedTraits) {
+            return !!this.normalizedTraits.idempotencyToken;
         }
-        else if (typeof this.traits === "object") {
-            return !!this.traits.idempotencyToken;
+        for (const traits of [this.traits, this.memberTraits]) {
+            if (typeof traits === "number") {
+                if ((traits & 0b0100) === 0b0100) {
+                    return true;
+                }
+            }
+            else if (typeof traits === "object") {
+                if (!!traits.idempotencyToken) {
+                    return true;
+                }
+            }
         }
         return false;
     }
     getMergedTraits() {
-        if (this.normalizedTraits) {
-            return this.normalizedTraits;
-        }
-        this.normalizedTraits = {
-            ...this.getOwnTraits(),
-            ...this.getMemberTraits(),
-        };
-        return this.normalizedTraits;
+        return (this.normalizedTraits ??
+            (this.normalizedTraits = {
+                ...this.getOwnTraits(),
+                ...this.getMemberTraits(),
+            }));
     }
     getMemberTraits() {
         return NormalizedSchema.translateTraits(this.memberTraits);
@@ -210,86 +203,109 @@ export class NormalizedSchema {
     }
     getKeySchema() {
         if (this.isDocumentSchema()) {
-            return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "key");
+            return this.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)}`);
+            throw new Error(`@smithy/core/schema - cannot get key for non-map: ${this.getName(true)}`);
         }
         const schema = this.getSchema();
         if (typeof schema === "number") {
-            return NormalizedSchema.memberFrom([63 & schema, 0], "key");
+            return this.memberFrom([63 & schema, 0], "key");
         }
-        return NormalizedSchema.memberFrom([schema.keySchema, 0], "key");
+        return this.memberFrom([schema.keySchema, 0], "key");
     }
     getValueSchema() {
         const schema = this.getSchema();
         if (typeof schema === "number") {
             if (this.isMapSchema()) {
-                return NormalizedSchema.memberFrom([63 & schema, 0], "value");
+                return this.memberFrom([63 & schema, 0], "value");
             }
             else if (this.isListSchema()) {
-                return NormalizedSchema.memberFrom([63 & schema, 0], "member");
+                return this.memberFrom([63 & schema, 0], "member");
             }
         }
         if (schema && typeof schema === "object") {
             if (this.isStructSchema()) {
-                throw new Error(`cannot call getValueSchema() with StructureSchema ${this.getName(true)}`);
+                throw new Error(`may not getValueSchema() on structure ${this.getName(true)}`);
             }
             const collection = schema;
             if ("valueSchema" in collection) {
                 if (this.isMapSchema()) {
-                    return NormalizedSchema.memberFrom([collection.valueSchema, 0], "value");
+                    return this.memberFrom([collection.valueSchema, 0], "value");
                 }
                 else if (this.isListSchema()) {
-                    return NormalizedSchema.memberFrom([collection.valueSchema, 0], "member");
+                    return this.memberFrom([collection.valueSchema, 0], "member");
                 }
             }
         }
         if (this.isDocumentSchema()) {
-            return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "value");
+            return this.memberFrom([SCHEMA.DOCUMENT, 0], "value");
+        }
+        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`);
+    }
+    hasMemberSchema(member) {
+        if (this.isStructSchema()) {
+            const struct = this.getSchema();
+            return struct.memberNames.includes(member);
         }
-        throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a value member.`);
+        return false;
     }
     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}.`);
+            if (!struct.memberNames.includes(member)) {
+                throw new Error(`@smithy/core/schema - ${this.getName(true)} has no member=${member}.`);
             }
-            return NormalizedSchema.memberFrom(struct.members[member], member);
+            const i = struct.memberNames.indexOf(member);
+            const memberSchema = struct.memberList[i];
+            return this.memberFrom(Array.isArray(memberSchema) ? memberSchema : [memberSchema, 0], member);
         }
         if (this.isDocumentSchema()) {
-            return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], member);
+            return this.memberFrom([SCHEMA.DOCUMENT, 0], member);
         }
-        throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have members.`);
+        throw new Error(`@smithy/core/schema - ${this.getName(true)} has no 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);
+        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 buffer;
         }
-        return {};
+        return "";
     }
     *structIterator() {
         if (this.isUnitSchema()) {
             return;
         }
         if (!this.isStructSchema()) {
-            throw new Error("@smithy/core/schema - cannot acquire structIterator on non-struct schema.");
+            throw new Error("@smithy/core/schema - cannot iterate 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])];
+            yield [struct.memberNames[i], this.memberFrom([struct.memberList[i], 0], struct.memberNames[i])];
         }
     }
+    memberFrom(memberSchema, memberName) {
+        if (memberSchema instanceof NormalizedSchema) {
+            return Object.assign(memberSchema, {
+                memberName,
+                _isMemberSchema: true,
+            });
+        }
+        return new NormalizedSchema(memberSchema, memberName);
+    }
     getSchemaName() {
         const schema = this.getSchema();
         if (typeof schema === "number") {
@@ -310,4 +326,4 @@ export class NormalizedSchema {
         return "Unknown";
     }
 }
-NormalizedSchema.symbol = Symbol.for("@smithy/core/schema::NormalizedSchema");
+NormalizedSchema.symbol = Symbol.for("@smithy/nor");

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

@@ -1,16 +1,15 @@
-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;
+    constructor() {
+        super(...arguments);
+        this.symbol = OperationSchema.symbol;
     }
 }
-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;
-}
+OperationSchema.symbol = Symbol.for("@smithy/ope");
+export const op = (namespace, name, traits, input, output) => Schema.assign(new OperationSchema(), {
+    name,
+    namespace,
+    traits,
+    input,
+    output,
+});

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

@@ -1,6 +1,19 @@
+import { TypeRegistry } from "../TypeRegistry";
 export class Schema {
-    constructor(name, traits) {
-        this.name = name;
-        this.traits = traits;
+    static assign(instance, values) {
+        const schema = Object.assign(instance, values);
+        TypeRegistry.for(schema.namespace).register(schema.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;
     }
 }

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

@@ -1,25 +1,14 @@
-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;
+    constructor() {
+        super(...arguments);
         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;
 }
+SimpleSchema.symbol = Symbol.for("@smithy/sim");
+export const sim = (namespace, name, schemaRef, traits) => Schema.assign(new SimpleSchema(), {
+    name,
+    namespace,
+    traits,
+    schemaRef,
+});

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

@@ -1,32 +1,15 @@
-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;
+    constructor() {
+        super(...arguments);
         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;
 }
+StructureSchema.symbol = Symbol.for("@smithy/str");
+export const struct = (namespace, name, traits, memberNames, memberList) => Schema.assign(new StructureSchema(), {
+    name,
+    namespace,
+    traits,
+    memberNames,
+    memberList,
+});

package/node_modules/@smithy/core/dist-es/submodules/serde/generateIdempotencyToken.js

@@ -1,2 +1,2 @@
-import { v4 as generateIdempotencyToken } from "uuid";
+import { v4 as generateIdempotencyToken } from "@smithy/uuid";
 export { generateIdempotencyToken };

package/node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js

@@ -28,11 +28,13 @@ export class NumericValue {
             return false;
         }
         const _nv = object;
-        const prototypeMatch = NumericValue.prototype.isPrototypeOf(object.constructor?.prototype);
+        const prototypeMatch = NumericValue.prototype.isPrototypeOf(object);
         if (prototypeMatch) {
             return prototypeMatch;
         }
-        if (typeof _nv.string === "string" && typeof _nv.type === "string" && _nv.constructor?.name === "NumericValue") {
+        if (typeof _nv.string === "string" &&
+            typeof _nv.type === "string" &&
+            _nv.constructor?.name?.endsWith("NumericValue")) {
             return true;
         }
         return prototypeMatch;

package/node_modules/@smithy/core/dist-types/getSmithyContext.d.ts

@@ -1,4 +1,4 @@
-import { HandlerExecutionContext } from "@smithy/types";
+import type { HandlerExecutionContext } from "@smithy/types";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.d.ts

@@ -1,5 +1,5 @@
-import { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
-import { PreviouslyResolved } from "./httpAuthSchemeMiddleware";
+import type { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
+import type { PreviouslyResolved } from "./httpAuthSchemeMiddleware";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/getHttpAuthSchemePlugin.d.ts

@@ -1,5 +1,5 @@
-import { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
-import { PreviouslyResolved } from "./httpAuthSchemeMiddleware";
+import type { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
+import type { PreviouslyResolved } from "./httpAuthSchemeMiddleware";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/httpAuthSchemeMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { HandlerExecutionContext, HttpAuthScheme, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, IdentityProviderConfig, Provider, SelectedHttpAuthScheme, SerializeMiddleware, SMITHY_CONTEXT_KEY } from "@smithy/types";
+import type { HandlerExecutionContext, HttpAuthScheme, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, IdentityProviderConfig, Provider, SelectedHttpAuthScheme, SerializeMiddleware, SMITHY_CONTEXT_KEY } from "@smithy/types";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/resolveAuthOptions.d.ts

@@ -1,4 +1,4 @@
-import { HttpAuthOption } from "@smithy/types";
+import type { HttpAuthOption } from "@smithy/types";
 /**
  * Resolves list of auth options based on the supported ones, vs the preference list.
  *

package/node_modules/@smithy/core/dist-types/middleware-http-signing/getHttpSigningMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { FinalizeRequestHandlerOptions, Pluggable, RelativeMiddlewareOptions } from "@smithy/types";
+import type { FinalizeRequestHandlerOptions, Pluggable, RelativeMiddlewareOptions } from "@smithy/types";
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/middleware-http-signing/httpSigningMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { FinalizeRequestMiddleware } from "@smithy/types";
+import type { FinalizeRequestMiddleware } from "@smithy/types";
 /**
  * @internal
  */