@ndlib/ndlib-cdk2 1.0.7 → 1.0.9

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/endpoint.d.ts

@@ -0,0 +1,43 @@
+import { AuthScheme } from "./auth";
+export interface EndpointPartition {
+  name: string;
+  dnsSuffix: string;
+  dualStackDnsSuffix: string;
+  supportsFIPS: boolean;
+  supportsDualStack: boolean;
+}
+export interface EndpointARN {
+  partition: string;
+  service: string;
+  region: string;
+  accountId: string;
+  resourceId: Array<string>;
+}
+export declare enum EndpointURLScheme {
+  HTTP = "http",
+  HTTPS = "https",
+}
+export interface EndpointURL {
+  scheme: EndpointURLScheme;
+  authority: string;
+  path: string;
+  normalizedPath: string;
+  isIp: boolean;
+}
+export declare type EndpointObjectProperty =
+  | string
+  | boolean
+  | {
+      [key: string]: EndpointObjectProperty;
+    }
+  | EndpointObjectProperty[];
+export interface EndpointV2 {
+  url: URL;
+  properties?: {
+    authSchemes?: AuthScheme[];
+  } & Record<string, EndpointObjectProperty>;
+  headers?: Record<string, string[]>;
+}
+export declare type EndpointParameters = {
+  [name: string]: undefined | string | boolean;
+};

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/eventStream.d.ts

@@ -0,0 +1,99 @@
+import { HttpRequest } from "./http";
+import {
+  FinalizeHandler,
+  FinalizeHandlerArguments,
+  FinalizeHandlerOutput,
+  HandlerExecutionContext,
+} from "./middleware";
+import { MetadataBearer } from "./response";
+export interface Message {
+  headers: MessageHeaders;
+  body: Uint8Array;
+}
+export declare type MessageHeaders = Record<string, MessageHeaderValue>;
+export interface BooleanHeaderValue {
+  type: "boolean";
+  value: boolean;
+}
+export interface ByteHeaderValue {
+  type: "byte";
+  value: number;
+}
+export interface ShortHeaderValue {
+  type: "short";
+  value: number;
+}
+export interface IntegerHeaderValue {
+  type: "integer";
+  value: number;
+}
+export interface LongHeaderValue {
+  type: "long";
+  value: Int64;
+}
+export interface BinaryHeaderValue {
+  type: "binary";
+  value: Uint8Array;
+}
+export interface StringHeaderValue {
+  type: "string";
+  value: string;
+}
+export interface TimestampHeaderValue {
+  type: "timestamp";
+  value: Date;
+}
+export interface UuidHeaderValue {
+  type: "uuid";
+  value: string;
+}
+export declare 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;
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/http.d.ts

@@ -0,0 +1,33 @@
+import { AbortSignal } from "./abort";
+export interface Headers extends Map<string, string> {
+  withHeader(headerName: string, headerValue: string): Headers;
+  withoutHeader(headerName: string): Headers;
+}
+export declare type HeaderBag = Record<string, string>;
+export interface HttpMessage {
+  headers: HeaderBag;
+  body?: any;
+}
+export declare 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, Endpoint {
+  method: string;
+}
+export interface HttpResponse extends HttpMessage {
+  statusCode: number;
+}
+export interface ResolvedHttpResponse extends HttpResponse {
+  body: string;
+}
+export interface HttpHandlerOptions {
+  abortSignal?: AbortSignal;
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/identity/AnonymousIdentity.d.ts

@@ -0,0 +1,2 @@
+import { Identity } from "./Identity";
+export interface AnonymousIdentity extends Identity {}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/identity/AwsCredentialIdentity.d.ts

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

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/identity/Identity.d.ts

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

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/identity/LoginIdentity.d.ts

@@ -0,0 +1,6 @@
+import { Identity, IdentityProvider } from "./Identity";
+export interface LoginIdentity extends Identity {
+  readonly username: string;
+  readonly password: string;
+}
+export declare type LoginIdentityProvider = IdentityProvider<LoginIdentity>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/identity/TokenIdentity.d.ts

@@ -0,0 +1,5 @@
+import { Identity, IdentityProvider } from "./Identity";
+export interface TokenIdentity extends Identity {
+  readonly token: string;
+}
+export declare type TokenIdentityProvider = IdentityProvider<TokenIdentity>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/identity/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./AnonymousIdentity";
+export * from "./AwsCredentialIdentity";
+export * from "./Identity";
+export * from "./LoginIdentity";
+export * from "./TokenIdentity";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,27 @@
+export * from "./abort";
+export * from "./auth";
+export * from "./checksum";
+export * from "./client";
+export * from "./command";
+export * from "./credentials";
+export * from "./crypto";
+export * from "./dns";
+export * from "./endpoint";
+export * from "./eventStream";
+export * from "./http";
+export * from "./identity";
+export * from "./logger";
+export * from "./middleware";
+export * from "./pagination";
+export * from "./profile";
+export * from "./request";
+export * from "./response";
+export * from "./retry";
+export * from "./serde";
+export * from "./shapes";
+export * from "./signature";
+export * from "./stream";
+export * from "./token";
+export * from "./transfer";
+export * from "./util";
+export * from "./waiter";

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/logger.d.ts

@@ -0,0 +1,20 @@
+export declare type LogLevel =
+  | "all"
+  | "trace"
+  | "debug"
+  | "log"
+  | "info"
+  | "warn"
+  | "error"
+  | "off";
+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/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/middleware.d.ts

@@ -0,0 +1,214 @@
+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 declare 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 declare 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 declare type Step =
+  | "initialize"
+  | "serialize"
+  | "build"
+  | "finalizeRequest"
+  | "deserialize";
+export declare type Priority = "high" | "normal" | "low";
+export interface HandlerOptions {
+  step?: Step;
+  tags?: Array<string>;
+  name?: string;
+  override?: boolean;
+}
+export interface AbsoluteLocation {
+  priority?: Priority;
+}
+export declare type Relation = "before" | "after";
+export interface RelativeLocation {
+  relation: Relation;
+  toMiddleware: string;
+}
+export declare 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;
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/pagination.d.ts

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

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/profile.d.ts

@@ -0,0 +1,7 @@
+export declare type IniSection = Record<string, string | undefined>;
+export interface Profile extends IniSection {}
+export declare type ParsedIniData = Record<string, IniSection>;
+export interface SharedConfigFiles {
+  credentialsFile: ParsedIniData;
+  configFile: ParsedIniData;
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/request.d.ts

@@ -0,0 +1,4 @@
+export interface Request {
+  destination: URL;
+  body?: any;
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/response.d.ts

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

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/retry.d.ts

@@ -0,0 +1,46 @@
+export declare 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 {
+  hasRetryTokens(errorType: RetryErrorType): boolean;
+  getRetryTokenCount(errorInfo: RetryErrorInfo): number;
+  getLastRetryCost(): number | undefined;
+  releaseRetryTokens(amount?: number): void;
+}
+export interface RetryStrategyV2 {
+  acquireInitialRetryToken(retryTokenScope: string): Promise<RetryToken>;
+  refreshRetryTokenForRetry(
+    tokenToRenew: RetryToken,
+    errorInfo: RetryErrorInfo
+  ): Promise<RetryToken>;
+  recordSuccess(token: RetryToken): void;
+}
+export declare type ExponentialBackoffJitterType =
+  | "DEFAULT"
+  | "NONE"
+  | "FULL"
+  | "DECORRELATED";
+export interface ExponentialBackoffStrategyOptions {
+  jitterType: ExponentialBackoffJitterType;
+  backoffScaleValue?: number;
+}

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/serde.d.ts

@@ -0,0 +1,50 @@
+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>;
+}
+declare global {
+  export interface ReadableStream {}
+  export interface Blob {}
+}
+export interface SdkStreamMixin {
+  transformToByteArray: () => Promise<Uint8Array>;
+  transformToString: (encoding?: string) => Promise<string>;
+  transformToWebStream: () => ReadableStream;
+}
+export declare type SdkStream<BaseStream> = BaseStream & SdkStreamMixin;
+export declare 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/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/shapes.d.ts

@@ -0,0 +1,24 @@
+import { HttpResponse } from "./http";
+import { MetadataBearer } from "./response";
+export declare 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 declare type SdkError = Error &
+  Partial<SmithyException> &
+  Partial<MetadataBearer>;

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/types/dist-types/ts3.4/signature.d.ts

@@ -0,0 +1,40 @@
+import { HttpRequest } from "./http";
+export declare type DateInput = number | string | Date;
+export interface SigningArguments {
+  signingDate?: DateInput;
+  signingService?: string;
+  signingRegion?: string;
+}
+export interface RequestSigningArguments extends SigningArguments {
+  unsignableHeaders?: Set<string>;
+  signableHeaders?: Set<string>;
+}
+export interface RequestPresigningArguments extends RequestSigningArguments {
+  expiresIn?: number;
+  unhoistableHeaders?: Set<string>;
+}
+export interface EventSigningArguments extends SigningArguments {
+  priorSignature: string;
+}
+export interface RequestPresigner {
+  presign(
+    requestToSign: HttpRequest,
+    options?: RequestPresigningArguments
+  ): Promise<HttpRequest>;
+}
+export interface RequestSigner {
+  sign(
+    requestToSign: HttpRequest,
+    options?: RequestSigningArguments
+  ): Promise<HttpRequest>;
+}
+export interface StringSigner {
+  sign(stringToSign: string, options?: SigningArguments): Promise<string>;
+}
+export interface FormattedEvent {
+  headers: Uint8Array;
+  payload: Uint8Array;
+}
+export interface EventSigner {
+  sign(event: FormattedEvent, options: EventSigningArguments): Promise<string>;
+}