@cdklabs/cdk-ssm-documents 0.0.68 → 0.0.70

package/node_modules/@smithy/types/dist-types/ts3.4/schema/static-schemas.d.ts

@@ -0,0 +1,118 @@
+import { $SchemaRef, SchemaTraits } from "../schema/schema";
+/**
+ * @public
+ */
+export type StaticSchemaIdSimple = 0;
+/**
+ * @public
+ */
+export type StaticSchemaIdList = 1;
+/**
+ * @public
+ */
+export type StaticSchemaIdMap = 2;
+/**
+ * @public
+ */
+export type StaticSchemaIdStruct = 3;
+/**
+ * @public
+ */
+export type StaticSchemaIdUnion = 4;
+/**
+ * @public
+ */
+export type StaticSchemaIdError = -3;
+/**
+ * @public
+ */
+export type StaticSchemaIdOperation = 9;
+/**
+ * @public
+ */
+export type StaticSchema = StaticSimpleSchema | StaticListSchema | StaticMapSchema | StaticStructureSchema | StaticUnionSchema | StaticErrorSchema | StaticOperationSchema;
+/**
+ * @public
+ */
+export type ShapeName = string;
+/**
+ * @public
+ */
+export type ShapeNamespace = string;
+/**
+ * @public
+ */
+export type StaticSimpleSchema = [
+    StaticSchemaIdSimple,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    $SchemaRef
+];
+/**
+ * @public
+ */
+export type StaticListSchema = [
+    StaticSchemaIdList,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    $SchemaRef
+];
+/**
+ * @public
+ */
+export type StaticMapSchema = [
+    StaticSchemaIdMap,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    $SchemaRef,
+    $SchemaRef
+];
+/**
+ * @public
+ */
+export type StaticStructureSchema = [
+    StaticSchemaIdStruct,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    string[],
+    $SchemaRef[],
+    number?
+];
+/**
+ * @public
+ */
+export type StaticUnionSchema = [
+    StaticSchemaIdUnion,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    string[],
+    $SchemaRef[]
+];
+/**
+ * @public
+ */
+export type StaticErrorSchema = [
+    StaticSchemaIdError,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    string[],
+    $SchemaRef[],
+    number?
+];
+/**
+ * @public
+ */
+export type StaticOperationSchema = [
+    StaticSchemaIdOperation,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    $SchemaRef,
+    $SchemaRef
+];

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

@@ -0,0 +1,46 @@
+/**
+ * A bitvector representing a traits object.
+ *
+ * Vector index to trait:
+ * 0 - httpLabel
+ * 1 - idempotent
+ * 2 - idempotencyToken
+ * 3 - sensitive
+ * 4 - httpPayload
+ * 5 - httpResponseCode
+ * 6 - httpQueryParams
+ *
+ * The singular trait values are enumerated for quick identification, but
+ * combination values are left to the `number` union type.
+ *
+ * @public
+ */
+export type TraitBitVector = HttpLabelBitMask | IdempotentBitMask | IdempotencyTokenBitMask | SensitiveBitMask | HttpPayloadBitMask | HttpResponseCodeBitMask | HttpQueryParamsBitMask | number;
+/**
+ * @public
+ */
+export type HttpLabelBitMask = 1;
+/**
+ * @public
+ */
+export type IdempotentBitMask = 2;
+/**
+ * @public
+ */
+export type IdempotencyTokenBitMask = 4;
+/**
+ * @public
+ */
+export type SensitiveBitMask = 8;
+/**
+ * @public
+ */
+export type HttpPayloadBitMask = 16;
+/**
+ * @public
+ */
+export type HttpResponseCodeBitMask = 32;
+/**
+ * @public
+ */
+export type HttpQueryParamsBitMask = 64;

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

@@ -0,0 +1,114 @@
+import { Endpoint } from "./http";
+import { $ClientProtocol } from "./schema/schema";
+import { RequestHandler } from "./transfer";
+import { Decoder, Encoder, Provider } from "./util";
+/**
+ * Interface for object requires an Endpoint set.
+ *
+ * @public
+ */
+export interface EndpointBearer {
+    endpoint: Provider<Endpoint>;
+}
+/**
+ * @public
+ */
+export interface StreamCollector {
+    /**
+     * A function that converts a stream into an array of bytes.
+     *
+     * @param stream - The low-level native stream from browser or Nodejs runtime
+     */
+    (stream: any): Promise<Uint8Array>;
+}
+/**
+ * Request and Response serde util functions and settings for AWS services
+ *
+ * @public
+ */
+export interface SerdeContext extends SerdeFunctions, EndpointBearer {
+    requestHandler: RequestHandler<any, any>;
+    disableHostPrefix: boolean;
+    protocol?: $ClientProtocol<any, any>;
+}
+/**
+ * Serde functions from the client config.
+ *
+ * @public
+ */
+export interface SerdeFunctions {
+    base64Encoder: Encoder;
+    base64Decoder: Decoder;
+    utf8Encoder: Encoder;
+    utf8Decoder: Decoder;
+    streamCollector: StreamCollector;
+}
+/**
+ * @public
+ */
+export interface RequestSerializer<Request, Context extends EndpointBearer = any> {
+    /**
+     * Converts the provided `input` into a request object
+     *
+     * @param input - The user input to serialize.
+     *
+     * @param context - Context containing runtime-specific util functions.
+     */
+    (input: any, context: Context): Promise<Request>;
+}
+/**
+ * @public
+ */
+export interface ResponseDeserializer<OutputType, ResponseType = any, Context = any> {
+    /**
+     * Converts the output of an operation into JavaScript types.
+     *
+     * @param output - The HTTP response received from the service
+     *
+     * @param context - context containing runtime-specific util functions.
+     */
+    (output: ResponseType, context: Context): Promise<OutputType>;
+}
+/**
+ * The interface contains mix-in utility functions to transfer the runtime-specific
+ * stream implementation to specified format. Each stream can ONLY be transformed
+ * once.
+ * @public
+ */
+export interface SdkStreamMixin {
+    transformToByteArray: () => Promise<Uint8Array>;
+    transformToString: (encoding?: string) => Promise<string>;
+    transformToWebStream: () => ReadableStream;
+}
+/**
+ * The type describing a runtime-specific stream implementation with mix-in
+ * utility functions.
+ *
+ * @public
+ */
+export type SdkStream<BaseStream> = BaseStream & SdkStreamMixin;
+/**
+ * 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];
+};
+/**
+ * Interface for internal function to inject stream utility functions
+ * implementation
+ *
+ * @internal
+ */
+export interface SdkStreamMixinInjector {
+    (stream: unknown): SdkStreamMixin;
+}
+/**
+ * @internal
+ */
+export interface SdkStreamSerdeContext {
+    sdkStreamMixin: SdkStreamMixinInjector;
+}

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

@@ -0,0 +1,79 @@
+import { HttpResponse } from "./http";
+import { MetadataBearer } from "./response";
+/**
+ * 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;
+};
+/**
+ * A structure shape with the error trait.
+ * https://smithy.io/2.0/spec/behavior-traits.html#smithy-api-retryable-trait
+ *
+ * @public
+ */
+export interface RetryableTrait {
+    /**
+     * Indicates that the error is a retryable throttling error.
+     */
+    readonly throttling?: boolean;
+}
+/**
+ * Type that is implemented by all Smithy shapes marked with the
+ * error trait.
+ *
+ * @public
+ * @deprecated
+ */
+export interface SmithyException {
+    /**
+     * The shape ID name of the exception.
+     */
+    readonly name: string;
+    /**
+     * Whether the client or server are at fault.
+     */
+    readonly $fault: "client" | "server";
+    /**
+     * The service that encountered the exception.
+     */
+    readonly $service?: string;
+    /**
+     * Indicates that an error MAY be retried by the client.
+     */
+    readonly $retryable?: RetryableTrait;
+    /**
+     * Reference to low-level HTTP response object.
+     */
+    readonly $response?: HttpResponse;
+}
+/**
+ * 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"] & {
+        /**
+         * If present, will have value of true and indicates that the error resulted in a
+         * correction of the clock skew, a.k.a. config.systemClockOffset.
+         * This is specific to AWS SDK and sigv4.
+         */
+        readonly clockSkewCorrected?: true;
+    };
+    cause?: Error;
+};

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

@@ -0,0 +1,172 @@
+import { Message } from "./eventStream";
+import { HttpRequest } from "./http";
+import { AwsCredentialIdentity } from "./identity/awsCredentialIdentity";
+/**
+ * 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;
+/**
+ * @public
+ */
+export interface SigningArguments {
+    /**
+     * The date and time to be used as signature metadata. This value should be
+     * a Date object, a unix (epoch) timestamp, or a string that can be
+     * understood by the JavaScript `Date` constructor.If not supplied, the
+     * value returned by `new Date()` will be used.
+     */
+    signingDate?: DateInput;
+    /**
+     * The service signing name. It will override the service name of the signer
+     * in current invocation
+     */
+    signingService?: string;
+    /**
+     * The region name to sign the request. It will override the signing region of the
+     * signer in current invocation
+     */
+    signingRegion?: string;
+}
+/**
+ * @public
+ */
+export interface RequestSigningArguments extends SigningArguments {
+    /**
+     * A set of strings whose members represents headers that cannot be signed.
+     * All headers in the provided request will have their names converted to
+     * lower case and then checked for existence in the unsignableHeaders set.
+     */
+    unsignableHeaders?: Set<string>;
+    /**
+     * A set of strings whose members represents headers that should be signed.
+     * Any values passed here will override those provided via unsignableHeaders,
+     * allowing them to be signed.
+     *
+     * All headers in the provided request will have their names converted to
+     * lower case before signing.
+     */
+    signableHeaders?: Set<string>;
+}
+/**
+ * @public
+ */
+export interface RequestPresigningArguments extends RequestSigningArguments {
+    /**
+     * The number of seconds before the presigned URL expires
+     */
+    expiresIn?: number;
+    /**
+     * A set of strings whose representing headers that should not be hoisted
+     * to presigned request's query string. If not supplied, the presigner
+     * moves all the AWS-specific headers (starting with `x-amz-`) to the request
+     * query string. If supplied, these headers remain in the presigned request's
+     * header.
+     * All headers in the provided request will have their names converted to
+     * lower case and then checked for existence in the unhoistableHeaders set.
+     */
+    unhoistableHeaders?: Set<string>;
+    /**
+     * This overrides any headers with the same name(s) set by unhoistableHeaders.
+     * These headers will be hoisted into the query string and signed.
+     */
+    hoistableHeaders?: Set<string>;
+}
+/**
+ * @public
+ */
+export interface EventSigningArguments extends SigningArguments, EventStreamRequestScopedCredentials {
+    priorSignature: string;
+}
+/**
+ * @public
+ */
+export interface MessageSigningArguments extends SigningArguments, EventStreamRequestScopedCredentials {
+}
+/**
+ * @internal
+ */
+export interface EventStreamRequestScopedCredentials {
+    /**
+     * Optional, static credentials used for the duration of the event-stream request.
+     * If not provided, the signer's internal credential provider would be used, if
+     * the signer is SignatureV4.
+     */
+    eventStreamCredentials?: AwsCredentialIdentity;
+}
+/**
+ * @public
+ */
+export interface RequestPresigner {
+    /**
+     * Signs a request for future use.
+     *
+     * The request will be valid until either the provided `expiration` time has
+     * passed or the underlying credentials have expired.
+     *
+     * @param requestToSign - The request that should be signed.
+     * @param options - Additional signing options.
+     */
+    presign(requestToSign: HttpRequest, options?: RequestPresigningArguments): Promise<HttpRequest>;
+}
+/**
+ * An object that signs request objects with AWS credentials using one of the
+ * AWS authentication protocols.
+ *
+ * @public
+ */
+export interface RequestSigner {
+    /**
+     * Sign the provided request for immediate dispatch.
+     */
+    sign(requestToSign: HttpRequest, options?: RequestSigningArguments): Promise<HttpRequest>;
+}
+/**
+ * @public
+ */
+export interface StringSigner {
+    /**
+     * Sign the provided `stringToSign` for use outside of the context of
+     * request signing. Typical uses include signed policy generation.
+     */
+    sign(stringToSign: string, options?: SigningArguments): Promise<string>;
+}
+/**
+ * @public
+ */
+export interface FormattedEvent {
+    headers: Uint8Array;
+    payload: Uint8Array;
+}
+/**
+ * @public
+ */
+export interface EventSigner {
+    /**
+     * Sign the individual event of the event stream.
+     */
+    sign(event: FormattedEvent, options: EventSigningArguments): Promise<string>;
+}
+/**
+ * @public
+ */
+export interface SignableMessage {
+    message: Message;
+    priorSignature: string;
+}
+/**
+ * @public
+ */
+export interface SignedMessage {
+    message: Message;
+    signature: string;
+}
+/**
+ * @public
+ */
+export interface MessageSigner {
+    signMessage(message: SignableMessage, args: MessageSigningArguments): Promise<SignedMessage>;
+    sign(event: SignableMessage, options: MessageSigningArguments): Promise<SignedMessage>;
+}

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

@@ -0,0 +1,22 @@
+import { ChecksumConstructor } from "./checksum";
+import { HashConstructor, StreamHasher } from "./crypto";
+import { BodyLengthCalculator, Encoder } from "./util";
+/**
+ * @public
+ */
+export interface GetAwsChunkedEncodingStreamOptions {
+    base64Encoder?: Encoder;
+    bodyLengthChecker: BodyLengthCalculator;
+    checksumAlgorithmFn?: ChecksumConstructor | HashConstructor;
+    checksumLocationName?: string;
+    streamHasher?: StreamHasher;
+}
+/**
+ * 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/ts3.4/streaming-payload/streaming-blob-common-types.d.ts

@@ -0,0 +1,28 @@
+import { Readable } from "node:stream";
+import { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
+/**
+ * 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.
+ * 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;
+/**
+ * Node.js streaming blob type.
+ *
+ * @public
+ */
+export type NodeJsRuntimeStreamingBlobTypes = Readable;
+/**
+ * Browser streaming blob types.
+ *
+ * @public
+ */
+export type BrowserRuntimeStreamingBlobTypes = ReadableStreamOptionalType | BlobOptionalType;

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

@@ -0,0 +1,54 @@
+import { Readable } from "node:stream";
+import { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
+/**
+ * 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.
+ * 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.
+ * 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.
+ *
+ * @public
+ */
+export type StreamingBlobPayloadInputTypes = NodeJsRuntimeStreamingBlobPayloadInputTypes | BrowserRuntimeStreamingBlobPayloadInputTypes;
+/**
+ * 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;
+/**
+ * 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/ts3.4/streaming-payload/streaming-blob-payload-output-types.d.ts

@@ -0,0 +1,41 @@
+import { IncomingMessage } from "node:http";
+import { Readable } from "node:stream";
+import { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
+import { SdkStream } from "../serde";
+/**
+ * This union represents a superset of the types you may receive
+ * in streaming payload outputs.
+ * 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;
+/**
+ * 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>;
+/**
+ * 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>;