@mavogel/awscdk-rootmail 0.1.2 → 0.1.3

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/service-error-classification/constants.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Errors encountered when the client clock and server clock cannot agree on the
+ * current time.
+ *
+ * These errors are retryable, assuming the SDK has enabled clock skew
+ * correction.
+ *
+ */
+export declare const CLOCK_SKEW_ERROR_CODES: string[];
+/**
+ * Errors that indicate the SDK is being throttled.
+ *
+ * These errors are always retryable.
+ */
+export declare const THROTTLING_ERROR_CODES: string[];
+/**
+ * Error codes that indicate transient issues
+ */
+export declare const TRANSIENT_ERROR_CODES: string[];
+/**
+ * Error codes that indicate transient issues
+ */
+export declare const TRANSIENT_ERROR_STATUS_CODES: number[];
+/**
+ * Node.js system error codes that indicate timeout.
+ */
+export declare const NODEJS_TIMEOUT_ERROR_CODES: string[];
+/**
+ * Node.js system error codes that indicate network error.
+ */
+export declare const NODEJS_NETWORK_ERROR_CODES: string[];

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/service-error-classification/service-error-classification.d.ts

@@ -0,0 +1,30 @@
+import { SdkError } from "@smithy/types";
+export declare const isRetryableByTrait: (error: SdkError) => boolean;
+/**
+ * @deprecated use isClockSkewCorrectedError. This is only used in deprecated code.
+ */
+export declare const isClockSkewError: (error: SdkError) => boolean;
+/**
+ * @returns whether the error resulted in a systemClockOffset aka clock skew correction.
+ */
+export declare const isClockSkewCorrectedError: (error: SdkError) => true | undefined;
+/**
+ *
+ * @internal
+ */
+export declare const isBrowserNetworkError: (error: SdkError) => boolean;
+export declare const isThrottlingError: (error: SdkError) => boolean;
+/**
+ * Though NODEJS_TIMEOUT_ERROR_CODES are platform specific, they are
+ * included here because there is an error scenario with unknown root
+ * cause where the NodeHttpHandler does not decorate the Error with
+ * the name "TimeoutError" to be checked by the TRANSIENT_ERROR_CODES condition.
+ */
+export declare const isTransientError: (error: SdkError, depth?: number) => boolean;
+export declare const isServerError: (error: SdkError) => boolean;
+/**
+ * @internal
+ */
+export declare function isNodeJsHttp2TransientError(error: Error & {
+    code?: string;
+}): boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/AdaptiveRetryStrategy.d.ts

@@ -0,0 +1,38 @@
+import { Provider, RetryErrorInfo, RetryStrategyV2, RetryToken, StandardRetryToken } from "@smithy/types";
+import { StandardRetryStrategyOptions } from "./StandardRetryStrategy";
+import { RateLimiter } from "./types";
+/**
+ * Strategy options to be passed to AdaptiveRetryStrategy
+ *
+ * @public
+ */
+export interface AdaptiveRetryStrategyOptions extends Partial<StandardRetryStrategyOptions> {
+    rateLimiter?: RateLimiter;
+}
+/**
+ * The AdaptiveRetryStrategy is a retry strategy for executing against a very
+ * resource constrained set of resources. Care should be taken when using this
+ * retry strategy. By default, it uses a dynamic backoff delay based on load
+ * currently perceived against the downstream resource and performs circuit
+ * breaking to disable retries in the event of high downstream failures using
+ * the DefaultRateLimiter.
+ *
+ * @public
+ *
+ * @see {@link StandardRetryStrategy}
+ * @see {@link DefaultRateLimiter }
+ */
+export declare class AdaptiveRetryStrategy implements RetryStrategyV2 {
+    readonly mode: string;
+    private rateLimiter;
+    private standardRetryStrategy;
+    constructor(maxAttemptsProvider: number | Provider<number>, options?: AdaptiveRetryStrategyOptions);
+    acquireInitialRetryToken(retryTokenScope: string): Promise<RetryToken>;
+    refreshRetryTokenForRetry(tokenToRenew: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<RetryToken>;
+    recordSuccess(token: StandardRetryToken): void;
+    /**
+     * There is an existing integration which accesses this field.
+     * @deprecated
+     */
+    maxAttemptsProvider(): Promise<number>;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/ConfiguredRetryStrategy.d.ts

@@ -0,0 +1,31 @@
+import { Provider, RetryBackoffStrategy, RetryStrategyV2 } from "@smithy/types";
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+/**
+ * This extension of the StandardRetryStrategy allows customizing the
+ * backoff computation.
+ *
+ * @public
+ */
+export declare class ConfiguredRetryStrategy extends StandardRetryStrategy implements RetryStrategyV2 {
+    private readonly computeNextBackoffDelay;
+    /**
+     * @param maxAttempts - the maximum number of retry attempts allowed.
+     *                      e.g., if set to 3, then 4 total requests are possible.
+     * @param computeNextBackoffDelay - a millisecond delay for each retry or a function that takes the retry attempt
+     *                                  and returns the delay.
+     *
+     * @example exponential backoff.
+     * ```js
+     * new Client({
+     *   retryStrategy: new ConfiguredRetryStrategy(3, (attempt) => attempt ** 2)
+     * });
+     * ```
+     * @example constant delay.
+     * ```js
+     * new Client({
+     *   retryStrategy: new ConfiguredRetryStrategy(3, 2000)
+     * });
+     * ```
+     */
+    constructor(maxAttempts: number | Provider<number>, computeNextBackoffDelay?: number | RetryBackoffStrategy["computeNextBackoffDelay"]);
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/DefaultRateLimiter.d.ts

@@ -0,0 +1,119 @@
+import { RateLimiter } from "./types";
+/**
+ * @public
+ */
+export interface DefaultRateLimiterOptions {
+    /**
+     * Coefficient for controlling how aggressively the rate decreases on throttle.
+     * @defaultValue 0.7
+     */
+    beta?: number;
+    /**
+     * Minimum token bucket capacity in adaptive-tokens.
+     * @defaultValue 1
+     */
+    minCapacity?: number;
+    /**
+     * Minimum fill rate in adaptive-tokens per second.
+     * @defaultValue 0.5
+     */
+    minFillRate?: number;
+    /**
+     * Scale constant used in the cubic rate calculation.
+     * @defaultValue 0.4
+     */
+    scaleConstant?: number;
+    /**
+     * Smoothing factor for the exponential moving average of the measured send rate.
+     * @defaultValue 0.8
+     */
+    smooth?: number;
+}
+/**
+ * @public
+ */
+export declare class DefaultRateLimiter implements RateLimiter {
+    /**
+     * Only used in testing.
+     */
+    private static setTimeoutFn;
+    private readonly beta;
+    private readonly minCapacity;
+    private readonly minFillRate;
+    private readonly scaleConstant;
+    private readonly smooth;
+    /**
+     * Whether adaptive retry rate limiting is active.
+     * Remains `false` until a throttling error is detected.
+     */
+    private enabled;
+    /**
+     * Current number of available adaptive-tokens. When exhausted, requests wait based on fill rate.
+     */
+    private availableTokens;
+    /**
+     * The most recent maximum fill rate in adaptive-tokens per second, recorded at the last throttle event.
+     */
+    private lastMaxRate;
+    /**
+     * Smoothed measured send rate in requests per second.
+     */
+    private measuredTxRate;
+    /**
+     * Number of requests observed in the current measurement time bucket.
+     */
+    private requestCount;
+    /**
+     * Current token bucket fill rate in adaptive-tokens per second. Defaults to {@link minFillRate}.
+     */
+    private fillRate;
+    /**
+     * Timestamp in seconds of the most recent throttle event.
+     */
+    private lastThrottleTime;
+    /**
+     * Timestamp in seconds of the last token bucket refill.
+     */
+    private lastTimestamp;
+    /**
+     * The time bucket (in seconds) used for measuring the send rate.
+     */
+    private lastTxRateBucket;
+    /**
+     * Maximum token bucket capacity in adaptive-tokens. Defaults to {@link minCapacity}.
+     * Updated in {@link updateTokenBucketRate} to match the new fill rate, floored by {@link minCapacity}.
+     */
+    private maxCapacity;
+    /**
+     * Calculated time window in seconds used in the cubic rate recovery function.
+     */
+    private timeWindow;
+    constructor(options?: DefaultRateLimiterOptions);
+    getSendToken(): Promise<void>;
+    updateClientSendingRate(response: any): void;
+    private getCurrentTimeInSeconds;
+    private acquireTokenBucket;
+    private refillTokenBucket;
+    private calculateTimeWindow;
+    /**
+     * Returns a new fill rate in adaptive-tokens per second by reducing
+     * the given rate by a factor of {@link beta}.
+     */
+    private cubicThrottle;
+    /**
+     * Returns a new fill rate in adaptive-tokens per second using a CUBIC
+     * congestion control curve. The rate recovers toward {@link lastMaxRate},
+     * then continues growing beyond it. The caller caps the result at
+     * `2 * measuredTxRate`.
+     */
+    private cubicSuccess;
+    private enableTokenBucket;
+    /**
+     * Set a new fill rate for adaptive-tokens.
+     * The max capacity is updated to allow for one second of time to approximately
+     * refill the adaptive-token capacity.
+     */
+    private updateTokenBucketRate;
+    private updateMeasuredRate;
+    private getPrecise;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/DefaultRetryBackoffStrategy.d.ts

@@ -0,0 +1,12 @@
+import { StandardRetryBackoffStrategy } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class DefaultRetryBackoffStrategy implements StandardRetryBackoffStrategy {
+    protected x: number;
+    /**
+     * @param i - attempt count starting from zero.
+     */
+    computeNextBackoffDelay(i: number): number;
+    setDelayBase(delay: number): void;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/DefaultRetryToken.d.ts

@@ -0,0 +1,18 @@
+import { StandardRetryToken } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class DefaultRetryToken implements StandardRetryToken {
+    private readonly delay;
+    private readonly count;
+    private readonly cost;
+    private readonly longPoll;
+    $retryLog: {
+        acquisitionDelay: number;
+    };
+    constructor(delay: number, count: number, cost: number | undefined, longPoll: boolean);
+    getRetryCount(): number;
+    getRetryDelay(): number;
+    getRetryCost(): number | undefined;
+    isLongPoll(): boolean;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/StandardRetryStrategy.d.ts

@@ -0,0 +1,56 @@
+import { Provider, RetryErrorInfo, RetryStrategyV2, StandardRetryBackoffStrategy, StandardRetryToken } from "@smithy/types";
+/**
+ * @public
+ */
+export type StandardRetryStrategyOptions = {
+    /**
+     * Maximum number of attempts. If set to 1, no retries will be made.
+     */
+    maxAttempts: number;
+    /**
+     * When present, overrides the base delay for non-throttling retries.
+     */
+    baseDelay?: number;
+    /**
+     * Backoff calculator.
+     */
+    backoff?: StandardRetryBackoffStrategy;
+};
+/**
+ * @public
+ */
+export declare class StandardRetryStrategy implements RetryStrategyV2 {
+    readonly mode: string;
+    protected readonly retryBackoffStrategy: StandardRetryBackoffStrategy;
+    private capacity;
+    private readonly maxAttemptsProvider;
+    private readonly baseDelay;
+    constructor(maxAttempts: number);
+    constructor(maxAttemptsProvider: Provider<number>);
+    constructor(options: StandardRetryStrategyOptions);
+    acquireInitialRetryToken(retryTokenScope: string): Promise<StandardRetryToken>;
+    refreshRetryTokenForRetry(token: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<StandardRetryToken>;
+    recordSuccess(token: StandardRetryToken): void;
+    /**
+     * This number decreases when retries are executed and refills when requests or retries succeed.
+     * @returns the current available retry capacity.
+     */
+    getCapacity(): number;
+    /**
+     * There is an existing integration which accesses this field.
+     * @deprecated
+     */
+    maxAttempts(): Promise<number>;
+    private getMaxAttempts;
+    /**
+     * 0 - OK to retry.
+     * 1 - error is not classified as retryable.
+     * 2 - attempt count exhausted.
+     * 3 - no capacity left (retry tokens exhausted).
+     *
+     * @returns 0 or the number of the highest priority (lowest integer) reason why retry is not possible.
+     */
+    private retryCode;
+    private getCapacityCost;
+    private isRetryableError;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @public
+ */
+export declare enum RETRY_MODES {
+    STANDARD = "standard",
+    ADAPTIVE = "adaptive"
+}
+/**
+ * The default value for how many HTTP requests an SDK should make for a
+ * single SDK operation invocation before giving up
+ *
+ * @public
+ */
+export declare const DEFAULT_MAX_ATTEMPTS = 3;
+/**
+ * The default retry algorithm to use.
+ *
+ * @public
+ */
+export declare const DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/constants.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The base number of milliseconds to use in calculating a suitable cool-down
+ * time when a retryable error is encountered.
+ *
+ * @public
+ */
+export declare const DEFAULT_RETRY_DELAY_BASE = 100;
+/**
+ * The maximum amount of time (in milliseconds) that will be used as a delay
+ * between retry attempts.
+ *
+ * @public
+ */
+export declare const MAXIMUM_RETRY_DELAY: number;
+/**
+ * The retry delay base (in milliseconds) to use when a throttling error is
+ * encountered.
+ *
+ * @public
+ */
+export declare const THROTTLING_RETRY_DELAY_BASE = 500;
+/**
+ * Initial number of retry tokens in Retry Quota
+ *
+ * @public
+ */
+export declare const INITIAL_RETRY_TOKENS = 500;
+/**
+ * The total amount of retry tokens to be decremented from retry token balance.
+ *
+ * @public
+ */
+export declare const RETRY_COST = 5;
+/**
+ * The total amount of retry tokens to be decremented from retry token balance
+ * when a throttling error is encountered.
+ *
+ * @public
+ */
+export declare const TIMEOUT_RETRY_COST = 10;
+/**
+ * The total amount of retry token to be incremented from retry token balance
+ * if an SDK operation invocation succeeds without requiring a retry request.
+ *
+ * @public
+ *
+ */
+export declare const NO_RETRY_INCREMENT = 1;
+/**
+ * Header name for SDK invocation ID
+ *
+ * @public
+ */
+export declare const INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
+/**
+ * Header name for request retry information.
+ *
+ * @public
+ */
+export declare const REQUEST_HEADER = "amz-sdk-request";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/retries-2026-config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @internal
+ */
+export declare abstract class Retry {
+    static v2026: boolean;
+    static delay(): 50 | 100;
+    static throttlingDelay(): 500 | 1000;
+    static cost(): 5 | 14;
+    static throttlingCost(): 5 | 10;
+    static modifiedCostType(): "THROTTLING" | "TRANSIENT";
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/retry/util-retry/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @public
+ */
+export interface RateLimiter {
+    /**
+     * If there is sufficient capacity (tokens) available, it immediately returns.
+     * If there is not sufficient capacity, it will either sleep a certain amount
+     * of time until the rate limiter can retrieve a token from its token bucket
+     * or raise an exception indicating there is insufficient capacity.
+     */
+    getSendToken: () => Promise<void>;
+    /**
+     * Updates the client sending rate based on response.
+     * If the response was successful, the capacity and fill rate are increased.
+     * If the response was a throttling response, the capacity and fill rate are
+     * decreased. Transient errors do not affect the rate limiter.
+     */
+    updateClientSendingRate: (response: any) => void;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/TypeRegistry.d.ts

@@ -0,0 +1,71 @@
+import { Schema as ISchema, StaticErrorSchema } from "@smithy/types";
+import { ErrorSchema } from "./schemas/ErrorSchema";
+/**
+ * A way to look up schema by their ShapeId values.
+ *
+ * @public
+ */
+export declare class TypeRegistry {
+    readonly namespace: string;
+    private schemas;
+    private exceptions;
+    static readonly registries: Map<string, TypeRegistry>;
+    private constructor();
+    /**
+     * @param namespace - specifier.
+     * @returns the schema for that namespace, creating it if necessary.
+     */
+    static for(namespace: string): TypeRegistry;
+    /**
+     * Copies entries from another instance without changing the namespace of self.
+     * The composition is additive but non-destructive and will not overwrite existing entries.
+     *
+     * @param other - another TypeRegistry.
+     */
+    copyFrom(other: TypeRegistry): void;
+    /**
+     * Adds the given schema to a type registry with the same namespace, and this registry.
+     *
+     * @param shapeId - to be registered.
+     * @param schema - to be registered.
+     */
+    register(shapeId: string, schema: ISchema): void;
+    /**
+     * @param shapeId - query.
+     * @returns the schema.
+     */
+    getSchema(shapeId: string): ISchema;
+    /**
+     * Associates an error schema with its constructor.
+     */
+    registerError(es: ErrorSchema | StaticErrorSchema, ctor: any): void;
+    /**
+     * @param es - query.
+     * @returns Error constructor that extends the service's base exception.
+     */
+    getErrorCtor(es: ErrorSchema | StaticErrorSchema): any;
+    /**
+     * 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(): StaticErrorSchema | undefined;
+    /**
+     * @param predicate - criterion.
+     * @returns a schema in this registry matching the predicate.
+     */
+    find(predicate: (schema: ISchema) => boolean): number | "unit" | import("@smithy/types").MemberSchema | import("@smithy/types").NormalizedSchema | StaticErrorSchema | import("@smithy/types").StaticListSchema | import("@smithy/types").StaticMapSchema | import("@smithy/types").StaticOperationSchema | import("@smithy/types").StaticSimpleSchema | import("@smithy/types").StaticStructureSchema | import("@smithy/types").StaticUnionSchema | import("@smithy/types").TraitsSchema | undefined;
+    /**
+     * Unloads the current TypeRegistry.
+     */
+    clear(): void;
+    private normalizeShapeId;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/deref.d.ts

@@ -0,0 +1,6 @@
+import { Schema, SchemaRef } from "@smithy/types";
+/**
+ * Dereferences a SchemaRef if needed.
+ * @internal
+ */
+export declare const deref: (schemaRef: SchemaRef) => Schema;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/index.d.ts

@@ -0,0 +1,14 @@
+export { deref } from "./deref";
+export { deserializerMiddlewareOption, getSchemaSerdePlugin, serializerMiddlewareOption, } from "./middleware/getSchemaSerdePlugin";
+export { ListSchema, list } from "./schemas/ListSchema";
+export { MapSchema, map } from "./schemas/MapSchema";
+export { OperationSchema, op } from "./schemas/OperationSchema";
+export { operation } from "./schemas/operation";
+export { ErrorSchema, error } from "./schemas/ErrorSchema";
+export { NormalizedSchema, isStaticSchema, simpleSchemaCacheN, simpleSchemaCacheS } from "./schemas/NormalizedSchema";
+export { Schema } from "./schemas/Schema";
+export { SimpleSchema, sim, simAdapter } from "./schemas/SimpleSchema";
+export { StructureSchema, struct } from "./schemas/StructureSchema";
+export { SCHEMA } from "./schemas/sentinels";
+export { traitsCache, translateTraits } from "./schemas/translateTraits";
+export { TypeRegistry } from "./TypeRegistry";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/middleware/getSchemaSerdePlugin.d.ts

@@ -0,0 +1,14 @@
+import { DeserializeHandlerOptions, MetadataBearer, Pluggable, SerializeHandlerOptions } from "@smithy/types";
+import { PreviouslyResolved } from "./schema-middleware-types";
+/**
+ * @internal
+ */
+export declare const deserializerMiddlewareOption: DeserializeHandlerOptions;
+/**
+ * @internal
+ */
+export declare const serializerMiddlewareOption: SerializeHandlerOptions;
+/**
+ * @internal
+ */
+export declare function getSchemaSerdePlugin<InputType extends object = any, OutputType extends MetadataBearer = any>(config: PreviouslyResolved): Pluggable<InputType, OutputType>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/middleware/schema-middleware-types.d.ts

@@ -0,0 +1,11 @@
+import { ClientProtocol, SerdeContext, UrlParser } from "@smithy/types";
+/**
+ * @internal
+ */
+export type PreviouslyResolved = Pick<SerdeContext & {
+    urlParser: UrlParser;
+    protocol: ClientProtocol<any, any>;
+}, Exclude<keyof (SerdeContext & {
+    urlParser: UrlParser;
+    protocol: ClientProtocol<any, any>;
+}), "endpoint">>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/middleware/schemaDeserializationMiddleware.d.ts

@@ -0,0 +1,9 @@
+import { DeserializeHandler, DeserializeHandlerArguments, HandlerExecutionContext } from "@smithy/types";
+import { PreviouslyResolved } from "./schema-middleware-types";
+/**
+ * @internal
+ */
+export declare const schemaDeserializationMiddleware: <O>(config: PreviouslyResolved) => (next: DeserializeHandler<any, any>, context: HandlerExecutionContext) => (args: DeserializeHandlerArguments<any>) => Promise<{
+    response: unknown;
+    output: O;
+}>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/middleware/schemaSerializationMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { HandlerExecutionContext, SerializeHandler, SerializeHandlerArguments } from "@smithy/types";
+import { PreviouslyResolved } from "./schema-middleware-types";
+/**
+ * @internal
+ */
+export declare const schemaSerializationMiddleware: (config: PreviouslyResolved) => (next: SerializeHandler<any, any>, context: HandlerExecutionContext) => (args: SerializeHandlerArguments<any>) => Promise<import("@smithy/types").SerializeHandlerOutput<any>>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/ErrorSchema.d.ts

@@ -0,0 +1,37 @@
+import { SchemaRef, SchemaTraits } from "@smithy/types";
+import { StructureSchema } from "./StructureSchema";
+/**
+ * A schema for a structure shape having the error trait. These represent enumerated operation errors.
+ * Because Smithy-TS SDKs use classes for exceptions, whereas plain objects are used for all other data,
+ * and have an existing notion of a XYZServiceBaseException, the ErrorSchema differs from a StructureSchema
+ * by additionally holding the class reference for the corresponding ServiceException class.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare class ErrorSchema extends StructureSchema {
+    static readonly symbol: unique symbol;
+    /**
+     * @deprecated - field unused.
+     */
+    ctor: any;
+    protected readonly symbol: symbol;
+}
+/**
+ * Factory for ErrorSchema, to reduce codegen output and register the schema.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ *
+ * @param namespace - shapeId namespace.
+ * @param name - shapeId name.
+ * @param traits - shape level serde traits.
+ * @param memberNames - list of member names.
+ * @param memberList - list of schemaRef corresponding to each
+ * @param _ctor - class reference for the existing Error extending class.
+ */
+export declare const error: (namespace: string, name: string, traits: SchemaTraits, memberNames: string[], memberList: SchemaRef[], 
+/**
+ * @deprecated - field unused.
+ */
+_ctor?: any) => ErrorSchema;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/schema/schemas/ListSchema.d.ts

@@ -0,0 +1,23 @@
+import { ListSchema as IListSchema, SchemaRef, SchemaTraits } from "@smithy/types";
+import { Schema } from "./Schema";
+/**
+ * A schema with a single member schema.
+ * The deprecated Set type may be represented as a list.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare class ListSchema extends Schema implements IListSchema {
+    static readonly symbol: unique symbol;
+    name: string;
+    traits: SchemaTraits;
+    valueSchema: SchemaRef;
+    protected readonly symbol: symbol;
+}
+/**
+ * Factory for ListSchema.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+export declare const list: (namespace: string, name: string, traits: SchemaTraits, valueSchema: SchemaRef) => ListSchema;