@cdklabs/cdk-ssm-documents 0.0.68 → 0.0.69

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

@@ -0,0 +1,15 @@
+/**
+ * @public
+ */
+export interface ConnectConfiguration {
+    /**
+     * The maximum time in milliseconds that the connection phase of a request
+     * may take before the connection attempt is abandoned.
+     */
+    requestTimeout?: number;
+    /**
+     * Signal from the Command class object context,
+     * tells the connection manager to use a new connection.
+     */
+    isEventStream?: boolean;
+}

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

@@ -0,0 +1,3 @@
+export { ConnectConfiguration } from "./config";
+export { ConnectionManager, ConnectionManagerConfiguration } from "./manager";
+export { CacheKey, ConnectionPool } from "./pool";

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

@@ -0,0 +1,34 @@
+import { RequestContext } from "../transfer";
+import { ConnectConfiguration } from "./config";
+/**
+ * @public
+ */
+export interface ConnectionManagerConfiguration {
+    /**
+     * Maximum number of allowed concurrent requests per connection.
+     */
+    maxConcurrency?: number;
+    /**
+     * Disables concurrent requests per connection.
+     */
+    disableConcurrency?: boolean;
+}
+/**
+ * @public
+ */
+export interface ConnectionManager<T> {
+    /**
+     * Retrieves a connection from the connection pool if available,
+     * otherwise establish a new connection
+     */
+    lease(requestContext: RequestContext, connectionConfiguration: ConnectConfiguration): T;
+    /**
+     * Releases the connection back to the pool making it potentially
+     * re-usable by other requests.
+     */
+    release(requestContext: RequestContext, connection: T): void;
+    /**
+     * Destroys the connection manager. All connections will be closed.
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * @public
+ */
+export interface ConnectionPool<T> {
+    /**
+     * Retrieve the first connection in the pool
+     */
+    poll(): T | void;
+    /**
+     * Release the connection back to the pool making it potentially
+     * re-usable by other requests.
+     */
+    offerLast(connection: T): void;
+    /**
+     * Removes the connection from the pool, and destroys it.
+     */
+    destroy(connection: T): void;
+    /**
+     * Implements the iterable protocol and allows arrays to be consumed
+     * by most syntaxes expecting iterables, such as the spread syntax
+     * and for...of loops
+     */
+    [Symbol.iterator](): Iterator<T>;
+}
+/**
+ * Unused.
+ * @internal
+ * @deprecated
+ */
+export interface CacheKey {
+    destination: string;
+}

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

@@ -0,0 +1,58 @@
+/**
+ * @public
+ */
+export type SourceData = string | ArrayBuffer | ArrayBufferView;
+/**
+ * An object that provides a hash of data provided in chunks to `update`. The
+ * hash may be performed incrementally as chunks are received or all at once
+ * when the hash is finalized, depending on the underlying implementation.
+ *
+ * @public
+ * @deprecated use {@link Checksum}
+ */
+export interface Hash {
+    /**
+     * Adds a chunk of data to the hash. If a buffer is provided, the `encoding`
+     * argument will be ignored. If a string is provided without a specified
+     * encoding, implementations must assume UTF-8 encoding.
+     *
+     * Not all encodings are supported on all platforms, though all must support
+     * UTF-8.
+     */
+    update(toHash: SourceData, encoding?: "utf8" | "ascii" | "latin1"): void;
+    /**
+     * Finalizes the hash and provides a promise that will be fulfilled with the
+     * raw bytes of the calculated hash.
+     */
+    digest(): Promise<Uint8Array>;
+}
+/**
+ * A constructor for a hash 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
+ * @deprecated use {@link ChecksumConstructor}
+ */
+export interface HashConstructor {
+    new (secret?: SourceData): Hash;
+}
+/**
+ * A function that calculates the hash of a data stream. Determining the hash
+ * will consume the stream, so only replayable streams should be provided to an
+ * implementation of this interface.
+ *
+ * @public
+ */
+export interface StreamHasher<StreamType = any> {
+    (hashCtor: HashConstructor, stream: StreamType): Promise<Uint8Array>;
+}
+/**
+ * A function that returns a promise fulfilled with bytes from a
+ * cryptographically secure pseudorandom number generator.
+ *
+ * @public
+ */
+export interface randomValues {
+    (byteLength: number): Promise<Uint8Array>;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/downlevel-ts3.4/transform/type-transform.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Transforms any members of the object T having type FromType
+ * to ToType. This applies only to exact type matches.
+ * This is for the case where FromType is a union and only those fields
+ * matching the same union should be transformed.
+ *
+ * @public
+ */
+export type Transform<T, FromType, ToType> = RecursiveTransformExact<T, FromType, ToType>;
+/**
+ * Returns ToType if T matches exactly with FromType.
+ *
+ * @internal
+ */
+type TransformExact<T, FromType, ToType> = [
+    T
+] extends [
+    FromType
+] ? ([
+    FromType
+] extends [
+    T
+] ? ToType : T) : T;
+/**
+ * Applies TransformExact to members of an object recursively.
+ *
+ * @internal
+ */
+type RecursiveTransformExact<T, FromType, ToType> = T extends Function ? T : T extends object ? {
+    [key in keyof T]: [
+        T[key]
+    ] extends [
+        FromType
+    ] ? [
+        FromType
+    ] extends [
+        T[key]
+    ] ? ToType : RecursiveTransformExact<T[key], FromType, ToType> : RecursiveTransformExact<T[key], FromType, ToType>;
+} : TransformExact<T, FromType, ToType>;
+export {};

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

@@ -0,0 +1,31 @@
+import { Message } from "./eventStream";
+/**
+ * @public
+ */
+export interface MessageEncoder {
+    encode(message: Message): Uint8Array;
+}
+/**
+ * @public
+ */
+export interface MessageDecoder {
+    decode(message: ArrayBufferView): Message;
+    feed(message: ArrayBufferView): void;
+    endOfStream(): void;
+    getMessage(): AvailableMessage;
+    getAvailableMessages(): AvailableMessages;
+}
+/**
+ * @public
+ */
+export interface AvailableMessage {
+    getMessage(): Message | undefined;
+    isEndOfStream(): boolean;
+}
+/**
+ * @public
+ */
+export interface AvailableMessages {
+    getMessages(): Message[];
+    isEndOfStream(): boolean;
+}

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

@@ -0,0 +1,77 @@
+import { AuthScheme } from "./auth/auth";
+/**
+ * @public
+ */
+export interface EndpointPartition {
+    name: string;
+    dnsSuffix: string;
+    dualStackDnsSuffix: string;
+    supportsFIPS: boolean;
+    supportsDualStack: boolean;
+}
+/**
+ * @public
+ */
+export interface EndpointARN {
+    partition: string;
+    service: string;
+    region: string;
+    accountId: string;
+    resourceId: Array<string>;
+}
+/**
+ * @public
+ */
+export declare enum EndpointURLScheme {
+    HTTP = "http",
+    HTTPS = "https"
+}
+/**
+ * @public
+ */
+export interface EndpointURL {
+    /**
+     * The URL scheme such as http or https.
+     */
+    scheme: EndpointURLScheme;
+    /**
+     * The authority is the host and optional port component of the URL.
+     */
+    authority: string;
+    /**
+     * The parsed path segment of the URL.
+     * This value is as-is as provided by the user.
+     */
+    path: string;
+    /**
+     * The parsed path segment of the URL.
+     * This value is guranteed to start and end with a "/".
+     */
+    normalizedPath: string;
+    /**
+     * A boolean indicating whether the authority is an IP address.
+     */
+    isIp: boolean;
+}
+/**
+ * @public
+ */
+export type EndpointObjectProperty = string | boolean | {
+    [key: string]: EndpointObjectProperty;
+} | EndpointObjectProperty[];
+/**
+ * @public
+ */
+export interface EndpointV2 {
+    url: URL;
+    properties?: {
+        authSchemes?: AuthScheme[];
+    } & Record<string, EndpointObjectProperty>;
+    headers?: Record<string, string[]>;
+}
+/**
+ * @public
+ */
+export type EndpointParameters = {
+    [name: string]: undefined | boolean | string | string[];
+};

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

@@ -0,0 +1,41 @@
+/**
+ * @internal
+ */
+export interface EndpointParameterInstructions {
+    [name: string]: BuiltInParamInstruction | ClientContextParamInstruction | StaticContextParamInstruction | ContextParamInstruction | OperationContextParamInstruction;
+}
+/**
+ * @internal
+ */
+export interface BuiltInParamInstruction {
+    type: "builtInParams";
+    name: string;
+}
+/**
+ * @internal
+ */
+export interface ClientContextParamInstruction {
+    type: "clientContextParams";
+    name: string;
+}
+/**
+ * @internal
+ */
+export interface StaticContextParamInstruction {
+    type: "staticContextParams";
+    value: string | boolean;
+}
+/**
+ * @internal
+ */
+export interface ContextParamInstruction {
+    type: "contextParams";
+    name: string;
+}
+/**
+ * @internal
+ */
+export interface OperationContextParamInstruction {
+    type: "operationContextParams";
+    get(input: any): any;
+}

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

@@ -0,0 +1,27 @@
+import { EndpointObjectProperty } from "../endpoint";
+import { ConditionObject, Expression } from "./shared";
+/**
+ * @public
+ */
+export type EndpointObjectProperties = Record<string, EndpointObjectProperty>;
+/**
+ * @public
+ */
+export type EndpointObjectHeaders = Record<string, Expression[]>;
+/**
+ * @public
+ */
+export type EndpointObject = {
+    url: Expression;
+    properties?: EndpointObjectProperties;
+    headers?: EndpointObjectHeaders;
+};
+/**
+ * @public
+ */
+export type EndpointRuleObject = {
+    type: "endpoint";
+    conditions?: ConditionObject[];
+    endpoint: EndpointObject;
+    documentation?: string;
+};

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

@@ -0,0 +1,10 @@
+import { ConditionObject, Expression } from "./shared";
+/**
+ * @public
+ */
+export type ErrorRuleObject = {
+    type: "error";
+    conditions?: ConditionObject[];
+    error: Expression;
+    documentation?: string;
+};

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

@@ -0,0 +1,28 @@
+import { RuleSetRules } from "./TreeRuleObject";
+/**
+ * @public
+ */
+export type DeprecatedObject = {
+    message?: string;
+    since?: string;
+};
+/**
+ * @public
+ */
+export type ParameterObject = {
+    type: "String" | "string" | "Boolean" | "boolean";
+    default?: string | boolean;
+    required?: boolean;
+    documentation?: string;
+    builtIn?: string;
+    deprecated?: DeprecatedObject;
+};
+/**
+ * @public
+ */
+export type RuleSetObject = {
+    version: string;
+    serviceId?: string;
+    parameters: Record<string, ParameterObject>;
+    rules: RuleSetRules;
+};

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

@@ -0,0 +1,16 @@
+import { EndpointRuleObject } from "./EndpointRuleObject";
+import { ErrorRuleObject } from "./ErrorRuleObject";
+import { ConditionObject } from "./shared";
+/**
+ * @public
+ */
+export type RuleSetRules = Array<EndpointRuleObject | ErrorRuleObject | TreeRuleObject>;
+/**
+ * @public
+ */
+export type TreeRuleObject = {
+    type: "tree";
+    conditions?: ConditionObject[];
+    rules: RuleSetRules;
+    documentation?: string;
+};

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

@@ -0,0 +1,5 @@
+export { EndpointObject, EndpointObjectHeaders, EndpointObjectProperties, EndpointRuleObject, } from "./EndpointRuleObject";
+export { ErrorRuleObject } from "./ErrorRuleObject";
+export { DeprecatedObject, ParameterObject, RuleSetObject } from "./RuleSetObject";
+export { ConditionObject, EndpointParams, EndpointResolverOptions, EvaluateOptions, Expression, FunctionArgv, FunctionObject, FunctionReturn, ReferenceObject, ReferenceRecord, } from "./shared";
+export { RuleSetRules, TreeRuleObject } from "./TreeRuleObject";

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

@@ -0,0 +1,55 @@
+import { Logger } from "../logger";
+/**
+ * @public
+ */
+export type ReferenceObject = {
+    ref: string;
+};
+/**
+ * @public
+ */
+export type FunctionObject = {
+    fn: string;
+    argv: FunctionArgv;
+};
+/**
+ * @public
+ */
+export type FunctionArgv = Array<Expression | boolean | number>;
+/**
+ * @public
+ */
+export type FunctionReturn = string | boolean | number | {
+    [key: string]: FunctionReturn;
+};
+/**
+ * @public
+ */
+export type ConditionObject = FunctionObject & {
+    assign?: string;
+};
+/**
+ * @public
+ */
+export type Expression = string | ReferenceObject | FunctionObject;
+/**
+ * @public
+ */
+export type EndpointParams = Record<string, string | boolean>;
+/**
+ * @public
+ */
+export type EndpointResolverOptions = {
+    endpointParams: EndpointParams;
+    logger?: Logger;
+};
+/**
+ * @public
+ */
+export type ReferenceRecord = Record<string, FunctionReturn>;
+/**
+ * @public
+ */
+export type EvaluateOptions = EndpointResolverOptions & {
+    referenceRecord: ReferenceRecord;
+};

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

@@ -0,0 +1,137 @@
+import { HttpRequest } from "./http";
+import { FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext } from "./middleware";
+import { MetadataBearer } from "./response";
+/**
+ * An event stream message. The headers and body properties will always be
+ * defined, with empty headers represented as an object with no keys and an
+ * empty body represented as a zero-length Uint8Array.
+ *
+ * @public
+ */
+export interface Message {
+    headers: MessageHeaders;
+    body: Uint8Array;
+}
+/**
+ * @public
+ */
+export type MessageHeaders = Record<string, MessageHeaderValue>;
+/**
+ * @public
+ */
+export type HeaderValue<K extends string, V> = {
+    type: K;
+    value: V;
+};
+/**
+ * @public
+ */
+export type BooleanHeaderValue = HeaderValue<"boolean", boolean>;
+/**
+ * @public
+ */
+export type ByteHeaderValue = HeaderValue<"byte", number>;
+/**
+ * @public
+ */
+export type ShortHeaderValue = HeaderValue<"short", number>;
+/**
+ * @public
+ */
+export type IntegerHeaderValue = HeaderValue<"integer", number>;
+/**
+ * @public
+ */
+export type LongHeaderValue = HeaderValue<"long", Int64>;
+/**
+ * @public
+ */
+export type BinaryHeaderValue = HeaderValue<"binary", Uint8Array>;
+/**
+ * @public
+ */
+export type StringHeaderValue = HeaderValue<"string", string>;
+/**
+ * @public
+ */
+export type TimestampHeaderValue = HeaderValue<"timestamp", Date>;
+/**
+ * @public
+ */
+export type UuidHeaderValue = HeaderValue<"uuid", string>;
+/**
+ * @public
+ */
+export type MessageHeaderValue = BooleanHeaderValue | ByteHeaderValue | ShortHeaderValue | IntegerHeaderValue | LongHeaderValue | BinaryHeaderValue | StringHeaderValue | TimestampHeaderValue | UuidHeaderValue;
+/**
+ * @public
+ */
+export interface Int64 {
+    readonly bytes: Uint8Array;
+    valueOf: () => number;
+    toString: () => string;
+}
+/**
+ * Util functions for serializing or deserializing event stream
+ *
+ * @public
+ */
+export interface EventStreamSerdeContext {
+    eventStreamMarshaller: EventStreamMarshaller;
+}
+/**
+ * A function which deserializes binary event stream message into modeled shape.
+ *
+ * @public
+ */
+export interface EventStreamMarshallerDeserFn<StreamType> {
+    <T>(body: StreamType, deserializer: (input: Record<string, Message>) => Promise<T>): AsyncIterable<T>;
+}
+/**
+ * A function that serializes modeled shape into binary stream message.
+ *
+ * @public
+ */
+export interface EventStreamMarshallerSerFn<StreamType> {
+    <T>(input: AsyncIterable<T>, serializer: (event: T) => Message): StreamType;
+}
+/**
+ * An interface which provides functions for serializing and deserializing binary event stream
+ * to/from corresponsing modeled shape.
+ *
+ * @public
+ */
+export interface EventStreamMarshaller<StreamType = any> {
+    deserialize: EventStreamMarshallerDeserFn<StreamType>;
+    serialize: EventStreamMarshallerSerFn<StreamType>;
+}
+/**
+ * @public
+ */
+export interface EventStreamRequestSigner {
+    sign(request: HttpRequest): Promise<HttpRequest>;
+}
+/**
+ * @public
+ */
+export interface EventStreamPayloadHandler {
+    handle: <Input extends object, Output extends MetadataBearer>(next: FinalizeHandler<Input, Output>, args: FinalizeHandlerArguments<Input>, context?: HandlerExecutionContext) => Promise<FinalizeHandlerOutput<Output>>;
+}
+/**
+ * @public
+ */
+export interface EventStreamPayloadHandlerProvider {
+    (options: any): EventStreamPayloadHandler;
+}
+/**
+ * @public
+ */
+export interface EventStreamSerdeProvider {
+    (options: any): EventStreamMarshaller;
+}
+/**
+ * @public
+ */
+export interface EventStreamSignerProvider {
+    (options: any): EventStreamRequestSigner;
+}

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

@@ -0,0 +1,58 @@
+import { ChecksumConstructor } from "../checksum";
+import { HashConstructor } from "../crypto";
+/**
+ * @internal
+ */
+export declare enum AlgorithmId {
+    MD5 = "md5",
+    CRC32 = "crc32",
+    CRC32C = "crc32c",
+    SHA1 = "sha1",
+    SHA256 = "sha256"
+}
+/**
+ * @internal
+ */
+export interface ChecksumAlgorithm {
+    algorithmId(): AlgorithmId | string;
+    checksumConstructor(): ChecksumConstructor | HashConstructor;
+}
+/**
+ * @deprecated unused.
+ * @internal
+ */
+type ChecksumConfigurationLegacy = {
+    [other in string | number]: any;
+};
+/**
+ * @internal
+ */
+export interface ChecksumConfiguration extends ChecksumConfigurationLegacy {
+    addChecksumAlgorithm(algo: ChecksumAlgorithm): void;
+    checksumAlgorithms(): ChecksumAlgorithm[];
+}
+/**
+ * @deprecated will be removed for implicit type.
+ * @internal
+ */
+type GetChecksumConfigurationType = (runtimeConfig: Partial<{
+    sha256: ChecksumConstructor | HashConstructor;
+    md5: ChecksumConstructor | HashConstructor;
+}>) => ChecksumConfiguration;
+/**
+ * @internal
+ * @deprecated will be moved to smithy-client.
+ */
+export declare const getChecksumConfiguration: GetChecksumConfigurationType;
+/**
+ * @internal
+ * @deprecated will be removed for implicit type.
+ */
+type ResolveChecksumRuntimeConfigType = (clientConfig: ChecksumConfiguration) => any;
+/**
+ * @internal
+ *
+ * @deprecated will be moved to smithy-client.
+ */
+export declare const resolveChecksumRuntimeConfig: ResolveChecksumRuntimeConfigType;
+export {};