@cdklabs/cdk-ecs-codedeploy 0.0.207 → 0.0.209

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

@@ -1,77 +1,24 @@
-import { HttpRequest } from "./http";
-import {
-  FinalizeHandler,
-  FinalizeHandlerArguments,
-  FinalizeHandlerOutput,
-  HandlerExecutionContext,
-} from "./middleware";
-import { MetadataBearer } from "./response";
-export interface Message {
-  headers: MessageHeaders;
-  body: Uint8Array;
-}
-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>;
-export type MessageHeaderValue =
-  | BooleanHeaderValue
-  | ByteHeaderValue
-  | ShortHeaderValue
-  | IntegerHeaderValue
-  | LongHeaderValue
-  | BinaryHeaderValue
-  | StringHeaderValue
-  | TimestampHeaderValue
-  | UuidHeaderValue;
-export interface Int64 {
-  readonly bytes: Uint8Array;
-  valueOf: () => number;
-  toString: () => string;
-}
-export interface EventStreamSerdeContext {
-  eventStreamMarshaller: EventStreamMarshaller;
-}
-export interface EventStreamMarshallerDeserFn<StreamType> {
-  <T>(
-    body: StreamType,
-    deserializer: (input: Record<string, Message>) => Promise<T>
-  ): AsyncIterable<T>;
-}
-export interface EventStreamMarshallerSerFn<StreamType> {
-  <T>(input: AsyncIterable<T>, serializer: (event: T) => Message): StreamType;
-}
-export interface EventStreamMarshaller<StreamType = any> {
-  deserialize: EventStreamMarshallerDeserFn<StreamType>;
-  serialize: EventStreamMarshallerSerFn<StreamType>;
-}
-export interface EventStreamRequestSigner {
-  sign(request: HttpRequest): Promise<HttpRequest>;
-}
-export interface EventStreamPayloadHandler {
-  handle: <Input extends object, Output extends MetadataBearer>(
-    next: FinalizeHandler<Input, Output>,
-    args: FinalizeHandlerArguments<Input>,
-    context?: HandlerExecutionContext
-  ) => Promise<FinalizeHandlerOutput<Output>>;
-}
-export interface EventStreamPayloadHandlerProvider {
-  (options: any): EventStreamPayloadHandler;
-}
-export interface EventStreamSerdeProvider {
-  (options: any): EventStreamMarshaller;
-}
-export interface EventStreamSignerProvider {
-  (options: any): EventStreamRequestSigner;
-}
-export {};
+export {
+  Message,
+  MessageHeaders,
+  BooleanHeaderValue,
+  ByteHeaderValue,
+  ShortHeaderValue,
+  IntegerHeaderValue,
+  LongHeaderValue,
+  BinaryHeaderValue,
+  StringHeaderValue,
+  TimestampHeaderValue,
+  UuidHeaderValue,
+  MessageHeaderValue,
+  Int64,
+  EventStreamSerdeContext,
+  EventStreamMarshaller,
+  EventStreamMarshallerDeserFn,
+  EventStreamMarshallerSerFn,
+  EventStreamPayloadHandler,
+  EventStreamPayloadHandlerProvider,
+  EventStreamRequestSigner,
+  EventStreamSerdeProvider,
+  EventStreamSignerProvider,
+} from "@smithy/types";

package/node_modules/@aws-sdk/types/dist-types/ts3.4/extensions/index.d.ts

@@ -0,0 +1,5 @@
+import { Provider } from "@smithy/types";
+export interface AwsRegionExtensionConfiguration {
+  setRegion(region: Provider<string>): void;
+  region(): Provider<string>;
+}

package/node_modules/@aws-sdk/types/dist-types/ts3.4/http.d.ts

@@ -1,33 +1,17 @@
-import { AbortSignal } from "./abort";
-import { URI } from "./uri";
+import { HttpResponse } from "@smithy/types";
+export {
+  Endpoint,
+  HeaderBag,
+  HttpHandlerOptions,
+  HttpMessage,
+  HttpRequest,
+  HttpResponse,
+  QueryParameterBag,
+} from "@smithy/types";
 export interface Headers extends Map<string, string> {
   withHeader(headerName: string, headerValue: string): Headers;
   withoutHeader(headerName: string): Headers;
 }
-export type HeaderBag = Record<string, string>;
-export interface HttpMessage {
-  headers: HeaderBag;
-  body?: any;
-}
-export type QueryParameterBag = Record<string, string | Array<string> | null>;
-export interface Endpoint {
-  protocol: string;
-  hostname: string;
-  port?: number;
-  path: string;
-  query?: QueryParameterBag;
-}
-export interface HttpRequest extends HttpMessage, URI {
-  method: string;
-}
-export interface HttpResponse extends HttpMessage {
-  statusCode: number;
-  reason?: string;
-}
 export interface ResolvedHttpResponse extends HttpResponse {
   body: string;
 }
-export interface HttpHandlerOptions {
-  abortSignal?: AbortSignal;
-  requestTimeout?: number;
-}

package/node_modules/@aws-sdk/types/dist-types/ts3.4/identity/AwsCredentialIdentity.d.ts

@@ -1,8 +1,4 @@
-import { Identity, IdentityProvider } from "./Identity";
-export interface AwsCredentialIdentity extends Identity {
-  readonly accessKeyId: string;
-  readonly secretAccessKey: string;
-  readonly sessionToken?: string;
-}
-export type AwsCredentialIdentityProvider =
-  IdentityProvider<AwsCredentialIdentity>;
+export {
+  AwsCredentialIdentity,
+  AwsCredentialIdentityProvider,
+} from "@smithy/types";

package/node_modules/@aws-sdk/types/dist-types/ts3.4/identity/Identity.d.ts

@@ -1,6 +1 @@
-export interface Identity {
-  readonly expiration?: Date;
-}
-export interface IdentityProvider<IdentityT extends Identity> {
-  (identityProperties?: Record<string, any>): Promise<IdentityT>;
-}
+export { Identity, IdentityProvider } from "@smithy/types";

package/node_modules/@aws-sdk/types/dist-types/ts3.4/index.d.ts

@@ -11,6 +11,7 @@ export * from "./dns";
 export * from "./encode";
 export * from "./endpoint";
 export * from "./eventStream";
+export * from "./extensions";
 export * from "./http";
 export * from "./identity";
 export * from "./logger";

package/node_modules/@aws-sdk/types/dist-types/ts3.4/logger.d.ts

@@ -1,3 +1,5 @@
+import { Logger } from "@smithy/types";
+export { Logger } from "@smithy/types";
 export type LogLevel =
   | "all"
   | "trace"
@@ -11,10 +13,3 @@ export interface LoggerOptions {
   logger?: Logger;
   logLevel?: LogLevel;
 }
-export interface Logger {
-  trace?: (...content: any[]) => void;
-  debug: (...content: any[]) => void;
-  info: (...content: any[]) => void;
-  warn: (...content: any[]) => void;
-  error: (...content: any[]) => void;
-}

package/node_modules/@aws-sdk/types/dist-types/ts3.4/middleware.d.ts

@@ -1,211 +1,40 @@
-import { AuthScheme, HttpAuthDefinition } from "./auth";
-import { EndpointV2 } from "./endpoint";
-import { Logger } from "./logger";
-import { UserAgent } from "./util";
-export interface InitializeHandlerArguments<Input extends object> {
-  input: Input;
-}
-export interface InitializeHandlerOutput<Output extends object>
-  extends DeserializeHandlerOutput<Output> {
-  output: Output;
-}
-export interface SerializeHandlerArguments<Input extends object>
-  extends InitializeHandlerArguments<Input> {
-  request?: unknown;
-}
-export interface SerializeHandlerOutput<Output extends object>
-  extends InitializeHandlerOutput<Output> {}
-export interface BuildHandlerArguments<Input extends object>
-  extends FinalizeHandlerArguments<Input> {}
-export interface BuildHandlerOutput<Output extends object>
-  extends InitializeHandlerOutput<Output> {}
-export interface FinalizeHandlerArguments<Input extends object>
-  extends SerializeHandlerArguments<Input> {
-  request: unknown;
-}
-export interface FinalizeHandlerOutput<Output extends object>
-  extends InitializeHandlerOutput<Output> {}
-export interface DeserializeHandlerArguments<Input extends object>
-  extends FinalizeHandlerArguments<Input> {}
-export interface DeserializeHandlerOutput<Output extends object> {
-  response: unknown;
-  output?: Output;
-}
-export interface InitializeHandler<
-  Input extends object,
-  Output extends object
-> {
-  (args: InitializeHandlerArguments<Input>): Promise<
-    InitializeHandlerOutput<Output>
-  >;
-}
-export type Handler<
-  Input extends object,
-  Output extends object
-> = InitializeHandler<Input, Output>;
-export interface SerializeHandler<Input extends object, Output extends object> {
-  (args: SerializeHandlerArguments<Input>): Promise<
-    SerializeHandlerOutput<Output>
-  >;
-}
-export interface FinalizeHandler<Input extends object, Output extends object> {
-  (args: FinalizeHandlerArguments<Input>): Promise<
-    FinalizeHandlerOutput<Output>
-  >;
-}
-export interface BuildHandler<Input extends object, Output extends object> {
-  (args: BuildHandlerArguments<Input>): Promise<BuildHandlerOutput<Output>>;
-}
-export interface DeserializeHandler<
-  Input extends object,
-  Output extends object
-> {
-  (args: DeserializeHandlerArguments<Input>): Promise<
-    DeserializeHandlerOutput<Output>
-  >;
-}
-export interface InitializeMiddleware<
-  Input extends object,
-  Output extends object
-> {
-  (
-    next: InitializeHandler<Input, Output>,
-    context: HandlerExecutionContext
-  ): InitializeHandler<Input, Output>;
-}
-export interface SerializeMiddleware<
-  Input extends object,
-  Output extends object
-> {
-  (
-    next: SerializeHandler<Input, Output>,
-    context: HandlerExecutionContext
-  ): SerializeHandler<Input, Output>;
-}
-export interface FinalizeRequestMiddleware<
-  Input extends object,
-  Output extends object
-> {
-  (
-    next: FinalizeHandler<Input, Output>,
-    context: HandlerExecutionContext
-  ): FinalizeHandler<Input, Output>;
-}
-export interface BuildMiddleware<Input extends object, Output extends object> {
-  (
-    next: BuildHandler<Input, Output>,
-    context: HandlerExecutionContext
-  ): BuildHandler<Input, Output>;
-}
-export interface DeserializeMiddleware<
-  Input extends object,
-  Output extends object
-> {
-  (
-    next: DeserializeHandler<Input, Output>,
-    context: HandlerExecutionContext
-  ): DeserializeHandler<Input, Output>;
-}
-export type MiddlewareType<Input extends object, Output extends object> =
-  | InitializeMiddleware<Input, Output>
-  | SerializeMiddleware<Input, Output>
-  | BuildMiddleware<Input, Output>
-  | FinalizeRequestMiddleware<Input, Output>
-  | DeserializeMiddleware<Input, Output>;
-export interface Terminalware {
-  <Input extends object, Output extends object>(
-    context: HandlerExecutionContext
-  ): DeserializeHandler<Input, Output>;
-}
-export type Step =
-  | "initialize"
-  | "serialize"
-  | "build"
-  | "finalizeRequest"
-  | "deserialize";
-export type Priority = "high" | "normal" | "low";
-export interface HandlerOptions {
-  step?: Step;
-  tags?: Array<string>;
-  name?: string;
-  override?: boolean;
-}
-export interface AbsoluteLocation {
-  priority?: Priority;
-}
-export type Relation = "before" | "after";
-export interface RelativeLocation {
-  relation: Relation;
-  toMiddleware: string;
-}
-export type RelativeMiddlewareOptions = RelativeLocation &
-  Pick<HandlerOptions, Exclude<keyof HandlerOptions, "step">>;
-export interface InitializeHandlerOptions extends HandlerOptions {
-  step?: "initialize";
-}
-export interface SerializeHandlerOptions extends HandlerOptions {
-  step: "serialize";
-}
-export interface BuildHandlerOptions extends HandlerOptions {
-  step: "build";
-}
-export interface FinalizeRequestHandlerOptions extends HandlerOptions {
-  step: "finalizeRequest";
-}
-export interface DeserializeHandlerOptions extends HandlerOptions {
-  step: "deserialize";
-}
-export interface MiddlewareStack<Input extends object, Output extends object>
-  extends Pluggable<Input, Output> {
-  add(
-    middleware: InitializeMiddleware<Input, Output>,
-    options?: InitializeHandlerOptions & AbsoluteLocation
-  ): void;
-  add(
-    middleware: SerializeMiddleware<Input, Output>,
-    options: SerializeHandlerOptions & AbsoluteLocation
-  ): void;
-  add(
-    middleware: BuildMiddleware<Input, Output>,
-    options: BuildHandlerOptions & AbsoluteLocation
-  ): void;
-  add(
-    middleware: FinalizeRequestMiddleware<Input, Output>,
-    options: FinalizeRequestHandlerOptions & AbsoluteLocation
-  ): void;
-  add(
-    middleware: DeserializeMiddleware<Input, Output>,
-    options: DeserializeHandlerOptions & AbsoluteLocation
-  ): void;
-  addRelativeTo(
-    middleware: MiddlewareType<Input, Output>,
-    options: RelativeMiddlewareOptions
-  ): void;
-  use(pluggable: Pluggable<Input, Output>): void;
-  clone(): MiddlewareStack<Input, Output>;
-  remove(toRemove: MiddlewareType<Input, Output> | string): boolean;
-  removeByTag(toRemove: string): boolean;
-  concat<InputType extends Input, OutputType extends Output>(
-    from: MiddlewareStack<InputType, OutputType>
-  ): MiddlewareStack<InputType, OutputType>;
-  identify(): string[];
-  resolve<InputType extends Input, OutputType extends Output>(
-    handler: DeserializeHandler<InputType, OutputType>,
-    context: HandlerExecutionContext
-  ): InitializeHandler<InputType, OutputType>;
-}
-export interface HandlerExecutionContext {
-  logger?: Logger;
-  userAgent?: UserAgent;
-  endpointV2?: EndpointV2;
-  authSchemes?: AuthScheme[];
-  currentAuthConfig?: HttpAuthDefinition;
-  dynamoDbDocumentClientOptions?: Partial<{
-    overrideInputFilterSensitiveLog(...args: any[]): string | void;
-    overrideOutputFilterSensitiveLog(...args: any[]): string | void;
-  }>;
-  [key: string]: any;
-}
-export interface Pluggable<Input extends object, Output extends object> {
-  applyToStack: (stack: MiddlewareStack<Input, Output>) => void;
-}
+export {
+  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 "@smithy/types";

package/node_modules/@aws-sdk/types/dist-types/ts3.4/pagination.d.ts

@@ -1,8 +1 @@
-import { Client } from "./client";
-export type Paginator<T> = AsyncGenerator<T, T, unknown>;
-export interface PaginationConfiguration {
-  client: Client<any, any, any>;
-  pageSize?: number;
-  startingToken?: any;
-  stopOnSameToken?: boolean;
-}
+export { PaginationConfiguration, Paginator } from "@smithy/types";

package/node_modules/@aws-sdk/types/dist-types/ts3.4/profile.d.ts

@@ -1,7 +1,6 @@
-export type IniSection = Record<string, string | undefined>;
-export interface Profile extends IniSection {}
-export type ParsedIniData = Record<string, IniSection>;
-export interface SharedConfigFiles {
-  credentialsFile: ParsedIniData;
-  configFile: ParsedIniData;
-}
+export {
+  IniSection,
+  Profile,
+  ParsedIniData,
+  SharedConfigFiles,
+} from "@smithy/types";

package/node_modules/@aws-sdk/types/dist-types/ts3.4/response.d.ts

@@ -1,14 +1,4 @@
-export interface ResponseMetadata {
-  httpStatusCode?: number;
-  requestId?: string;
-  extendedRequestId?: string;
-  cfId?: string;
-  attempts?: number;
-  totalRetryDelay?: number;
-}
-export interface MetadataBearer {
-  $metadata: ResponseMetadata;
-}
+export { MetadataBearer, ResponseMetadata } from "@smithy/types";
 export interface Response {
   body: any;
 }

package/node_modules/@aws-sdk/types/dist-types/ts3.4/retry.d.ts

@@ -1,43 +1,12 @@
-export type RetryErrorType =
-  | "TRANSIENT"
-  | "THROTTLING"
-  | "SERVER_ERROR"
-  | "CLIENT_ERROR";
-export interface RetryErrorInfo {
-  errorType: RetryErrorType;
-  retryAfterHint?: Date;
-}
-export interface RetryBackoffStrategy {
-  computeNextBackoffDelay(retryAttempt: number): number;
-}
-export interface StandardRetryBackoffStrategy extends RetryBackoffStrategy {
-  setDelayBase(delayBase: number): void;
-}
-export interface RetryStrategyOptions {
-  backoffStrategy: RetryBackoffStrategy;
-  maxRetriesBase: number;
-}
-export interface RetryToken {
-  getRetryCount(): number;
-  getRetryDelay(): number;
-}
-export interface StandardRetryToken extends RetryToken {
-  getRetryCost(): number | undefined;
-}
-export interface RetryStrategyV2 {
-  acquireInitialRetryToken(retryTokenScope: string): Promise<RetryToken>;
-  refreshRetryTokenForRetry(
-    tokenToRenew: RetryToken,
-    errorInfo: RetryErrorInfo
-  ): Promise<RetryToken>;
-  recordSuccess(token: RetryToken): void;
-}
-export type ExponentialBackoffJitterType =
-  | "DEFAULT"
-  | "NONE"
-  | "FULL"
-  | "DECORRELATED";
-export interface ExponentialBackoffStrategyOptions {
-  jitterType: ExponentialBackoffJitterType;
-  backoffScaleValue?: number;
-}
+export {
+  ExponentialBackoffJitterType,
+  ExponentialBackoffStrategyOptions,
+  RetryBackoffStrategy,
+  RetryErrorInfo,
+  RetryErrorType,
+  RetryStrategyOptions,
+  RetryStrategyV2,
+  RetryToken,
+  StandardRetryBackoffStrategy,
+  StandardRetryToken,
+} from "@smithy/types";

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

@@ -1,50 +1,16 @@
-import { Endpoint } from "./http";
-import { RequestHandler } from "./transfer";
-import { Decoder, Encoder, Provider } from "./util";
-export interface EndpointBearer {
-  endpoint: Provider<Endpoint>;
-}
-export interface StreamCollector {
-  (stream: any): Promise<Uint8Array>;
-}
-export interface SerdeContext extends EndpointBearer {
-  base64Encoder: Encoder;
-  base64Decoder: Decoder;
-  utf8Encoder: Encoder;
-  utf8Decoder: Decoder;
-  streamCollector: StreamCollector;
-  requestHandler: RequestHandler<any, any>;
-  disableHostPrefix: boolean;
-}
-export interface RequestSerializer<
-  Request,
-  Context extends EndpointBearer = any
-> {
-  (input: any, context: Context): Promise<Request>;
-}
-export interface ResponseDeserializer<
-  OutputType,
-  ResponseType = any,
-  Context = any
-> {
-  (output: ResponseType, context: Context): Promise<OutputType>;
-}
+export {
+  EndpointBearer,
+  StreamCollector,
+  SerdeContext,
+  ResponseDeserializer,
+  RequestSerializer,
+  SdkStreamMixin,
+  SdkStream,
+  WithSdkStreamMixin,
+  SdkStreamMixinInjector,
+  SdkStreamSerdeContext,
+} from "@smithy/types";
 declare global {
   export interface ReadableStream {}
   export interface Blob {}
 }
-export interface SdkStreamMixin {
-  transformToByteArray: () => Promise<Uint8Array>;
-  transformToString: (encoding?: string) => Promise<string>;
-  transformToWebStream: () => ReadableStream;
-}
-export type SdkStream<BaseStream> = BaseStream & SdkStreamMixin;
-export type WithSdkStreamMixin<T, StreamKey extends keyof T> = {
-  [key in keyof T]: key extends StreamKey ? SdkStream<T[StreamKey]> : T[key];
-};
-export interface SdkStreamMixinInjector {
-  (stream: unknown): SdkStreamMixin;
-}
-export interface SdkStreamSerdeContext {
-  sdkStreamMixin: SdkStreamMixinInjector;
-}

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

@@ -1,24 +1,6 @@
-import { HttpResponse } from "./http";
-import { MetadataBearer } from "./response";
-export type DocumentType =
-  | null
-  | boolean
-  | number
-  | string
-  | DocumentType[]
-  | {
-      [prop: string]: DocumentType;
-    };
-export interface RetryableTrait {
-  readonly throttling?: boolean;
-}
-export interface SmithyException {
-  readonly name: string;
-  readonly $fault: "client" | "server";
-  readonly $service?: string;
-  readonly $retryable?: RetryableTrait;
-  readonly $response?: HttpResponse;
-}
-export type SdkError = Error &
-  Partial<SmithyException> &
-  Partial<MetadataBearer>;
+export {
+  DocumentType,
+  RetryableTrait,
+  SmithyException,
+  SdkError,
+} from "@smithy/types";