@cdklabs/cdk-ssm-documents 0.0.68 → 0.0.69

package/node_modules/@smithy/types/dist-types/index.d.ts

@@ -1,44 +1,52 @@
-export * from "./abort";
-export * from "./auth";
-export * from "./blob/blob-payload-input-types";
-export * from "./checksum";
-export * from "./client";
-export * from "./command";
-export * from "./connection";
-export * from "./crypto";
-export * from "./encode";
-export * from "./endpoint";
-export * from "./endpoints";
+export type { AbortController, AbortHandler, AbortSignal } from "./abort";
+export { HttpApiKeyAuthLocation, HttpAuthLocation } from "./auth";
+export type { AuthScheme, ErrorHandler, HttpAuthDefinition, HttpAuthOption, HttpAuthScheme, HttpAuthSchemeId, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, HttpSigner, IdentityProviderConfig, SelectedHttpAuthScheme, SuccessHandler, } from "./auth";
+export type { BlobPayloadInputTypes, BlobTypes, BrowserRuntimeBlobTypes, NodeJsRuntimeBlobTypes, } from "./blob/blob-payload-input-types";
+export type { Checksum, ChecksumConstructor } from "./checksum";
+export type { CheckOptionalClientConfig, Client, InvokeFunction, InvokeMethod, InvokeMethodOptionalArgs, } from "./client";
+export type { Command, CommandIO, GetOutputType } from "./command";
+export type { CacheKey, ConnectConfiguration, ConnectionManager, ConnectionManagerConfiguration, ConnectionPool, } from "./connection";
+export type { Hash, HashConstructor, SourceData, StreamHasher, randomValues } from "./crypto";
+export type { AvailableMessage, AvailableMessages, MessageDecoder, MessageEncoder } from "./encode";
+export { EndpointURLScheme } from "./endpoint";
+export type { EndpointARN, EndpointObjectProperty, EndpointParameters, EndpointPartition, EndpointURL, EndpointV2, } from "./endpoint";
+export type { ConditionObject, DeprecatedObject, EndpointObject, EndpointObjectHeaders, EndpointObjectProperties, EndpointParams, EndpointResolverOptions, EndpointRuleObject, ErrorRuleObject, EvaluateOptions, Expression, FunctionArgv, FunctionObject, FunctionReturn, ParameterObject, ReferenceObject, ReferenceRecord, RuleSetObject, RuleSetRules, TreeRuleObject, } from "./endpoints";
 export type { EndpointParameterInstructions, BuiltInParamInstruction, ClientContextParamInstruction, StaticContextParamInstruction, ContextParamInstruction, OperationContextParamInstruction, } from "./endpoints/EndpointParameterInstructions";
-export * from "./eventStream";
-export * from "./extensions";
-export * from "./feature-ids";
-export * from "./http";
-export * from "./http/httpHandlerInitialization";
-export * from "./identity";
-export * from "./logger";
-export * from "./middleware";
-export * from "./pagination";
-export * from "./profile";
-export * from "./response";
-export * from "./retry";
-export * from "./schema/schema";
-export * from "./schema/traits";
-export * from "./schema/schema-deprecated";
-export * from "./schema/sentinels";
-export * from "./schema/static-schemas";
-export * from "./serde";
-export * from "./shapes";
-export * from "./signature";
-export * from "./stream";
-export * from "./streaming-payload/streaming-blob-common-types";
-export * from "./streaming-payload/streaming-blob-payload-input-types";
-export * from "./streaming-payload/streaming-blob-payload-output-types";
-export * from "./transfer";
-export * from "./transform/client-payload-blob-type-narrow";
-export * from "./transform/mutable";
-export * from "./transform/no-undefined";
-export * from "./transform/type-transform";
-export * from "./uri";
-export * from "./util";
-export * from "./waiter";
+export type { BinaryHeaderValue, BooleanHeaderValue, ByteHeaderValue, EventStreamMarshaller, EventStreamMarshallerDeserFn, EventStreamMarshallerSerFn, EventStreamPayloadHandler, EventStreamPayloadHandlerProvider, EventStreamRequestSigner, EventStreamSerdeContext, EventStreamSerdeProvider, EventStreamSignerProvider, HeaderValue, Int64, IntegerHeaderValue, LongHeaderValue, Message, MessageHeaderValue, MessageHeaders, ShortHeaderValue, StringHeaderValue, TimestampHeaderValue, UuidHeaderValue, } from "./eventStream";
+export { AlgorithmId, getDefaultClientConfiguration, resolveDefaultRuntimeConfig } from "./extensions";
+export type { ChecksumAlgorithm, ChecksumConfiguration, DefaultClientConfiguration, DefaultExtensionConfiguration, RetryStrategyConfiguration, } from "./extensions";
+export type { SmithyFeatures } from "./feature-ids";
+export { FieldPosition } from "./http";
+export type { Endpoint, FieldOptions, HeaderBag, HttpHandlerOptions, HttpMessage, HttpRequest, HttpResponse, QueryParameterBag, } from "./http";
+export type { FetchHttpHandlerOptions, NodeHttpHandlerOptions, RequestHandlerParams, } from "./http/httpHandlerInitialization";
+export type { ApiKeyIdentity, ApiKeyIdentityProvider, AwsCredentialIdentity, AwsCredentialIdentityProvider, Identity, IdentityProvider, TokenIdentity, TokenIdentityProvider, } from "./identity";
+export type { Logger } from "./logger";
+export { SMITHY_CONTEXT_KEY } from "./middleware";
+export type { AbsoluteLocation, BuildHandler, BuildHandlerArguments, BuildHandlerOptions, BuildHandlerOutput, BuildMiddleware, DeserializeHandler, DeserializeHandlerArguments, DeserializeHandlerOptions, DeserializeHandlerOutput, DeserializeMiddleware, FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, FinalizeRequestHandlerOptions, FinalizeRequestMiddleware, Handler, HandlerExecutionContext, HandlerOptions, InitializeHandler, InitializeHandlerArguments, InitializeHandlerOptions, InitializeHandlerOutput, InitializeMiddleware, MiddlewareStack, MiddlewareType, Pluggable, Priority, Relation, RelativeLocation, RelativeMiddlewareOptions, SerializeHandler, SerializeHandlerArguments, SerializeHandlerOptions, SerializeHandlerOutput, SerializeMiddleware, Step, Terminalware, } from "./middleware";
+export type { PaginationConfiguration, Paginator } from "./pagination";
+export { IniSectionType } from "./profile";
+export type { IniSection, ParsedIniData, Profile, SharedConfigFiles } from "./profile";
+export type { MetadataBearer, ResponseMetadata } from "./response";
+export type { ExponentialBackoffJitterType, ExponentialBackoffStrategyOptions, RetryBackoffStrategy, RetryErrorInfo, RetryErrorType, RetryStrategyOptions, RetryStrategyV2, RetryToken, StandardRetryBackoffStrategy, StandardRetryToken, } from "./retry";
+export type { $ClientProtocol, $ClientProtocolCtor, $Codec, $MemberSchema, $OperationSchema, $Schema, $SchemaRef, $ShapeDeserializer, $ShapeSerializer, BlobSchemas, CodecSettings, ConfigurableSerdeContext, NormalizedSchema, SchemaTraits, SchemaTraitsObject, SimpleSchema, TimestampSchemas, UnitSchema, } from "./schema/schema";
+export type { HttpLabelBitMask, HttpPayloadBitMask, HttpQueryParamsBitMask, HttpResponseCodeBitMask, IdempotencyTokenBitMask, IdempotentBitMask, SensitiveBitMask, TraitBitVector, } from "./schema/traits";
+export type { ClientProtocol, ClientProtocolCtor, Codec, ListSchema, MapSchema, MemberSchema, OperationSchema, Schema, SchemaRef, ShapeDeserializer, ShapeSerializer, StructureSchema, TraitsSchema, } from "./schema/schema-deprecated";
+export type { BigDecimalSchema, BigIntegerSchema, BlobSchema, BooleanSchema, DocumentSchema, ListSchemaModifier, MapSchemaModifier, NumericSchema, StreamingBlobSchema, StringSchema, TimestampDateTimeSchema, TimestampDefaultSchema, TimestampEpochSecondsSchema, TimestampHttpDateSchema, } from "./schema/sentinels";
+export type { ShapeName, ShapeNamespace, StaticErrorSchema, StaticListSchema, StaticMapSchema, StaticOperationSchema, StaticSchema, StaticSchemaIdError, StaticSchemaIdList, StaticSchemaIdMap, StaticSchemaIdOperation, StaticSchemaIdSimple, StaticSchemaIdStruct, StaticSchemaIdUnion, StaticSimpleSchema, StaticStructureSchema, StaticUnionSchema, } from "./schema/static-schemas";
+export type { EndpointBearer, RequestSerializer, ResponseDeserializer, SdkStream, SdkStreamMixin, SdkStreamMixinInjector, SdkStreamSerdeContext, SerdeContext, SerdeFunctions, StreamCollector, WithSdkStreamMixin, } from "./serde";
+export type { DocumentType, RetryableTrait, SdkError, SmithyException } from "./shapes";
+export type { DateInput, EventSigner, EventSigningArguments, EventStreamRequestScopedCredentials, FormattedEvent, MessageSigner, MessageSigningArguments, RequestPresigner, RequestPresigningArguments, RequestSigner, RequestSigningArguments, SignableMessage, SignedMessage, SigningArguments, StringSigner, } from "./signature";
+export type { GetAwsChunkedEncodingStream, GetAwsChunkedEncodingStreamOptions } from "./stream";
+export type { BrowserRuntimeStreamingBlobTypes, NodeJsRuntimeStreamingBlobTypes, StreamingBlobTypes, } from "./streaming-payload/streaming-blob-common-types";
+export type { BrowserRuntimeStreamingBlobPayloadInputTypes, NodeJsRuntimeStreamingBlobPayloadInputTypes, StreamingBlobPayloadInputTypes, } from "./streaming-payload/streaming-blob-payload-input-types";
+export type { BrowserRuntimeStreamingBlobPayloadOutputTypes, NodeJsRuntimeStreamingBlobPayloadOutputTypes, StreamingBlobPayloadOutputTypes, } from "./streaming-payload/streaming-blob-payload-output-types";
+export { RequestHandlerProtocol } from "./transfer";
+export type { RequestContext, RequestHandler, RequestHandlerMetadata, RequestHandlerOutput } from "./transfer";
+export type { BrowserClient, BrowserXhrClient, NarrowPayloadBlobOutputType, NarrowPayloadBlobTypes, NodeJsClient, NodeJsHttp2Client, } from "./transform/client-payload-blob-type-narrow";
+export type { Mutable } from "./transform/mutable";
+export type { AssertiveClient, NoUndefined, RecursiveRequired, UncheckedClient } from "./transform/no-undefined";
+export type { Transform } from "./transform/type-transform";
+export type { URI } from "./uri";
+export type { BodyLengthCalculator, Decoder, Encoder, Exact, MemoizedProvider, OptionalParameter, Provider, RegionInfo, RegionInfoProvider, RegionInfoProviderOptions, RetryStrategy, UrlParser, UserAgent, UserAgentPair, } from "./util";
+export type { WaiterConfiguration } from "./waiter";
+export type { MetricsRecorder, MetricsRecorderFactory, MetricUnit, RequestOutcome } from "./metrics";

package/node_modules/@smithy/types/dist-types/metrics.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Outcome of a request, recorded by the framework via {@link MetricsRecorder.recordRequestOutcome}.
+ *
+ * @public
+ */
+export type RequestOutcome = "Success" | "Fault";
+/**
+ * Unit attached to a recorded metric value. The vocabulary follows the
+ * CloudWatch unit names so backends that emit to CloudWatch can pass it
+ * through, but it carries no backend-specific semantics — a recorder is free
+ * to map or ignore it.
+ *
+ * @public
+ */
+export type MetricUnit = "Seconds" | "Microseconds" | "Milliseconds" | "Bytes" | "Kilobytes" | "Megabytes" | "Gigabytes" | "Terabytes" | "Bits" | "Kilobits" | "Megabits" | "Gigabits" | "Terabits" | "Percent" | "Count" | "None" | "Bytes/Second" | "Kilobytes/Second" | "Megabytes/Second" | "Gigabytes/Second" | "Terabytes/Second" | "Bits/Second" | "Kilobits/Second" | "Megabits/Second" | "Gigabits/Second" | "Terabits/Second" | "Count/Second";
+/**
+ * Backend-agnostic recorder for per-request metrics. The framework drives the
+ * lifecycle and records request-level metrics through this interface; user
+ * handlers record their own business metrics through the same methods. Concrete
+ * recorders (e.g. an EMF recorder, or a future OpenTelemetry recorder) translate
+ * these abstract calls into their own primitives.
+ *
+ * @typeParam Native - the concrete backend handle returned by
+ *   {@link MetricsRecorder.getMetrics}, e.g. an OpenTelemetry `Meter`. The
+ *   parameter is required so that native access is always typed rather than
+ *   erased to `unknown`.
+ *
+ * @public
+ */
+export interface MetricsRecorder<Native> {
+    /**
+     * Open the recorder for the current request. Called by the framework once at
+     * the start of request handling.
+     */
+    begin(): void;
+    /**
+     * Close the recorder for the current request. Called by the framework once at
+     * the end of request handling; this is where an implementation typically
+     * flushes its event.
+     */
+    end(): void;
+    /**
+     * Records the outcome and duration of a request. The concrete backend decides
+     * how to express this.
+     */
+    recordRequestOutcome(outcome: RequestOutcome, durationMs: number): void;
+    /**
+     * Records a count. Values should be non-negative for cross-backend portability.
+     */
+    addCount(name: string, value: number): void;
+    /**
+     * Records a duration in milliseconds.
+     */
+    addTime(name: string, value: number): void;
+    /**
+     * Records a level — a sampled value that should average meaningfully across
+     * calls (e.g. queue depth, batch size).
+     */
+    addLevel(name: string, value: number, unit?: MetricUnit): void;
+    /**
+     * Records a discrete data point where percentiles matter (e.g. per-call
+     * latency, item size).
+     */
+    addMetric(name: string, value: number, unit?: MetricUnit): void;
+    /**
+     * Records a unitless ratio (e.g. cache hit rate, throttle rate).
+     */
+    addRatio(name: string, value: number): void;
+    /**
+     * Attaches a property to the request's metrics. A nullish or empty value
+     * removes the property.
+     */
+    setProperty(name: string, value: string | null | undefined): void;
+    /**
+     * Returns the recorder's native backend handle, so callers can reach
+     * library-specific features the abstract methods do not expose (e.g. an
+     * OpenTelemetry `Meter`).
+     */
+    getMetrics(): Native;
+}
+/**
+ * Creates a per-request {@link MetricsRecorder}. Created once at startup and
+ * passed to the service handler; the framework calls {@link MetricsRecorderFactory.create}
+ * once per request to obtain a scoped recorder.
+ *
+ * @typeParam Native - the native backend handle exposed by recorders this
+ *   factory produces. See {@link MetricsRecorder}.
+ *
+ * @public
+ */
+export interface MetricsRecorderFactory<Native> {
+    create(): MetricsRecorder<Native>;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/abort-handler.d.ts

@@ -0,0 +1,7 @@
+import { AbortSignal as DeprecatedAbortSignal } from "./abort";
+/**
+ * @public
+ */
+export interface AbortHandler {
+    (this: AbortSignal | DeprecatedAbortSignal, ev: any): any;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/abort.d.ts

@@ -0,0 +1,45 @@
+import { AbortHandler } from "./abort-handler";
+export { AbortHandler };
+/**
+ * Holders of an AbortSignal object may query if the associated operation has
+ * been aborted and register an onabort handler.
+ *
+ * @public
+ * @deprecated use platform (global) type for AbortSignal.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+ */
+export interface AbortSignal {
+    /**
+     * Whether the action represented by this signal has been cancelled.
+     */
+    readonly aborted: boolean;
+    /**
+     * A function to be invoked when the action represented by this signal has
+     * been cancelled.
+     */
+    onabort: AbortHandler | Function | null;
+}
+/**
+ * The AWS SDK uses a Controller/Signal model to allow for cooperative
+ * cancellation of asynchronous operations. When initiating such an operation,
+ * the caller can create an AbortController and then provide linked signal to
+ * subtasks. This allows a single source to communicate to multiple consumers
+ * that an action has been aborted without dictating how that cancellation
+ * should be handled.
+ *
+ * @public
+ * @deprecated use platform (global) type for AbortController.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortController
+ */
+export interface AbortController {
+    /**
+     * An object that reports whether the action associated with this
+     * `AbortController` has been cancelled.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Declares the operation associated with this AbortController to have been
+     * cancelled.
+     */
+    abort(): void;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/auth/HttpApiKeyAuth.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ */
+export declare enum HttpApiKeyAuthLocation {
+    HEADER = "header",
+    QUERY = "query"
+}

package/node_modules/@smithy/types/dist-types/ts3.4/auth/HttpAuthScheme.d.ts

@@ -0,0 +1,49 @@
+import { Identity, IdentityProvider } from "../identity/identity";
+import { HandlerExecutionContext } from "../middleware";
+import { HttpSigner } from "./HttpSigner";
+import { IdentityProviderConfig } from "./IdentityProviderConfig";
+/**
+ * ID for {@link HttpAuthScheme}
+ * @internal
+ */
+export type HttpAuthSchemeId = string;
+/**
+ * Interface that defines an HttpAuthScheme
+ * @internal
+ */
+export interface HttpAuthScheme {
+    /**
+     * ID for an HttpAuthScheme, typically the absolute shape ID of a Smithy auth trait.
+     */
+    schemeId: HttpAuthSchemeId;
+    /**
+     * Gets the IdentityProvider corresponding to an HttpAuthScheme.
+     */
+    identityProvider(config: IdentityProviderConfig): IdentityProvider<Identity> | undefined;
+    /**
+     * HttpSigner corresponding to an HttpAuthScheme.
+     */
+    signer: HttpSigner;
+}
+/**
+ * Interface that defines the identity and signing properties when selecting
+ * an HttpAuthScheme.
+ * @internal
+ */
+export interface HttpAuthOption {
+    schemeId: HttpAuthSchemeId;
+    identityProperties?: Record<string, unknown>;
+    signingProperties?: Record<string, unknown>;
+    propertiesExtractor?: <TConfig extends object, TContext extends HandlerExecutionContext>(config: TConfig, context: TContext) => {
+        identityProperties?: Record<string, unknown>;
+        signingProperties?: Record<string, unknown>;
+    };
+}
+/**
+ * @internal
+ */
+export interface SelectedHttpAuthScheme {
+    httpAuthOption: HttpAuthOption;
+    identity: Identity;
+    signer: HttpSigner;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/auth/HttpAuthSchemeProvider.d.ts

@@ -0,0 +1,20 @@
+import { HandlerExecutionContext } from "../middleware";
+import { HttpAuthOption } from "./HttpAuthScheme";
+/**
+ * @internal
+ */
+export interface HttpAuthSchemeParameters {
+    operation?: string;
+}
+/**
+ * @internal
+ */
+export interface HttpAuthSchemeProvider<TParameters extends HttpAuthSchemeParameters> {
+    (authParameters: TParameters): HttpAuthOption[];
+}
+/**
+ * @internal
+ */
+export interface HttpAuthSchemeParametersProvider<TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object> {
+    (config: TConfig, context: TContext, input: TInput): Promise<TParameters>;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/auth/HttpSigner.d.ts

@@ -0,0 +1,41 @@
+import { HttpRequest, HttpResponse } from "../http";
+import { Identity } from "../identity/identity";
+/**
+ * @internal
+ */
+export interface ErrorHandler {
+    (signingProperties: Record<string, unknown>): <E extends Error>(error: E) => never;
+}
+/**
+ * @internal
+ */
+export interface SuccessHandler {
+    (httpResponse: HttpResponse | unknown, signingProperties: Record<string, unknown>): void;
+}
+/**
+ * Interface to sign identity and signing properties.
+ * @internal
+ */
+export interface HttpSigner {
+    /**
+     * Signs an HttpRequest with an identity and signing properties.
+     * @param httpRequest request to sign
+     * @param identity identity to sing the request with
+     * @param signingProperties property bag for signing
+     * @returns signed request in a promise
+     */
+    sign(httpRequest: HttpRequest, identity: Identity, signingProperties: Record<string, unknown>): Promise<HttpRequest>;
+    /**
+     * Handler that executes after the {@link HttpSigner.sign} invocation and corresponding
+     * middleware throws an error.
+     * The error handler is expected to throw the error it receives, so the return type of the error handler is `never`.
+     * @internal
+     */
+    errorHandler?: ErrorHandler;
+    /**
+     * Handler that executes after the {@link HttpSigner.sign} invocation and corresponding
+     * middleware succeeds.
+     * @internal
+     */
+    successHandler?: SuccessHandler;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/auth/IdentityProviderConfig.d.ts

@@ -0,0 +1,14 @@
+import { Identity, IdentityProvider } from "../identity/identity";
+import { HttpAuthSchemeId } from "./HttpAuthScheme";
+/**
+ * Interface to get an IdentityProvider for a specified HttpAuthScheme
+ * @internal
+ */
+export interface IdentityProviderConfig {
+    /**
+     * Get the IdentityProvider for a specified HttpAuthScheme.
+     * @param schemeId schemeId of the HttpAuthScheme
+     * @returns IdentityProvider or undefined if HttpAuthScheme is not found
+     */
+    getIdentityProvider(schemeId: HttpAuthSchemeId): IdentityProvider<Identity> | undefined;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/auth/auth.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Authentication schemes represent a way that the service will authenticate the customer’s identity.
+ *
+ * @internal
+ */
+export interface AuthScheme {
+    /**
+     * @example "sigv4a" or "sigv4"
+     */
+    name: "sigv4" | "sigv4a" | string;
+    /**
+     * @example "s3"
+     */
+    signingName: string;
+    /**
+     * @example "us-east-1"
+     */
+    signingRegion: string;
+    /**
+     * @example ["*"]
+     * @example ["us-west-2", "us-east-1"]
+     */
+    signingRegionSet?: string[];
+    /**
+     * @deprecated this field was renamed to signingRegion.
+     */
+    signingScope?: never;
+    properties: Record<string, unknown>;
+}
+/**
+ * @deprecated
+ *
+ * @internal
+ */
+export interface HttpAuthDefinition {
+    /**
+     * Defines the location of where the Auth is serialized.
+     */
+    in: HttpAuthLocation;
+    /**
+     * Defines the name of the HTTP header or query string parameter
+     * that contains the Auth.
+     */
+    name: string;
+    /**
+     * Defines the security scheme to use on the `Authorization` header value.
+     * This can only be set if the "in" property is set to {@link HttpAuthLocation.HEADER}.
+     */
+    scheme?: string;
+}
+/**
+ * @deprecated
+ *
+ * @internal
+ */
+export declare enum HttpAuthLocation {
+    HEADER = "header",
+    QUERY = "query"
+}

package/node_modules/@smithy/types/dist-types/ts3.4/auth/index.d.ts

@@ -0,0 +1,7 @@
+export { HttpAuthLocation } from "./auth";
+export { AuthScheme, HttpAuthDefinition } from "./auth";
+export { HttpApiKeyAuthLocation } from "./HttpApiKeyAuth";
+export { HttpAuthOption, HttpAuthScheme, HttpAuthSchemeId, SelectedHttpAuthScheme } from "./HttpAuthScheme";
+export { HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, } from "./HttpAuthSchemeProvider";
+export { ErrorHandler, HttpSigner, SuccessHandler } from "./HttpSigner";
+export { IdentityProviderConfig } from "./IdentityProviderConfig";

package/node_modules/@smithy/types/dist-types/ts3.4/blob/blob-payload-input-types.d.ts

@@ -0,0 +1,37 @@
+import { Readable } from "node:stream";
+import { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
+/**
+ * A union of types that can be used as inputs for the service model
+ * "blob" type when it represents the request's entire payload or body.
+ * For example, in Lambda::invoke, the payload is modeled as a blob type
+ * and this union applies to it.
+ * In contrast, in Lambda::createFunction the Zip file option is a blob type,
+ * but is not the (entire) payload and this union does not apply.
+ * Note: not all types are signable by the standard SignatureV4 signer when
+ * used as the request body. For example, in Node.js a Readable stream
+ * is not signable by the default signer.
+ * They are included in the union because it may work in some cases,
+ * but the expected types are primarily string and Uint8Array.
+ * Additional details may be found in the internal
+ * function "getPayloadHash" in the SignatureV4 module.
+ *
+ * @public
+ */
+export type BlobPayloadInputTypes = string | ArrayBuffer | ArrayBufferView | Uint8Array | NodeJsRuntimeBlobTypes | BrowserRuntimeBlobTypes;
+/**
+ * Additional blob types for the Node.js environment.
+ *
+ * @public
+ */
+export type NodeJsRuntimeBlobTypes = Readable | Buffer;
+/**
+ * Additional blob types for the browser environment.
+ *
+ * @public
+ */
+export type BrowserRuntimeBlobTypes = BlobOptionalType | ReadableStreamOptionalType;
+/**
+ * @internal
+ * @deprecated renamed to BlobPayloadInputTypes.
+ */
+export type BlobTypes = BlobPayloadInputTypes;

package/node_modules/@smithy/types/dist-types/ts3.4/checksum.d.ts

@@ -0,0 +1,61 @@
+import { SourceData } from "./crypto";
+/**
+ * An object that provides a checksum of data provided in chunks to `update`.
+ * The checksum may be performed incrementally as chunks are received or all
+ * at once when the checksum is finalized, depending on the underlying
+ * implementation.
+ * It's recommended to compute checksum incrementally to avoid reading the
+ * entire payload in memory.
+ * A class that implements this interface may accept an optional secret key in its
+ * constructor while computing checksum value, when using HMAC. If provided,
+ * this secret key would be used when computing checksum.
+ *
+ * @public
+ */
+export interface Checksum {
+    /**
+     * Constant length of the digest created by the algorithm in bytes.
+     */
+    digestLength?: number;
+    /**
+     * Creates a new checksum object that contains a deep copy of the internal
+     * state of the current `Checksum` object.
+     */
+    copy?(): Checksum;
+    /**
+     * Returns the digest of all of the data passed.
+     */
+    digest(): Promise<Uint8Array>;
+    /**
+     * Allows marking a checksum for checksums that support the ability
+     * to mark and reset.
+     *
+     * @param readLimit - The maximum limit of bytes that can be read
+     *   before the mark position becomes invalid.
+     */
+    mark?(readLimit: number): void;
+    /**
+     * Resets the checksum to its initial value.
+     */
+    reset(): void;
+    /**
+     * Adds a chunk of data for which checksum needs to be computed.
+     * This can be called many times with new data as it is streamed.
+     *
+     * Implementations may override this method which passes second param
+     * which makes Checksum object stateless.
+     *
+     * @param chunk - The buffer to update checksum with.
+     */
+    update(chunk: Uint8Array): void;
+}
+/**
+ * A constructor for a Checksum that may be used to calculate an HMAC. Implementing
+ * classes should not directly hold the provided key in memory beyond the
+ * lexical scope of the constructor.
+ *
+ * @public
+ */
+export interface ChecksumConstructor {
+    new (secret?: SourceData): Checksum;
+}

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

@@ -0,0 +1,57 @@
+import { Command } from "./command";
+import { MiddlewareStack } from "./middleware";
+import { MetadataBearer } from "./response";
+import { OptionalParameter } from "./util";
+/**
+ * A type which checks if the client configuration is optional.
+ * If all entries of the client configuration are optional, it allows client creation without passing any config.
+ *
+ * @public
+ */
+export type CheckOptionalClientConfig<T> = OptionalParameter<T>;
+/**
+ * function definition for different overrides of client's 'send' function.
+ *
+ * @public
+ */
+export interface InvokeFunction<InputTypes extends object, OutputTypes extends MetadataBearer, ResolvedClientConfiguration> {
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options?: any): Promise<OutputType>;
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, cb: (err: any, data?: OutputType) => void): void;
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options: any, cb: (err: any, data?: OutputType) => void): void;
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options?: any, cb?: (err: any, data?: OutputType) => void): Promise<OutputType> | void;
+}
+/**
+ * Signature that appears on aggregated clients' methods.
+ *
+ * @public
+ */
+export interface InvokeMethod<InputType extends object, OutputType extends MetadataBearer> {
+    (input: InputType, options?: any): Promise<OutputType>;
+    (input: InputType, cb: (err: any, data?: OutputType) => void): void;
+    (input: InputType, options: any, cb: (err: any, data?: OutputType) => void): void;
+    (input: InputType, options?: any, cb?: (err: any, data?: OutputType) => void): Promise<OutputType> | void;
+}
+/**
+ * Signature that appears on aggregated clients' methods when argument is optional.
+ *
+ * @public
+ */
+export interface InvokeMethodOptionalArgs<InputType extends object, OutputType extends MetadataBearer> {
+    (): Promise<OutputType>;
+    (input: InputType, options?: any): Promise<OutputType>;
+    (input: InputType, cb: (err: any, data?: OutputType) => void): void;
+    (input: InputType, options: any, cb: (err: any, data?: OutputType) => void): void;
+    (input: InputType, options?: any, cb?: (err: any, data?: OutputType) => void): Promise<OutputType> | void;
+}
+/**
+ * A general interface for service clients, idempotent to browser or node clients
+ * This type corresponds to SmithyClient(https://github.com/aws/aws-sdk-js-v3/blob/main/packages/smithy-client/src/client.ts).
+ * It's provided for using without importing the SmithyClient class.
+ * @internal
+ */
+export interface Client<Input extends object, Output extends MetadataBearer, ResolvedClientConfiguration> {
+    readonly config: ResolvedClientConfiguration;
+    middlewareStack: MiddlewareStack<Input, Output>;
+    send: InvokeFunction<Input, Output, ResolvedClientConfiguration>;
+    destroy: () => void;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/command.d.ts

@@ -0,0 +1,28 @@
+import { Handler, MiddlewareStack } from "./middleware";
+import { MetadataBearer } from "./response";
+/**
+ * @public
+ */
+export interface Command<ClientInput extends object, InputType extends ClientInput, ClientOutput extends MetadataBearer, OutputType extends ClientOutput, ResolvedConfiguration> extends CommandIO<InputType, OutputType> {
+    readonly input: InputType;
+    readonly middlewareStack: MiddlewareStack<InputType, OutputType>;
+    /**
+     * This should be OperationSchema from @smithy/types, but would
+     * create problems with the client transform type adaptors.
+     */
+    readonly schema?: any;
+    resolveMiddleware(stack: MiddlewareStack<ClientInput, ClientOutput>, configuration: ResolvedConfiguration, options: any): Handler<InputType, OutputType>;
+}
+/**
+ * This is a subset of the Command type used only to detect the i/o types.
+ *
+ * @internal
+ */
+export interface CommandIO<InputType extends object, OutputType extends MetadataBearer> {
+    readonly input: InputType;
+    resolveMiddleware(stack: any, configuration: any, options: any): Handler<InputType, OutputType>;
+}
+/**
+ * @internal
+ */
+export type GetOutputType<Command> = Command extends CommandIO<any, infer O> ? O : never;