@cdklabs/cdk-ecs-codedeploy 0.0.194 → 0.0.196

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

@@ -0,0 +1,77 @@
+import { AuthScheme } from "./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 | string | boolean;
+};

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+export * from "./EndpointRuleObject";
+export * from "./ErrorRuleObject";
+export * from "./RuleSetObject";
+export * from "./shared";
+export * from "./TreeRuleObject";

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

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

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

@@ -0,0 +1,108 @@
+import { HttpRequest } from "./http";
+import { FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext } from "./middleware";
+import { MetadataBearer } from "./response";
+/**
+ * @public
+ *
+ * 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.
+ */
+export interface Message {
+    headers: MessageHeaders;
+    body: Uint8Array;
+}
+/**
+ * @public
+ */
+export type MessageHeaders = Record<string, MessageHeaderValue>;
+type HeaderValue<K extends string, V> = {
+    type: K;
+    value: V;
+};
+export type BooleanHeaderValue = HeaderValue<"boolean", boolean>;
+export type ByteHeaderValue = HeaderValue<"byte", number>;
+export type ShortHeaderValue = HeaderValue<"short", number>;
+export type IntegerHeaderValue = HeaderValue<"integer", number>;
+export type LongHeaderValue = HeaderValue<"long", Int64>;
+export type BinaryHeaderValue = HeaderValue<"binary", Uint8Array>;
+export type StringHeaderValue = HeaderValue<"string", string>;
+export type TimestampHeaderValue = HeaderValue<"timestamp", Date>;
+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;
+}
+/**
+ * @public
+ *
+ * Util functions for serializing or deserializing event stream
+ */
+export interface EventStreamSerdeContext {
+    eventStreamMarshaller: EventStreamMarshaller;
+}
+/**
+ * @public
+ *
+ * A function which deserializes binary event stream message into modeled shape.
+ */
+export interface EventStreamMarshallerDeserFn<StreamType> {
+    <T>(body: StreamType, deserializer: (input: Record<string, Message>) => Promise<T>): AsyncIterable<T>;
+}
+/**
+ * @public
+ *
+ * A function that serializes modeled shape into binary stream message.
+ */
+export interface EventStreamMarshallerSerFn<StreamType> {
+    <T>(input: AsyncIterable<T>, serializer: (event: T) => Message): StreamType;
+}
+/**
+ * @public
+ *
+ * An interface which provides functions for serializing and deserializing binary event stream
+ * to/from corresponsing modeled shape.
+ */
+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;
+}
+export {};

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

@@ -1,7 +1,9 @@
+import { AbortSignal } from "./abort";
+import { URI } from "./uri";
 /**
  * @public
  *
- * @deprecated use {@link EndpointV2} from `@aws-sdk/types`.
+ * @deprecated use {@link EndpointV2} from `@smithy/types`.
  */
 export interface Endpoint {
     protocol: string;
@@ -10,6 +12,34 @@ export interface Endpoint {
     path: string;
     query?: QueryParameterBag;
 }
+/**
+ * @public
+ *
+ * Interface an HTTP request class. Contains
+ * addressing information in addition to standard message properties.
+ */
+export interface HttpRequest extends HttpMessage, URI {
+    method: string;
+}
+/**
+ * @public
+ *
+ * Represents an HTTP message as received in reply to a request. Contains a
+ * numeric status code in addition to standard message properties.
+ */
+export interface HttpResponse extends HttpMessage {
+    statusCode: number;
+}
+/**
+ * @public
+ *
+ * Represents an HTTP message with headers and an optional static or streaming
+ * body. bode: ArrayBuffer | ArrayBufferView | string | Uint8Array | Readable | ReadableStream;
+ */
+export interface HttpMessage {
+    headers: HeaderBag;
+    body?: any;
+}
 /**
  * @public
  *
@@ -18,3 +48,58 @@ export interface Endpoint {
  * to null when query is not in key-value pairs shape
  */
 export type QueryParameterBag = Record<string, string | Array<string> | null>;
+export type FieldOptions = {
+    name: string;
+    kind?: FieldPosition;
+    values?: string[];
+};
+export declare enum FieldPosition {
+    HEADER = 0,
+    TRAILER = 1
+}
+/**
+ * @public
+ *
+ * A mapping of header names to string values. Multiple values for the same
+ * header should be represented as a single string with values separated by
+ * `, `.
+ *
+ * Keys should be considered case insensitive, even if this is not enforced by a
+ * particular implementation. For example, given the following HeaderBag, where
+ * keys differ only in case:
+ *
+ * ```json
+ *    {
+ *        'x-request-date': '2000-01-01T00:00:00Z',
+ *        'X-Request-Date': '2001-01-01T00:00:00Z'
+ *    }
+ * ```
+ *
+ * The SDK may at any point during processing remove one of the object
+ * properties in favor of the other. The headers may or may not be combined, and
+ * the SDK will not deterministically select which header candidate to use.
+ */
+export type HeaderBag = Record<string, string>;
+/**
+ * @public
+ *
+ * Represents an HTTP message with headers and an optional static or streaming
+ * body. bode: ArrayBuffer | ArrayBufferView | string | Uint8Array | Readable | ReadableStream;
+ */
+export interface HttpMessage {
+    headers: HeaderBag;
+    body?: any;
+}
+/**
+ * @public
+ *
+ * Represents the options that may be passed to an Http Handler.
+ */
+export interface HttpHandlerOptions {
+    abortSignal?: AbortSignal;
+    /**
+     * The maximum time in milliseconds that the connection phase of a request
+     * may take before the connection attempt is abandoned.
+     */
+    requestTimeout?: number;
+}

package/node_modules/@smithy/types/dist-types/identity/awsCredentialIdentity.d.ts

@@ -0,0 +1,23 @@
+import { Identity, IdentityProvider } from "./identity";
+/**
+ * @public
+ */
+export interface AwsCredentialIdentity extends Identity {
+    /**
+     * AWS access key ID
+     */
+    readonly accessKeyId: string;
+    /**
+     * AWS secret access key
+     */
+    readonly secretAccessKey: string;
+    /**
+     * A security or session token to use with these credentials. Usually
+     * present for temporary credentials.
+     */
+    readonly sessionToken?: string;
+}
+/**
+ * @public
+ */
+export type AwsCredentialIdentityProvider = IdentityProvider<AwsCredentialIdentity>;

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

@@ -0,0 +1,15 @@
+/**
+ * @public
+ */
+export interface Identity {
+    /**
+     * A `Date` when the identity or credential will no longer be accepted.
+     */
+    readonly expiration?: Date;
+}
+/**
+ * @public
+ */
+export interface IdentityProvider<IdentityT extends Identity> {
+    (identityProperties?: Record<string, any>): Promise<IdentityT>;
+}

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

@@ -0,0 +1,2 @@
+export * from "./awsCredentialIdentity";
+export * from "./identity";

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

@@ -1,5 +1,27 @@
 export * from "./abort";
+export * from "./auth";
+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 * from "./eventStream";
 export * from "./http";
+export * from "./identity";
+export * from "./logger";
+export * from "./middleware";
+export * from "./pagination";
+export * from "./profile";
+export * from "./response";
+export * from "./retry";
 export * from "./serde";
+export * from "./shapes";
+export * from "./signature";
+export * from "./stream";
 export * from "./transfer";
+export * from "./uri";
 export * from "./util";
+export * from "./waiter";

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

@@ -0,0 +1,13 @@
+/**
+ * @public
+ *
+ * Represents a logger object that is available in HandlerExecutionContext
+ * throughout the middleware stack.
+ */
+export interface Logger {
+    trace?: (...content: any[]) => void;
+    debug: (...content: any[]) => void;
+    info: (...content: any[]) => void;
+    warn: (...content: any[]) => void;
+    error: (...content: any[]) => void;
+}