@rio-cloud/cdk-v2-constructs 8.1.0 → 8.2.0-alpha.0

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

@@ -1,5 +1,5 @@
-import type { AuthScheme, HttpAuthDefinition } from "./auth/auth";
 import type { SelectedHttpAuthScheme } from "./auth/HttpAuthScheme";
+import type { AuthScheme, HttpAuthDefinition } from "./auth/auth";
 import type { Command } from "./command";
 import type { EndpointV2 } from "./endpoint";
 import type { SmithyFeatures } from "./feature-ids";
@@ -137,10 +137,10 @@ export interface DeserializeHandler<Input extends object, Output extends object>
     (args: DeserializeHandlerArguments<Input>): Promise<DeserializeHandlerOutput<Output>>;
 }
 /**
- * @public
- *
  * A factory function that creates functions implementing the `Handler`
  * interface.
+ *
+ * @public
  */
 export interface InitializeMiddleware<Input extends object, Output extends object> {
     /**
@@ -152,10 +152,10 @@ export interface InitializeMiddleware<Input extends object, Output extends objec
     (next: InitializeHandler<Input, Output>, context: HandlerExecutionContext): InitializeHandler<Input, Output>;
 }
 /**
- * @public
- *
  * A factory function that creates functions implementing the `BuildHandler`
  * interface.
+ *
+ * @public
  */
 export interface SerializeMiddleware<Input extends object, Output extends object> {
     /**
@@ -167,10 +167,10 @@ export interface SerializeMiddleware<Input extends object, Output extends object
     (next: SerializeHandler<Input, Output>, context: HandlerExecutionContext): SerializeHandler<Input, Output>;
 }
 /**
- * @public
- *
  * A factory function that creates functions implementing the `FinalizeHandler`
  * interface.
+ *
+ * @public
  */
 export interface FinalizeRequestMiddleware<Input extends object, Output extends object> {
     /**
@@ -198,10 +198,10 @@ export interface DeserializeMiddleware<Input extends object, Output extends obje
  */
 export type MiddlewareType<Input extends object, Output extends object> = InitializeMiddleware<Input, Output> | SerializeMiddleware<Input, Output> | BuildMiddleware<Input, Output> | FinalizeRequestMiddleware<Input, Output> | DeserializeMiddleware<Input, Output>;
 /**
- * @public
- *
  * A factory function that creates the terminal handler atop which a middleware
  * stack sits.
+ *
+ * @public
  */
 export interface Terminalware {
     <Input extends object, Output extends object>(context: HandlerExecutionContext): DeserializeHandler<Input, Output>;
@@ -258,10 +258,11 @@ export interface HandlerOptions {
      */
     name?: string;
     /**
-     * @internal
      * Aliases allows for middleware to be found by multiple names besides {@link HandlerOptions.name}.
      * This allows for references to replaced middleware to continue working, e.g. replacing
      * multiple auth-specific middleware with a single generic auth middleware.
+     *
+     * @internal
      */
     aliases?: Array<string>;
     /**
@@ -335,21 +336,21 @@ export interface DeserializeHandlerOptions extends HandlerOptions {
     step: "deserialize";
 }
 /**
- * @public
- *
  * A stack storing middleware. It can be resolved into a handler. It supports 2
  * approaches for adding middleware:
  * 1. Adding middleware to specific step with `add()`. The order of middleware
- *    added into same step is determined by order of adding them. If one middleware
- *    needs to be executed at the front of the step or at the end of step, set
- *    `priority` options to `high` or `low`.
+ * added into same step is determined by order of adding them. If one middleware
+ * needs to be executed at the front of the step or at the end of step, set
+ * `priority` options to `high` or `low`.
  * 2. Adding middleware to location relative to known middleware with `addRelativeTo()`.
- *    This is useful when given middleware must be executed before or after specific
- *    middleware(`toMiddleware`). You can add a middleware relatively to another
- *    middleware which also added relatively. But eventually, this relative middleware
- *    chain **must** be 'anchored' by a middleware that added using `add()` API
- *    with absolute `step` and `priority`. This mothod will throw if specified
- *    `toMiddleware` is not found.
+ * This is useful when given middleware must be executed before or after specific
+ * middleware(`toMiddleware`). You can add a middleware relatively to another
+ * middleware which also added relatively. But eventually, this relative middleware
+ * chain **must** be 'anchored' by a middleware that added using `add()` API
+ * with absolute `step` and `priority`. This mothod will throw if specified
+ * `toMiddleware` is not found.
+ *
+ * @public
  */
 export interface MiddlewareStack<Input extends object, Output extends object> extends Pluggable<Input, Output> {
     /**
@@ -420,14 +421,13 @@ export interface MiddlewareStack<Input extends object, Output extends object> ex
      */
     identify(): string[];
     /**
-     * @internal
-     *
      * When an operation is called using this stack,
      * it will log its list of middleware to the console using
      * the identify function.
+     * If no argument given, returns the current value.
      *
+     * @internal
      * @param toggle - set whether to log on resolve.
-     *                 If no argument given, returns the current value.
      */
     identifyOnResolve(toggle?: boolean): boolean;
     /**
@@ -447,10 +447,10 @@ export interface MiddlewareStack<Input extends object, Output extends object> ex
  */
 export declare const SMITHY_CONTEXT_KEY = "__smithy_context";
 /**
- * @public
- *
  * Data and helper objects that are not expected to change from one execution of
  * a composed handler to another.
+ *
+ * @public
  */
 export interface HandlerExecutionContext {
     /**
@@ -495,8 +495,9 @@ export interface HandlerExecutionContext {
         overrideOutputFilterSensitiveLog(...args: any[]): string | void;
     }>;
     /**
-     * @internal
      * Context for Smithy properties.
+     *
+     * @internal
      */
     [SMITHY_CONTEXT_KEY]?: {
         service?: string;

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

@@ -1,16 +1,16 @@
 import type { Client } from "./client";
 import type { Command } from "./command";
 /**
- * @public
- *
  * Expected type definition of a paginator.
+ *
+ * @public
  */
 export type Paginator<T> = AsyncGenerator<T, undefined, unknown>;
 /**
- * @public
- *
  * Expected paginator configuration passed to an operation. Services will extend
  * this interface definition and may type client further.
+ *
+ * @public
  */
 export interface PaginationConfiguration {
     client: Client<any, any, any>;

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

@@ -75,10 +75,24 @@ export interface RetryStrategyOptions {
  */
 export interface RetryToken {
     /**
+     * Starts at 0 for the initial request, which is not a "retry" by definition.
+     * 1 indicates the first retry.
+     *
      * @returns the current count of retry.
      */
     getRetryCount(): number;
     /**
+     * RetryStrategies implemented by `@smithy/core` will return tokens with a
+     * delay of zero.
+     *
+     * This is because the RetryStrategy token acquisition methods took over the
+     * task of idling for the delay period. If a user-implemented retry token
+     * contains a delay, the default Smithy retry middleware will still honor it.
+     *
+     * That is to say, you may either sleep within the RetryStrategy methods for acquiring
+     * the token, OR return a token with a retry delay that will cause the retry middleware
+     * to sleep.
+     *
      * @returns the number of milliseconds to wait before retrying an action.
      */
     getRetryDelay(): number;
@@ -86,6 +100,14 @@ export interface RetryToken {
      * @returns whether the operation which generated this token is long polling.
      */
     isLongPoll?(): boolean;
+    /**
+     * Delays that have already been executed by the time the token
+     * is accessible. This is needed for the token handler to understand what has happened.
+     * @internal
+     */
+    $retryLog?: {
+        acquisitionDelay?: number;
+    };
 }
 /**
  * @public
@@ -116,6 +138,9 @@ export interface RetryStrategyV2 {
      * either choose to allow another retry and send a new or updated token,
      * or reject the retry attempt and report the error either in an exception
      * or returning an error.
+     *
+     * This method should either delay internally and return a token with 0 delay, OR
+     * do not sleep and return a token with the desired delay duration.
      */
     refreshRetryTokenForRetry(tokenToRenew: RetryToken, errorInfo: RetryErrorInfo): Promise<RetryToken>;
     /**

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

@@ -3,9 +3,9 @@ import type { $ClientProtocol } from "./schema/schema";
 import type { RequestHandler } from "./transfer";
 import type { Decoder, Encoder, Provider } from "./util";
 /**
- * @public
- *
  * Interface for object requires an Endpoint set.
+ *
+ * @public
  */
 export interface EndpointBearer {
     endpoint: Provider<Endpoint>;
@@ -22,9 +22,9 @@ export interface StreamCollector {
     (stream: any): Promise<Uint8Array>;
 }
 /**
- * @public
- *
  * Request and Response serde util functions and settings for AWS services
+ *
+ * @public
  */
 export interface SerdeContext extends SerdeFunctions, EndpointBearer {
     requestHandler: RequestHandler<any, any>;
@@ -32,9 +32,9 @@ export interface SerdeContext extends SerdeFunctions, EndpointBearer {
     protocol?: $ClientProtocol<any, any>;
 }
 /**
- * @public
- *
  * Serde functions from the client config.
+ *
+ * @public
  */
 export interface SerdeFunctions {
     base64Encoder: Encoder;
@@ -81,18 +81,18 @@ export interface SdkStreamMixin {
     transformToWebStream: () => ReadableStream;
 }
 /**
- * @public
- *
  * The type describing a runtime-specific stream implementation with mix-in
  * utility functions.
+ *
+ * @public
  */
 export type SdkStream<BaseStream> = BaseStream & SdkStreamMixin;
 /**
- * @public
- *
  * Indicates that the member of type T with
  * key StreamKey have been extended
  * with the SdkStreamMixin helper methods.
+ *
+ * @public
  */
 export type WithSdkStreamMixin<T, StreamKey extends keyof T> = {
     [key in keyof T]: key extends StreamKey ? SdkStream<T[StreamKey]> : T[key];

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

@@ -1,23 +1,22 @@
 import type { HttpResponse } from "./http";
 import type { MetadataBearer } from "./response";
 /**
- * @public
- *
  * A document type represents an untyped JSON-like value.
- *
  * Not all protocols support document types, and the serialization format of a
  * document type is protocol specific. All JSON protocols SHOULD support
  * document types and they SHOULD serialize document types inline as normal
  * JSON values.
+ *
+ * @public
  */
 export type DocumentType = null | boolean | number | string | DocumentType[] | {
     [prop: string]: DocumentType;
 };
 /**
- * @public
- *
  * A structure shape with the error trait.
  * https://smithy.io/2.0/spec/behavior-traits.html#smithy-api-retryable-trait
+ *
+ * @public
  */
 export interface RetryableTrait {
     /**
@@ -26,10 +25,10 @@ export interface RetryableTrait {
     readonly throttling?: boolean;
 }
 /**
- * @public
- *
  * Type that is implemented by all Smithy shapes marked with the
  * error trait.
+ *
+ * @public
  * @deprecated
  */
 export interface SmithyException {
@@ -55,19 +54,17 @@ export interface SmithyException {
     readonly $response?: HttpResponse;
 }
 /**
- * @public
- *
- * @deprecated See {@link https://aws.amazon.com/blogs/developer/service-error-handling-modular-aws-sdk-js/}
- *
  * This type should not be used in your application.
  * Users of the AWS SDK for JavaScript v3 service clients should prefer to
  * use the specific Exception classes corresponding to each operation.
  * These can be found as code in the deserializer for the operation's Command class,
  * or as declarations in the service model file in codegen/sdk-codegen/aws-models.
- *
  * If no exceptions are enumerated by a particular Command operation,
  * the base exception for the service should be used. Each client exports
  * a base ServiceException prefixed with the service name.
+ *
+ * @public
+ * @deprecated See {@link https://aws.amazon.com/blogs/developer/service-error-handling-modular-aws-sdk-js/}
  */
 export type SdkError = Error & Partial<SmithyException> & Partial<MetadataBearer> & {
     $metadata?: Partial<MetadataBearer>["$metadata"] & {

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

@@ -2,10 +2,10 @@ import type { Message } from "./eventStream";
 import type { HttpRequest } from "./http";
 import type { AwsCredentialIdentity } from "./identity/awsCredentialIdentity";
 /**
- * @public
- *
  * A `Date` object, a unix (epoch) timestamp in seconds, or a string that can be
  * understood by the JavaScript `Date` constructor.
+ *
+ * @public
  */
 export type DateInput = number | string | Date;
 /**
@@ -112,10 +112,10 @@ export interface RequestPresigner {
     presign(requestToSign: HttpRequest, options?: RequestPresigningArguments): Promise<HttpRequest>;
 }
 /**
- * @public
- *
  * An object that signs request objects with AWS credentials using one of the
  * AWS authentication protocols.
+ *
+ * @public
  */
 export interface RequestSigner {
     /**

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

@@ -12,10 +12,10 @@ export interface GetAwsChunkedEncodingStreamOptions {
     streamHasher?: StreamHasher;
 }
 /**
- * @public
- *
  * A function that returns Readable Stream which follows aws-chunked encoding stream.
  * It optionally adds checksum if options are provided.
+ *
+ * @public
  */
 export interface GetAwsChunkedEncodingStream<StreamType = any> {
     (readableStream: StreamType, options: GetAwsChunkedEncodingStreamOptions): StreamType;

package/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-common-types.d.ts

@@ -1,32 +1,28 @@
-import type { Readable } from "stream";
+import type { Readable } from "node:stream";
 import type { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
 /**
- * @public
- *
  * This is the union representing the modeled blob type with streaming trait
  * in a generic format that does not relate to HTTP input or output payloads.
- *
  * Note: the non-streaming blob type is represented by Uint8Array, but because
  * the streaming blob type is always in the request/response paylod, it has
  * historically been handled with different types.
- *
- * @see https://smithy.io/2.0/spec/simple-types.html#blob
- *
  * For compatibility with its historical representation, it must contain at least
  * Readble (Node.js), Blob (browser), and ReadableStream (browser).
  *
+ * @public
+ * @see https://smithy.io/2.0/spec/simple-types.html#blob
  * @see StreamingPayloadInputTypes for FAQ about mixing types from multiple environments.
  */
 export type StreamingBlobTypes = NodeJsRuntimeStreamingBlobTypes | BrowserRuntimeStreamingBlobTypes;
 /**
- * @public
- *
  * Node.js streaming blob type.
+ *
+ * @public
  */
 export type NodeJsRuntimeStreamingBlobTypes = Readable;
 /**
- * @public
- *
  * Browser streaming blob types.
+ *
+ * @public
  */
 export type BrowserRuntimeStreamingBlobTypes = ReadableStreamOptionalType | BlobOptionalType;

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

@@ -1,60 +1,54 @@
-import type { Readable } from "stream";
+import type { Readable } from "node:stream";
 import type { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
 /**
- * @public
- *
  * This union represents a superset of the compatible types you
  * can use for streaming payload inputs.
- *
  * FAQ:
  * Why does the type union mix mutually exclusive runtime types, namely
  * Node.js and browser types?
- *
  * There are several reasons:
  * 1. For backwards compatibility.
  * 2. As a convenient compromise solution so that users in either environment may use the types
- *    without customization.
+ * without customization.
  * 3. The SDK does not have static type information about the exact implementation
- *    of the HTTP RequestHandler being used in your client(s) (e.g. fetch, XHR, node:http, or node:http2),
- *    given that it is chosen at runtime. There are multiple possible request handlers
- *    in both the Node.js and browser runtime environments.
- *
- *    Rather than restricting the type to a known common format (Uint8Array, for example)
- *    which doesn't include a universal streaming format in the currently supported Node.js versions,
- *    the type declaration is widened to multiple possible formats.
- *    It is up to the user to ultimately select a compatible format with the
- *    runtime and HTTP handler implementation they are using.
- *
+ * of the HTTP RequestHandler being used in your client(s) (e.g. fetch, XHR, node:http, or node:http2),
+ * given that it is chosen at runtime. There are multiple possible request handlers
+ * in both the Node.js and browser runtime environments.
+ * Rather than restricting the type to a known common format (Uint8Array, for example)
+ * which doesn't include a universal streaming format in the currently supported Node.js versions,
+ * the type declaration is widened to multiple possible formats.
+ * It is up to the user to ultimately select a compatible format with the
+ * runtime and HTTP handler implementation they are using.
  * Usage:
- *    The typical solution we expect users to have is to manually narrow the
- *    type when needed, picking the appropriate one out of the union according to the
- *    runtime environment and specific request handler.
- *    There is also the type utility "NodeJsClient", "BrowserClient" and more
- *    exported from this package. These can be applied at the client level
- *    to pre-narrow these streaming payload blobs. For usage see the readme.md
- *    in the root of the \@smithy/types NPM package.
+ * The typical solution we expect users to have is to manually narrow the
+ * type when needed, picking the appropriate one out of the union according to the
+ * runtime environment and specific request handler.
+ * There is also the type utility "NodeJsClient", "BrowserClient" and more
+ * exported from this package. These can be applied at the client level
+ * to pre-narrow these streaming payload blobs. For usage see the readme.md
+ * in the root of the \@smithy/types NPM package.
+ *
+ * @public
  */
 export type StreamingBlobPayloadInputTypes = NodeJsRuntimeStreamingBlobPayloadInputTypes | BrowserRuntimeStreamingBlobPayloadInputTypes;
 /**
- * @public
- *
  * Streaming payload input types in the Node.js environment.
  * These are derived from the types compatible with the request body used by node:http.
- *
  * 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 be intended in some cases,
  * but the expected types are primarily string, Uint8Array, and Buffer.
- *
  * Additional details may be found in the internal
  * function "getPayloadHash" in the SignatureV4 module.
+ *
+ * @public
  */
 export type NodeJsRuntimeStreamingBlobPayloadInputTypes = string | Uint8Array | Buffer | Readable;
 /**
- * @public
- *
  * Streaming payload input types in the browser environment.
  * These are derived from the types compatible with fetch's Request.body.
+ *
+ * @public
  */
 export type BrowserRuntimeStreamingBlobPayloadInputTypes = string | Uint8Array | ReadableStreamOptionalType | BlobOptionalType;

package/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-payload-output-types.d.ts

@@ -1,51 +1,41 @@
-import type { IncomingMessage } from "http";
-import type { Readable } from "stream";
+import type { IncomingMessage } from "node:http";
+import type { Readable } from "node:stream";
 import type { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
 import type { SdkStream } from "../serde";
 /**
- * @public
- *
  * This union represents a superset of the types you may receive
  * in streaming payload outputs.
- *
- * @see StreamingPayloadInputTypes for FAQ about mixing types from multiple environments.
- *
  * To highlight the upstream docs about the SdkStream mixin:
- *
  * The interface contains mix-in (via Object.assign) methods to transform the runtime-specific
  * stream implementation to specified format. Each stream can ONLY be transformed
  * once.
- *
  * The available methods are described on the SdkStream type via SdkStreamMixin.
+ *
+ * @public
+ * @see StreamingPayloadInputTypes for FAQ about mixing types from multiple environments.
  */
 export type StreamingBlobPayloadOutputTypes = NodeJsRuntimeStreamingBlobPayloadOutputTypes | BrowserRuntimeStreamingBlobPayloadOutputTypes;
 /**
- * @public
- *
  * Streaming payload output types in the Node.js environment.
- *
  * This is by default the IncomingMessage type from node:http responses when
  * using the default node-http-handler in Node.js environments.
- *
  * It can be other Readable types like node:http2's ClientHttp2Stream
  * such as when using the node-http2-handler.
- *
  * The SdkStreamMixin adds methods on this type to help transform (collect) it to
  * other formats.
+ *
+ * @public
  */
 export type NodeJsRuntimeStreamingBlobPayloadOutputTypes = SdkStream<IncomingMessage | Readable>;
 /**
- * @public
- *
  * Streaming payload output types in the browser environment.
- *
  * This is by default fetch's Response.body type (ReadableStream) when using
  * the default fetch-http-handler in browser-like environments.
- *
  * It may be a Blob, such as when using the XMLHttpRequest handler
  * and receiving an arraybuffer response body.
- *
  * The SdkStreamMixin adds methods on this type to help transform (collect) it to
  * other formats.
+ *
+ * @public
  */
 export type BrowserRuntimeStreamingBlobPayloadOutputTypes = SdkStream<ReadableStreamOptionalType | BlobOptionalType>;

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

@@ -24,8 +24,9 @@ export interface RequestHandlerMetadata {
     handlerProtocol: RequestHandlerProtocol | string;
 }
 /**
- * @public
  * Values from ALPN Protocol IDs.
+ *
+ * @public
  * @see https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
  */
 export declare enum RequestHandlerProtocol {

package/node_modules/@smithy/types/dist-types/transform/client-method-transforms.d.ts

@@ -3,9 +3,9 @@ import type { MetadataBearer } from "../response";
 import type { StreamingBlobPayloadOutputTypes } from "../streaming-payload/streaming-blob-payload-output-types";
 import type { Transform } from "./type-transform";
 /**
- * @internal
- *
  * Narrowed version of InvokeFunction used in Client::send.
+ *
+ * @internal
  */
 export interface NarrowedInvokeFunction<NarrowType, HttpHandlerOptions, InputTypes extends object, OutputTypes extends MetadataBearer> {
     <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, options?: HttpHandlerOptions): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>>;
@@ -14,9 +14,9 @@ export interface NarrowedInvokeFunction<NarrowType, HttpHandlerOptions, InputTyp
     <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, options?: HttpHandlerOptions, cb?: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>> | void;
 }
 /**
- * @internal
- *
  * Narrowed version of InvokeMethod used in aggregated Client methods.
+ *
+ * @internal
  */
 export interface NarrowedInvokeMethod<NarrowType, HttpHandlerOptions, InputType extends object, OutputType extends MetadataBearer> {
     (input: InputType, options?: HttpHandlerOptions): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>>;