@aws-amplify/graphql-api-construct 1.19.1 → 1.20.0

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/parse-utils.d.ts

@@ -0,0 +1,270 @@
+/**
+ * @internal
+ *
+ * Give an input string, strictly parses a boolean value.
+ *
+ * @param value - The boolean string to parse.
+ * @returns true for "true", false for "false", otherwise an error is thrown.
+ */
+export declare const parseBoolean: (value: string) => boolean;
+/**
+ * @internal
+ *
+ * Asserts a value is a boolean and returns it.
+ * Casts strings and numbers with a warning if there is evidence that they were
+ * intended to be booleans.
+ *
+ * @param value - A value that is expected to be a boolean.
+ * @returns The value if it's a boolean, undefined if it's null/undefined,
+ *   otherwise an error is thrown.
+ */
+export declare const expectBoolean: (value: any) => boolean | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is a number and returns it.
+ * Casts strings with a warning if the string is a parseable number.
+ * This is to unblock slight API definition/implementation inconsistencies.
+ *
+ * @param value - A value that is expected to be a number.
+ * @returns The value if it's a number, undefined if it's null/undefined,
+ *   otherwise an error is thrown.
+ */
+export declare const expectNumber: (value: any) => number | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is a 32-bit float and returns it.
+ *
+ * @param value - A value that is expected to be a 32-bit float.
+ * @returns The value if it's a float, undefined if it's null/undefined,
+ *   otherwise an error is thrown.
+ */
+export declare const expectFloat32: (value: any) => number | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is an integer and returns it.
+ *
+ * @param value - A value that is expected to be an integer.
+ * @returns The value if it's an integer, undefined if it's null/undefined,
+ *   otherwise an error is thrown.
+ */
+export declare const expectLong: (value: any) => number | undefined;
+/**
+ * @internal
+ *
+ * @deprecated Use expectLong
+ */
+export declare const expectInt: (value: any) => number | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is a 32-bit integer and returns it.
+ *
+ * @param value - A value that is expected to be an integer.
+ * @returns The value if it's an integer, undefined if it's null/undefined,
+ *   otherwise an error is thrown.
+ */
+export declare const expectInt32: (value: any) => number | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is a 16-bit integer and returns it.
+ *
+ * @param value - A value that is expected to be an integer.
+ * @returns The value if it's an integer, undefined if it's null/undefined,
+ *   otherwise an error is thrown.
+ */
+export declare const expectShort: (value: any) => number | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is an 8-bit integer and returns it.
+ *
+ * @param value - A value that is expected to be an integer.
+ * @returns The value if it's an integer, undefined if it's null/undefined,
+ *   otherwise an error is thrown.
+ */
+export declare const expectByte: (value: any) => number | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is not null or undefined and returns it, or throws an error.
+ *
+ * @param value - A value that is expected to be defined
+ * @param location - The location where we're expecting to find a defined object (optional)
+ * @returns The value if it's not undefined, otherwise throws an error
+ */
+export declare const expectNonNull: <T>(value: T | null | undefined, location?: string) => T;
+/**
+ * @internal
+ *
+ * Asserts a value is an JSON-like object and returns it. This is expected to be used
+ * with values parsed from JSON (arrays, objects, numbers, strings, booleans).
+ *
+ * @param value - A value that is expected to be an object
+ * @returns The value if it's an object, undefined if it's null/undefined,
+ *   otherwise an error is thrown.
+ */
+export declare const expectObject: (value: any) => Record<string, any> | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is a string and returns it.
+ * Numbers and boolean will be cast to strings with a warning.
+ *
+ * @param value - A value that is expected to be a string.
+ * @returns The value if it's a string, undefined if it's null/undefined,
+ *   otherwise an error is thrown.
+ */
+export declare const expectString: (value: any) => string | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is a JSON-like object with only one non-null/non-undefined key and
+ * returns it.
+ *
+ * @param value - A value that is expected to be an object with exactly one non-null,
+ *              non-undefined key.
+ * @returns the value if it's a union, undefined if it's null/undefined, otherwise
+ *  an error is thrown.
+ */
+export declare const expectUnion: (value: unknown) => Record<string, any> | undefined;
+/**
+ * @internal
+ *
+ * Parses a value into a double. If the value is null or undefined, undefined
+ * will be returned. If the value is a string, it will be parsed by the standard
+ * parseFloat with one exception: NaN may only be explicitly set as the string
+ * "NaN", any implicit Nan values will result in an error being thrown. If any
+ * other type is provided, an exception will be thrown.
+ *
+ * @param value - A number or string representation of a double.
+ * @returns The value as a number, or undefined if it's null/undefined.
+ */
+export declare const strictParseDouble: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * @deprecated Use strictParseDouble
+ */
+export declare const strictParseFloat: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * Parses a value into a float. If the value is null or undefined, undefined
+ * will be returned. If the value is a string, it will be parsed by the standard
+ * parseFloat with one exception: NaN may only be explicitly set as the string
+ * "NaN", any implicit Nan values will result in an error being thrown. If any
+ * other type is provided, an exception will be thrown.
+ *
+ * @param value - A number or string representation of a float.
+ * @returns The value as a number, or undefined if it's null/undefined.
+ */
+export declare const strictParseFloat32: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is a number and returns it. If the value is a string
+ * representation of a non-numeric number type (NaN, Infinity, -Infinity),
+ * the value will be parsed. Any other string value will result in an exception
+ * being thrown. Null or undefined will be returned as undefined. Any other
+ * type will result in an exception being thrown.
+ *
+ * @param value - A number or string representation of a non-numeric float.
+ * @returns The value as a number, or undefined if it's null/undefined.
+ */
+export declare const limitedParseDouble: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * @deprecated Use limitedParseDouble
+ */
+export declare const handleFloat: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * @deprecated Use limitedParseDouble
+ */
+export declare const limitedParseFloat: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * Asserts a value is a 32-bit float and returns it. If the value is a string
+ * representation of a non-numeric number type (NaN, Infinity, -Infinity),
+ * the value will be parsed. Any other string value will result in an exception
+ * being thrown. Null or undefined will be returned as undefined. Any other
+ * type will result in an exception being thrown.
+ *
+ * @param value - A number or string representation of a non-numeric float.
+ * @returns The value as a number, or undefined if it's null/undefined.
+ */
+export declare const limitedParseFloat32: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * Parses a value into an integer. If the value is null or undefined, undefined
+ * will be returned. If the value is a string, it will be parsed by parseFloat
+ * and the result will be asserted to be an integer. If the parsed value is not
+ * an integer, or the raw value is any type other than a string or number, an
+ * exception will be thrown.
+ *
+ * @param value - A number or string representation of an integer.
+ * @returns The value as a number, or undefined if it's null/undefined.
+ */
+export declare const strictParseLong: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * @deprecated Use strictParseLong
+ */
+export declare const strictParseInt: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * Parses a value into a 32-bit integer. If the value is null or undefined, undefined
+ * will be returned. If the value is a string, it will be parsed by parseFloat
+ * and the result will be asserted to be an integer. If the parsed value is not
+ * an integer, or the raw value is any type other than a string or number, an
+ * exception will be thrown.
+ *
+ * @param value - A number or string representation of a 32-bit integer.
+ * @returns The value as a number, or undefined if it's null/undefined.
+ */
+export declare const strictParseInt32: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * Parses a value into a 16-bit integer. If the value is null or undefined, undefined
+ * will be returned. If the value is a string, it will be parsed by parseFloat
+ * and the result will be asserted to be an integer. If the parsed value is not
+ * an integer, or the raw value is any type other than a string or number, an
+ * exception will be thrown.
+ *
+ * @param value - A number or string representation of a 16-bit integer.
+ * @returns The value as a number, or undefined if it's null/undefined.
+ */
+export declare const strictParseShort: (value: string | number) => number | undefined;
+/**
+ * @internal
+ *
+ * Parses a value into an 8-bit integer. If the value is null or undefined, undefined
+ * will be returned. If the value is a string, it will be parsed by parseFloat
+ * and the result will be asserted to be an integer. If the parsed value is not
+ * an integer, or the raw value is any type other than a string or number, an
+ * exception will be thrown.
+ *
+ * @param value - A number or string representation of an 8-bit integer.
+ * @returns The value as a number, or undefined if it's null/undefined.
+ */
+export declare const strictParseByte: (value: string | number) => number | undefined;
+/**
+ * @internal
+ */
+export declare const logger: {
+    warn: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+};

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/quote-header.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @public
+ * @param part - header list element
+ * @returns quoted string if part contains delimiter.
+ */
+export declare function quoteHeader(part: string): string;

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/resolve-path.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ * Backwards compatibility re-export.
+ */
+export { resolvedPath } from "@smithy/core/protocols";

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ser-utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @internal
+ *
+ * Serializes a number, turning non-numeric values into strings.
+ *
+ * @param value - The number to serialize.
+ * @returns A number, or a string if the given number was non-numeric.
+ */
+export declare const serializeFloat: (value: number) => string | number;
+/**
+ * @internal
+ * @param date - to be serialized.
+ * @returns https://smithy.io/2.0/spec/protocol-traits.html#timestampformat-trait date-time format.
+ */
+export declare const serializeDateTime: (date: Date) => string;

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/serde-json.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @internal
+ *
+ * Maps an object through the default JSON serde behavior.
+ * This means removing nullish fields and un-sparsifying lists.
+ *
+ * This is also used by Smithy RPCv2 CBOR as the default serde behavior.
+ *
+ * @param obj - to be checked.
+ * @returns same object with default serde behavior applied.
+ */
+export declare const _json: (obj: any) => any;

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/split-every.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @internal
+ *
+ * Given an input string, splits based on the delimiter after a given
+ * number of delimiters has been encountered.
+ *
+ * @param value - The input string to split.
+ * @param delimiter - The delimiter to split on.
+ * @param numDelimiters - The number of delimiters to have encountered to split.
+ */
+export declare function splitEvery(value: string, delimiter: string, numDelimiters: number): Array<string>;

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/split-header.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param value - header string value.
+ * @returns value split by commas that aren't in quotes.
+ */
+export declare const splitHeader: (value: string) => string[];

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/NoOpLogger.d.ts

@@ -0,0 +1,11 @@
+import { Logger } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class NoOpLogger implements Logger {
+    trace(): void;
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/client.d.ts

@@ -0,0 +1,61 @@
+import { Client as IClient, Command, FetchHttpHandlerOptions, MetadataBearer, MiddlewareStack, NodeHttpHandlerOptions, RequestHandler } from "@smithy/types";
+/**
+ * @public
+ */
+export interface SmithyConfiguration<HandlerOptions> {
+    requestHandler: RequestHandler<any, any, HandlerOptions> | NodeHttpHandlerOptions | FetchHttpHandlerOptions | Record<string, unknown>;
+    /**
+     * The API version set internally by the SDK, and is
+     * not planned to be used by customer code.
+     * @internal
+     */
+    readonly apiVersion: string;
+    /**
+     * @public
+     *
+     * Default false.
+     *
+     * When true, the client will only resolve the middleware stack once per
+     * Command class. This means modifying the middlewareStack of the
+     * command or client after requests have been made will not be
+     * recognized.
+     *
+     * Calling client.destroy() also clears this cache.
+     *
+     * Enable this only if needing the additional time saved (0-1ms per request)
+     * and not needing middleware modifications between requests.
+     */
+    cacheMiddleware?: boolean;
+}
+/**
+ * @internal
+ */
+export type SmithyResolvedConfiguration<HandlerOptions> = {
+    requestHandler: RequestHandler<any, any, HandlerOptions>;
+    readonly apiVersion: string;
+    cacheMiddleware?: boolean;
+};
+/**
+ * @public
+ */
+export declare class Client<HandlerOptions, ClientInput extends object, ClientOutput extends MetadataBearer, ResolvedClientConfiguration extends SmithyResolvedConfiguration<HandlerOptions>> implements IClient<ClientInput, ClientOutput, ResolvedClientConfiguration> {
+    readonly config: ResolvedClientConfiguration;
+    middlewareStack: MiddlewareStack<ClientInput, ClientOutput>;
+    /**
+     * Holds an object reference to the initial configuration object.
+     * Used to check that the config resolver stack does not create
+     * dangling instances of an intermediate form of the configuration object.
+     *
+     * @internal
+     */
+    initConfig?: object;
+    /**
+     * May be used to cache the resolved handler function for a Command class.
+     */
+    private handlers?;
+    constructor(config: ResolvedClientConfiguration);
+    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, options?: HandlerOptions): Promise<OutputType>;
+    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, cb: (err: any, data?: OutputType) => void): void;
+    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, options: HandlerOptions, cb: (err: any, data?: OutputType) => void): void;
+    destroy(): void;
+}

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/collect-stream-body.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ * Backwards compatibility re-export.
+ */
+export { collectBody } from "@smithy/core/protocols";

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/command.d.ts

@@ -0,0 +1,113 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as ICommand, Handler, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, Logger, MetadataBearer, MiddlewareStack as IMiddlewareStack, OptionalParameter, Pluggable, RequestHandler, SerdeContext } from "@smithy/types";
+/**
+ * @public
+ */
+export declare abstract class Command<Input extends ClientInput, Output extends ClientOutput, ResolvedClientConfiguration, ClientInput extends object = any, ClientOutput extends MetadataBearer = any> implements ICommand<ClientInput, Input, ClientOutput, Output, ResolvedClientConfiguration> {
+    abstract input: Input;
+    readonly middlewareStack: IMiddlewareStack<Input, Output>;
+    /**
+     * Factory for Command ClassBuilder.
+     * @internal
+     */
+    static classBuilder<I extends SI, O extends SO, C extends {
+        logger: Logger;
+        requestHandler: RequestHandler<any, any, any>;
+    }, SI extends object = any, SO extends MetadataBearer = any>(): ClassBuilder<I, O, C, SI, SO>;
+    abstract resolveMiddleware(stack: IMiddlewareStack<ClientInput, ClientOutput>, configuration: ResolvedClientConfiguration, options: any): Handler<Input, Output>;
+    /**
+     * @internal
+     */
+    resolveMiddlewareWithContext(clientStack: IMiddlewareStack<any, any>, configuration: {
+        logger: Logger;
+        requestHandler: RequestHandler<any, any, any>;
+    }, options: any, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor, }: ResolveMiddlewareContextArgs): import("@smithy/types").InitializeHandler<any, Output>;
+}
+/**
+ * @internal
+ */
+type ResolveMiddlewareContextArgs = {
+    middlewareFn: (CommandCtor: any, clientStack: any, config: any, options: any) => Pluggable<any, any>[];
+    clientName: string;
+    commandName: string;
+    smithyContext: Record<string, unknown>;
+    additionalContext: HandlerExecutionContext;
+    inputFilterSensitiveLog: (_: any) => any;
+    outputFilterSensitiveLog: (_: any) => any;
+    CommandCtor: any;
+};
+/**
+ * @internal
+ */
+declare class ClassBuilder<I extends SI, O extends SO, C extends {
+    logger: Logger;
+    requestHandler: RequestHandler<any, any, any>;
+}, SI extends object = any, SO extends MetadataBearer = any> {
+    private _init;
+    private _ep;
+    private _middlewareFn;
+    private _commandName;
+    private _clientName;
+    private _additionalContext;
+    private _smithyContext;
+    private _inputFilterSensitiveLog;
+    private _outputFilterSensitiveLog;
+    private _serializer;
+    private _deserializer;
+    /**
+     * Optional init callback.
+     */
+    init(cb: (_: Command<I, O, C, SI, SO>) => void): void;
+    /**
+     * Set the endpoint parameter instructions.
+     */
+    ep(endpointParameterInstructions: EndpointParameterInstructions): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Add any number of middleware.
+     */
+    m(middlewareSupplier: (CommandCtor: any, clientStack: any, config: any, options: any) => Pluggable<any, any>[]): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Set the initial handler execution context Smithy field.
+     */
+    s(service: string, operation: string, smithyContext?: Record<string, unknown>): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Set the initial handler execution context.
+     */
+    c(additionalContext?: HandlerExecutionContext): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Set constant string identifiers for the operation.
+     */
+    n(clientName: string, commandName: string): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Set the input and output sensistive log filters.
+     */
+    f(inputFilter?: (_: any) => any, outputFilter?: (_: any) => any): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Sets the serializer.
+     */
+    ser(serializer: (input: I, context?: SerdeContext | any) => Promise<IHttpRequest>): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * Sets the deserializer.
+     */
+    de(deserializer: (output: IHttpResponse, context?: SerdeContext | any) => Promise<O>): ClassBuilder<I, O, C, SI, SO>;
+    /**
+     * @returns a Command class with the classBuilder properties.
+     */
+    build(): {
+        new (input: I): CommandImpl<I, O, C, SI, SO>;
+        new (...[input]: OptionalParameter<I>): CommandImpl<I, O, C, SI, SO>;
+        getEndpointParameterInstructions(): EndpointParameterInstructions;
+    };
+}
+/**
+ * A concrete implementation of ICommand with no abstract members.
+ * @public
+ */
+export interface CommandImpl<I extends SI, O extends SO, C extends {
+    logger: Logger;
+    requestHandler: RequestHandler<any, any, any>;
+}, SI extends object = any, SO extends MetadataBearer = any> extends Command<I, O, C, SI, SO> {
+    readonly input: I;
+    resolveMiddleware(stack: IMiddlewareStack<SI, SO>, configuration: C, options: any): Handler<I, O>;
+}
+export {};

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare const SENSITIVE_STRING = "***SensitiveInformation***";

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/create-aggregated-client.d.ts

@@ -0,0 +1,9 @@
+import { Client } from "./client";
+/**
+ * @internal
+ *
+ * @param commands - command lookup container.
+ * @param client - client instance on which to add aggregated methods.
+ * @returns an aggregated client with dynamically created methods.
+ */
+export declare const createAggregatedClient: (commands: Record<string, any>, Client: new (...args: any) => Client<any, any, any, any>) => void;

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/date-utils.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @internal
+ *
+ * Builds a proper UTC HttpDate timestamp from a Date object
+ * since not all environments will have this as the expected
+ * format.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString}
+ * - Prior to ECMAScript 2018, the format of the return value
+ * - varied according to the platform. The most common return
+ * - value was an RFC-1123 formatted date stamp, which is a
+ * - slightly updated version of RFC-822 date stamps.
+ */
+export declare function dateToUtcString(date: Date): string;
+/**
+ * @internal
+ *
+ * Parses a value into a Date. Returns undefined if the input is null or
+ * undefined, throws an error if the input is not a string that can be parsed
+ * as an RFC 3339 date.
+ *
+ * Input strings must conform to RFC3339 section 5.6, and cannot have a UTC
+ * offset. Fractional precision is supported.
+ *
+ * @see {@link https://xml2rfc.tools.ietf.org/public/rfc/html/rfc3339.html#anchor14}
+ *
+ * @param value - the value to parse
+ * @returns a Date or undefined
+ */
+export declare const parseRfc3339DateTime: (value: unknown) => Date | undefined;
+/**
+ * @internal
+ *
+ * Parses a value into a Date. Returns undefined if the input is null or
+ * undefined, throws an error if the input is not a string that can be parsed
+ * as an RFC 3339 date.
+ *
+ * Input strings must conform to RFC3339 section 5.6, and can have a UTC
+ * offset. Fractional precision is supported.
+ *
+ * @see {@link https://xml2rfc.tools.ietf.org/public/rfc/html/rfc3339.html#anchor14}
+ *
+ * @param value - the value to parse
+ * @returns a Date or undefined
+ */
+export declare const parseRfc3339DateTimeWithOffset: (value: unknown) => Date | undefined;
+/**
+ * @internal
+ *
+ * Parses a value into a Date. Returns undefined if the input is null or
+ * undefined, throws an error if the input is not a string that can be parsed
+ * as an RFC 7231 IMF-fixdate or obs-date.
+ *
+ * Input strings must conform to RFC7231 section 7.1.1.1. Fractional seconds are supported.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7231.html#section-7.1.1.1}
+ *
+ * @param value - the value to parse
+ * @returns a Date or undefined
+ */
+export declare const parseRfc7231DateTime: (value: unknown) => Date | undefined;
+/**
+ * @internal
+ *
+ * Parses a value into a Date. Returns undefined if the input is null or
+ * undefined, throws an error if the input is not a number or a parseable string.
+ *
+ * Input strings must be an integer or floating point number. Fractional seconds are supported.
+ *
+ * @param value - the value to parse
+ * @returns a Date or undefined
+ */
+export declare const parseEpochTimestamp: (value: unknown) => Date | undefined;

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/default-error-handler.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Always throws an error with the given `exceptionCtor` and other arguments.
+ * This is only called from an error handling code path.
+ *
+ * @internal
+ */
+export declare const throwDefaultError: ({ output, parsedBody, exceptionCtor, errorCode }: any) => never;
+/**
+ * @internal
+ *
+ * Creates {@link throwDefaultError} with bound ExceptionCtor.
+ */
+export declare const withBaseException: (ExceptionCtor: new (...args: any) => any) => any;

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/defaults-mode.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @internal
+ */
+export declare const loadConfigsForDefaultMode: (mode: ResolvedDefaultsMode) => DefaultsModeConfigs;
+/**
+ * Option determining how certain default configuration options are resolved in the SDK. It can be one of the value listed below:
+ * * `"standard"`: <p>The STANDARD mode provides the latest recommended default values that should be safe to run in most scenarios</p><p>Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK</p>
+ * * `"in-region"`: <p>The IN_REGION mode builds on the standard mode and includes optimization tailored for applications which call AWS services from within the same AWS region</p><p>Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK</p>
+ * * `"cross-region"`: <p>The CROSS_REGION mode builds on the standard mode and includes optimization tailored for applications which call AWS services in a different region</p><p>Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK</p>
+ * * `"mobile"`: <p>The MOBILE mode builds on the standard mode and includes optimization tailored for mobile applications</p><p>Note that the default values vended from this mode might change as best practices may evolve. As a result, it is encouraged to perform tests when upgrading the SDK</p>
+ * * `"auto"`: <p>The AUTO mode is an experimental mode that builds on the standard mode. The SDK will attempt to discover the execution environment to determine the appropriate settings automatically.</p><p>Note that the auto detection is heuristics-based and does not guarantee 100% accuracy. STANDARD mode will be used if the execution environment cannot be determined. The auto detection might query <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html">EC2 Instance Metadata service</a>, which might introduce latency. Therefore we recommend choosing an explicit defaults_mode instead if startup latency is critical to your application</p>
+ * * `"legacy"`: <p>The LEGACY mode provides default settings that vary per SDK and were used prior to establishment of defaults_mode</p>
+ *
+ * @defaultValue "legacy"
+ */
+export type DefaultsMode = "standard" | "in-region" | "cross-region" | "mobile" | "auto" | "legacy";
+/**
+ * @internal
+ */
+export type ResolvedDefaultsMode = Exclude<DefaultsMode, "auto">;
+/**
+ * @internal
+ */
+export interface DefaultsModeConfigs {
+    retryMode?: string;
+    connectionTimeout?: number;
+    requestTimeout?: number;
+}

package/node_modules/@aws-sdk/client-sts/node_modules/@smithy/smithy-client/dist-types/ts3.4/emitWarningIfUnsupportedVersion.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ *
+ * Emits warning if the provided Node.js version string is pending deprecation.
+ *
+ * @param version - The Node.js version string.
+ */
+export declare const emitWarningIfUnsupportedVersion: (version: string) => void;