@aws-sdk/types - npm Package Compare versions

Comparing version 3.168.0 to 3.170.0

dist-types/endpoint.d.ts

@@ -34,2 +34,7 @@ export interface EndpointPartition {
     /**
+     * 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.
@@ -36,0 +41,0 @@ */

dist-types/ts3.4/abort.d.ts

 export interface AbortHandler {
-    (this: AbortSignal, ev: any): any;
+  (this: AbortSignal, ev: any): any;
 }
 
 export interface AbortSignal {
-    
-    readonly aborted: boolean;
-    
-    onabort: AbortHandler | null;
+  readonly aborted: boolean;
+
+  onabort: AbortHandler | null;
 }
 
 export interface AbortController {
-    
-    readonly signal: AbortSignal;
-    
-    abort(): void;
+  readonly signal: AbortSignal;
+
+  abort(): void;
 }

dist-types/ts3.4/client.d.ts

@@ -5,14 +5,51 @@ import { Command } from "./command";
 
-interface InvokeFunction<InputTypes extends object, OutputTypes extends MetadataBearer, ResolvedClientConfiguration> {
-    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options?: any): Promise<OutputType>;
-    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options: any, cb: (err: any, data?: OutputType) => void): void;
-    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options?: any, cb?: (err: any, data?: OutputType) => void): Promise<OutputType> | void;
+interface InvokeFunction<
+  InputTypes extends object,
+  OutputTypes extends MetadataBearer,
+  ResolvedClientConfiguration
+> {
+  <InputType extends InputTypes, OutputType extends OutputTypes>(
+    command: Command<
+      InputTypes,
+      InputType,
+      OutputTypes,
+      OutputType,
+      ResolvedClientConfiguration
+    >,
+    options?: any
+  ): Promise<OutputType>;
+  <InputType extends InputTypes, OutputType extends OutputTypes>(
+    command: Command<
+      InputTypes,
+      InputType,
+      OutputTypes,
+      OutputType,
+      ResolvedClientConfiguration
+    >,
+    options: any,
+    cb: (err: any, data?: OutputType) => void
+  ): void;
+  <InputType extends InputTypes, OutputType extends OutputTypes>(
+    command: Command<
+      InputTypes,
+      InputType,
+      OutputTypes,
+      OutputType,
+      ResolvedClientConfiguration
+    >,
+    options?: any,
+    cb?: (err: any, data?: OutputType) => void
+  ): Promise<OutputType> | void;
 }
 
-export interface Client<Input extends object, Output extends MetadataBearer, ResolvedClientConfiguration> {
-    readonly config: ResolvedClientConfiguration;
-    middlewareStack: MiddlewareStack<Input, Output>;
-    send: InvokeFunction<Input, Output, ResolvedClientConfiguration>;
-    destroy: () => void;
+export interface Client<
+  Input extends object,
+  Output extends MetadataBearer,
+  ResolvedClientConfiguration
+> {
+  readonly config: ResolvedClientConfiguration;
+  middlewareStack: MiddlewareStack<Input, Output>;
+  send: InvokeFunction<Input, Output, ResolvedClientConfiguration>;
+  destroy: () => void;
 }
 export {};

dist-types/ts3.4/command.d.ts

 import { Handler, MiddlewareStack } from "./middleware";
 import { MetadataBearer } from "./response";
-export interface Command<ClientInput extends object, InputType extends ClientInput, ClientOutput extends MetadataBearer, OutputType extends ClientOutput, ResolvedConfiguration> {
-    readonly input: InputType;
-    readonly middlewareStack: MiddlewareStack<InputType, OutputType>;
-    resolveMiddleware(stack: MiddlewareStack<ClientInput, ClientOutput>, configuration: ResolvedConfiguration, options: any): Handler<InputType, OutputType>;
+export interface Command<
+  ClientInput extends object,
+  InputType extends ClientInput,
+  ClientOutput extends MetadataBearer,
+  OutputType extends ClientOutput,
+  ResolvedConfiguration
+> {
+  readonly input: InputType;
+  readonly middlewareStack: MiddlewareStack<InputType, OutputType>;
+  resolveMiddleware(
+    stack: MiddlewareStack<ClientInput, ClientOutput>,
+    configuration: ResolvedConfiguration,
+    options: any
+  ): Handler<InputType, OutputType>;
 }

dist-types/ts3.4/credentials.d.ts

 import { Provider } from "./util";
 
 export interface Credentials {
-    
-    readonly accessKeyId: string;
-    
-    readonly secretAccessKey: string;
-    
-    readonly sessionToken?: string;
-    
-    readonly expiration?: Date;
+  readonly accessKeyId: string;
+
+  readonly secretAccessKey: string;
+
+  readonly sessionToken?: string;
+
+  readonly expiration?: Date;
 }
 export declare type CredentialProvider = Provider<Credentials>;

dist-types/ts3.4/crypto.d.ts

 export declare type SourceData = string | ArrayBuffer | ArrayBufferView;
 
 export interface Hash {
-    
-    update(toHash: SourceData, encoding?: "utf8" | "ascii" | "latin1"): void;
-    
-    digest(): Promise<Uint8Array>;
+  update(toHash: SourceData, encoding?: "utf8" | "ascii" | "latin1"): void;
+
+  digest(): Promise<Uint8Array>;
 }
 
 export interface HashConstructor {
-    new (secret?: SourceData): Hash;
+  new (secret?: SourceData): Hash;
 }
 
 export interface StreamHasher<StreamType = any> {
-    (hashCtor: HashConstructor, stream: StreamType): Promise<Uint8Array>;
+  (hashCtor: HashConstructor, stream: StreamType): Promise<Uint8Array>;
 }
 
 export interface randomValues {
-    (byteLength: number): Promise<Uint8Array>;
+  (byteLength: number): Promise<Uint8Array>;
 }

dist-types/ts3.4/endpoint.d.ts

 export interface EndpointPartition {
-    name: string;
-    dnsSuffix: string;
-    dualStackDnsSuffix: string;
-    supportsFIPS: boolean;
-    supportsDualStack: boolean;
+  name: string;
+  dnsSuffix: string;
+  dualStackDnsSuffix: string;
+  supportsFIPS: boolean;
+  supportsDualStack: boolean;
 }
 export interface EndpointARN {
-    partition: string;
-    service: string;
-    region: string;
-    accountId: string;
-    resourceId: Array<string>;
+  partition: string;
+  service: string;
+  region: string;
+  accountId: string;
+  resourceId: Array<string>;
 }
 export declare enum EndpointURLScheme {
-    HTTP = "http",
-    HTTPS = "https"
+  HTTP = "http",
+  HTTPS = "https",
 }
 export interface EndpointURL {
-    
-    scheme: EndpointURLScheme;
-    
-    authority: string;
-    
-    path: string;
-    
-    isIp: boolean;
+  scheme: EndpointURLScheme;
+
+  authority: string;
+
+  path: string;
+
+  normalizedPath: string;
+
+  isIp: boolean;
 }
-export declare type EndpointObjectProperty = string | boolean | {
-    [key: string]: EndpointObjectProperty;
-} | EndpointObjectProperty[];
+export declare type EndpointObjectProperty =
+  | string
+  | boolean
+  | {
+      [key: string]: EndpointObjectProperty;
+    }
+  | EndpointObjectProperty[];
 export interface EndpointV2 {
-    url: URL;
-    properties?: Record<string, EndpointObjectProperty>;
-    headers?: Record<string, string[]>;
+  url: URL;
+  properties?: Record<string, EndpointObjectProperty>;
+  headers?: Record<string, string[]>;
 }

dist-types/ts3.4/eventStream.d.ts

 import { HttpRequest } from "./http";
-import { FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext } from "./middleware";
+import {
+  FinalizeHandler,
+  FinalizeHandlerArguments,
+  FinalizeHandlerOutput,
+  HandlerExecutionContext,
+} from "./middleware";
 import { MetadataBearer } from "./response";
 
 export interface Message {
-    headers: MessageHeaders;
-    body: Uint8Array;
+  headers: MessageHeaders;
+  body: Uint8Array;
 }
 export declare type MessageHeaders = Record<string, MessageHeaderValue>;
 export interface BooleanHeaderValue {
-    type: "boolean";
-    value: boolean;
+  type: "boolean";
+  value: boolean;
 }
 export interface ByteHeaderValue {
-    type: "byte";
-    value: number;
+  type: "byte";
+  value: number;
 }
 export interface ShortHeaderValue {
-    type: "short";
-    value: number;
+  type: "short";
+  value: number;
 }
 export interface IntegerHeaderValue {
-    type: "integer";
-    value: number;
+  type: "integer";
+  value: number;
 }
 export interface LongHeaderValue {
-    type: "long";
-    value: Int64;
+  type: "long";
+  value: Int64;
 }
 export interface BinaryHeaderValue {
-    type: "binary";
-    value: Uint8Array;
+  type: "binary";
+  value: Uint8Array;
 }
 export interface StringHeaderValue {
-    type: "string";
-    value: string;
+  type: "string";
+  value: string;
 }
 export interface TimestampHeaderValue {
-    type: "timestamp";
-    value: Date;
+  type: "timestamp";
+  value: Date;
 }
 export interface UuidHeaderValue {
-    type: "uuid";
-    value: string;
+  type: "uuid";
+  value: string;
 }
-export declare type MessageHeaderValue = BooleanHeaderValue | ByteHeaderValue | ShortHeaderValue | IntegerHeaderValue | LongHeaderValue | BinaryHeaderValue | StringHeaderValue | TimestampHeaderValue | UuidHeaderValue;
+export declare type MessageHeaderValue =
+  | BooleanHeaderValue
+  | ByteHeaderValue
+  | ShortHeaderValue
+  | IntegerHeaderValue
+  | LongHeaderValue
+  | BinaryHeaderValue
+  | StringHeaderValue
+  | TimestampHeaderValue
+  | UuidHeaderValue;
 export interface Int64 {
-    readonly bytes: Uint8Array;
-    valueOf: () => number;
-    toString: () => string;
+  readonly bytes: Uint8Array;
+  valueOf: () => number;
+  toString: () => string;
 }
 
 export interface EventStreamSerdeContext {
-    eventStreamMarshaller: EventStreamMarshaller;
+  eventStreamMarshaller: EventStreamMarshaller;
 }
 
 export interface EventStreamMarshallerDeserFn<StreamType> {
-    <T>(body: StreamType, deserializer: (input: Record<string, Message>) => Promise<T>): AsyncIterable<T>;
+  <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;
+  <T>(input: AsyncIterable<T>, serializer: (event: T) => Message): StreamType;
 }
 
 export interface EventStreamMarshaller<StreamType = any> {
-    deserialize: EventStreamMarshallerDeserFn<StreamType>;
-    serialize: EventStreamMarshallerSerFn<StreamType>;
+  deserialize: EventStreamMarshallerDeserFn<StreamType>;
+  serialize: EventStreamMarshallerSerFn<StreamType>;
 }
 export interface EventStreamRequestSigner {
-    sign(request: HttpRequest): Promise<HttpRequest>;
+  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>>;
+  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;
+  (options: any): EventStreamPayloadHandler;
 }
 export interface EventStreamSerdeProvider {
-    (options: any): EventStreamMarshaller;
+  (options: any): EventStreamMarshaller;
 }
 export interface EventStreamSignerProvider {
-    (options: any): EventStreamRequestSigner;
+  (options: any): EventStreamRequestSigner;
 }

dist-types/ts3.4/http.d.ts

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

dist-types/ts3.4/index.d.ts

@@ -0,0 +0,0 @@ export * from "./abort";

dist-types/ts3.4/logger.d.ts

@@ -0,14 +1,19 @@
+export declare type LogLevel =
+  | "all"
+  | "log"
+  | "info"
+  | "warn"
+  | "error"
+  | "off";
 
-export declare type LogLevel = "all" | "log" | "info" | "warn" | "error" | "off";
-
 export interface LoggerOptions {
-    logger?: Logger;
-    logLevel?: LogLevel;
+  logger?: Logger;
+  logLevel?: LogLevel;
 }
 
 export interface Logger {
-    debug(...content: any[]): void;
-    info(...content: any[]): void;
-    warn(...content: any[]): void;
-    error(...content: any[]): void;
+  debug(...content: any[]): void;
+  info(...content: any[]): void;
+  warn(...content: any[]): void;
+  error(...content: any[]): void;
 }

dist-types/ts3.4/middleware.d.ts

 import { Logger } from "./logger";
 import { UserAgent } from "./util";
 export interface InitializeHandlerArguments<Input extends object> {
-    
-    input: Input;
+  input: Input;
 }
-export interface InitializeHandlerOutput<Output extends object> extends DeserializeHandlerOutput<Output> {
-    output: Output;
+export interface InitializeHandlerOutput<Output extends object>
+  extends DeserializeHandlerOutput<Output> {
+  output: Output;
 }
-export interface SerializeHandlerArguments<Input extends object> extends InitializeHandlerArguments<Input> {
-    
-    request?: unknown;
+export interface SerializeHandlerArguments<Input extends object>
+  extends InitializeHandlerArguments<Input> {
+  request?: unknown;
 }
-export interface SerializeHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {
+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 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 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;
+  response: unknown;
+  output?: Output;
 }
-export interface InitializeHandler<Input extends object, Output extends object> {
-    
-    (args: InitializeHandlerArguments<Input>): Promise<InitializeHandlerOutput<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 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>>;
+  (args: SerializeHandlerArguments<Input>): Promise<
+    SerializeHandlerOutput<Output>
+  >;
 }
 export interface FinalizeHandler<Input extends object, Output extends object> {
-    
-    (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>>;
+  (args: FinalizeHandlerArguments<Input>): Promise<
+    FinalizeHandlerOutput<Output>
+  >;
 }
 export interface BuildHandler<Input extends object, Output extends object> {
-    (args: BuildHandlerArguments<Input>): Promise<BuildHandlerOutput<Output>>;
+  (args: BuildHandlerArguments<Input>): Promise<BuildHandlerOutput<Output>>;
 }
-export interface DeserializeHandler<Input extends object, Output extends object> {
-    (args: DeserializeHandlerArguments<Input>): Promise<DeserializeHandlerOutput<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 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 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 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>;
+  (
+    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 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 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>;
+  <Input extends object, Output extends object>(
+    context: HandlerExecutionContext
+  ): DeserializeHandler<Input, Output>;
 }
-export declare type Step = "initialize" | "serialize" | "build" | "finalizeRequest" | "deserialize";
+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;
+  step?: Step;
+
+  tags?: Array<string>;
+
+  name?: string;
+
+  override?: boolean;
 }
 export interface AbsoluteLocation {
-    
-    priority?: Priority;
+  priority?: Priority;
 }
 export declare type Relation = "before" | "after";
 export interface RelativeLocation {
-    
-    relation: Relation;
-    
-    toMiddleware: string;
+  relation: Relation;
+
+  toMiddleware: string;
 }
-export declare type RelativeMiddlewareOptions = RelativeLocation & Pick<HandlerOptions, Exclude<keyof HandlerOptions, "step">>;
+export declare type RelativeMiddlewareOptions = RelativeLocation &
+  Pick<HandlerOptions, Exclude<keyof HandlerOptions, "step">>;
 export interface InitializeHandlerOptions extends HandlerOptions {
-    step?: "initialize";
+  step?: "initialize";
 }
 export interface SerializeHandlerOptions extends HandlerOptions {
-    step: "serialize";
+  step: "serialize";
 }
 export interface BuildHandlerOptions extends HandlerOptions {
-    step: "build";
+  step: "build";
 }
 export interface FinalizeRequestHandlerOptions extends HandlerOptions {
-    step: "finalizeRequest";
+  step: "finalizeRequest";
 }
 export interface DeserializeHandlerOptions extends HandlerOptions {
-    step: "deserialize";
+  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>;
-    
-    resolve<InputType extends Input, OutputType extends Output>(handler: DeserializeHandler<InputType, OutputType>, context: HandlerExecutionContext): InitializeHandler<InputType, OutputType>;
+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>;
+
+  resolve<InputType extends Input, OutputType extends Output>(
+    handler: DeserializeHandler<InputType, OutputType>,
+    context: HandlerExecutionContext
+  ): InitializeHandler<InputType, OutputType>;
 }
 
 export interface HandlerExecutionContext {
-    
-    logger?: Logger;
-    
-    userAgent?: UserAgent;
-    [key: string]: any;
+  logger?: Logger;
+
+  userAgent?: UserAgent;
+  [key: string]: any;
 }
 export interface Pluggable<Input extends object, Output extends object> {
-    
-    applyToStack: (stack: MiddlewareStack<Input, Output>) => void;
+  applyToStack: (stack: MiddlewareStack<Input, Output>) => void;
 }

dist-types/ts3.4/pagination.d.ts

@@ -6,7 +6,7 @@ import { Client } from "./client";
 export interface PaginationConfiguration {
-    client: Client<any, any, any>;
-    pageSize?: number;
-    startingToken?: any;
-    
-    stopOnSameToken?: boolean;
+  client: Client<any, any, any>;
+  pageSize?: number;
+  startingToken?: any;
+
+  stopOnSameToken?: boolean;
 }

dist-types/ts3.4/profile.d.ts

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

dist-types/ts3.4/response.d.ts

 export interface ResponseMetadata {
-    
-    httpStatusCode?: number;
-    
-    requestId?: string;
-    
-    extendedRequestId?: string;
-    
-    cfId?: string;
-    
-    attempts?: number;
-    
-    totalRetryDelay?: number;
+  httpStatusCode?: number;
+
+  requestId?: string;
+
+  extendedRequestId?: string;
+
+  cfId?: string;
+
+  attempts?: number;
+
+  totalRetryDelay?: number;
 }
 export interface MetadataBearer {
-    
-    $metadata: ResponseMetadata;
+  $metadata: ResponseMetadata;
 }

dist-types/ts3.4/serde.d.ts

@@ -6,38 +6,41 @@ import { Endpoint } from "./http";
 export interface EndpointBearer {
-    endpoint: Provider<Endpoint>;
+  endpoint: Provider<Endpoint>;
 }
 export interface StreamCollector {
-    
-    (stream: any): Promise<Uint8Array>;
+  (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;
+  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 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 interface ResponseDeserializer<
+  OutputType,
+  ResponseType = any,
+  Context = any
+> {
+  (output: ResponseType, context: Context): Promise<OutputType>;
 }
 
 declare global {
-    export interface ReadableStream {
-    }
+  export interface ReadableStream {}
 }
 
 export interface SdkStreamMixin {
-    transformToByteArray: () => Promise<Uint8Array>;
-    transformToString: (encoding?: string) => Promise<string>;
-    transformToWebStream: () => ReadableStream;
+  transformToByteArray: () => Promise<Uint8Array>;
+  transformToString: (encoding?: string) => Promise<string>;
+  transformToWebStream: () => ReadableStream;
 }
 
 export declare type SdkStream<BaseStream> = BaseStream & SdkStreamMixin;

dist-types/ts3.4/shapes.d.ts

 import { HttpResponse } from "./http";
 import { MetadataBearer } from "./response";
 
-export declare type DocumentType = null | boolean | number | string | DocumentType[] | {
-    [prop: string]: DocumentType;
-};
+export declare type DocumentType =
+  | null
+  | boolean
+  | number
+  | string
+  | DocumentType[]
+  | {
+      [prop: string]: DocumentType;
+    };
 
 export interface RetryableTrait {
-    
-    readonly throttling?: boolean;
+  readonly throttling?: boolean;
 }
 
 export interface SmithyException {
-    
-    readonly name: string;
-    
-    readonly $fault: "client" | "server";
-    
-    readonly $service?: string;
-    
-    readonly $retryable?: RetryableTrait;
-    
-    readonly $response?: HttpResponse;
+  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>;
+export declare type SdkError = Error &
+  Partial<SmithyException> &
+  Partial<MetadataBearer>;

dist-types/ts3.4/signature.d.ts

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

dist-types/ts3.4/stream.d.ts

 import { HashConstructor, StreamHasher } from "./crypto";
 import { BodyLengthCalculator, Encoder } from "./util";
 export interface GetAwsChunkedEncodingStreamOptions {
-    base64Encoder?: Encoder;
-    bodyLengthChecker: BodyLengthCalculator;
-    checksumAlgorithmFn?: HashConstructor;
-    checksumLocationName?: string;
-    streamHasher?: StreamHasher;
+  base64Encoder?: Encoder;
+  bodyLengthChecker: BodyLengthCalculator;
+  checksumAlgorithmFn?: HashConstructor;
+  checksumLocationName?: string;
+  streamHasher?: StreamHasher;
 }
 
 export interface GetAwsChunkedEncodingStream<StreamType = any> {
-    (readableStream: StreamType, options: GetAwsChunkedEncodingStreamOptions): StreamType;
+  (
+    readableStream: StreamType,
+    options: GetAwsChunkedEncodingStreamOptions
+  ): StreamType;
 }

dist-types/ts3.4/token.d.ts

 import { Provider } from "./util";
 
 export interface Token {
-    
-    readonly token: string;
-    
-    readonly expiration?: Date;
+  readonly token: string;
+
+  readonly expiration?: Date;
 }
 export declare type TokenProvider = Provider<Token>;

dist-types/ts3.4/transfer.d.ts

 export declare type RequestHandlerOutput<ResponseType> = {
-    response: ResponseType;
+  response: ResponseType;
 };
-export interface RequestHandler<RequestType, ResponseType, HandlerOptions = {}> {
-    
-    metadata?: RequestHandlerMetadata;
-    destroy?: () => void;
-    handle: (request: RequestType, handlerOptions?: HandlerOptions) => Promise<RequestHandlerOutput<ResponseType>>;
+export interface RequestHandler<
+  RequestType,
+  ResponseType,
+  HandlerOptions = {}
+> {
+  metadata?: RequestHandlerMetadata;
+  destroy?: () => void;
+  handle: (
+    request: RequestType,
+    handlerOptions?: HandlerOptions
+  ) => Promise<RequestHandlerOutput<ResponseType>>;
 }
 export interface RequestHandlerMetadata {
-    handlerProtocol: string;
+  handlerProtocol: string;
 }

dist-types/ts3.4/util.d.ts

 import { Endpoint } from "./http";
-import { FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput } from "./middleware";
+import {
+  FinalizeHandler,
+  FinalizeHandlerArguments,
+  FinalizeHandlerOutput,
+} from "./middleware";
 import { MetadataBearer } from "./response";
 
 export interface Encoder {
-    (input: Uint8Array): string;
+  (input: Uint8Array): string;
 }
 
 export interface Decoder {
-    (input: string): Uint8Array;
+  (input: string): Uint8Array;
 }
 
 export interface Provider<T> {
-    (): Promise<T>;
+  (): Promise<T>;
 }
 
 export interface MemoizedProvider<T> {
-    (options?: {
-        forceRefresh?: boolean;
-    }): Promise<T>;
+  (options?: { forceRefresh?: boolean }): Promise<T>;
 }
 
 export interface BodyLengthCalculator {
-    (body: any): number | undefined;
+  (body: any): number | undefined;
 }
 
 export interface RetryStrategy {
-    
-    mode?: string;
-    
-    retry: <Input extends object, Output extends MetadataBearer>(next: FinalizeHandler<Input, Output>, args: FinalizeHandlerArguments<Input>) => Promise<FinalizeHandlerOutput<Output>>;
+  mode?: string;
+
+  retry: <Input extends object, Output extends MetadataBearer>(
+    next: FinalizeHandler<Input, Output>,
+    args: FinalizeHandlerArguments<Input>
+  ) => Promise<FinalizeHandlerOutput<Output>>;
 }
 
 export interface UrlParser {
-    (url: string): Endpoint;
+  (url: string): Endpoint;
 }
 
 export interface RegionInfo {
-    hostname: string;
-    partition: string;
-    path?: string;
-    signingService?: string;
-    signingRegion?: string;
+  hostname: string;
+  partition: string;
+  path?: string;
+  signingService?: string;
+  signingRegion?: string;
 }
 
 export interface RegionInfoProviderOptions {
-    
-    useDualstackEndpoint: boolean;
-    
-    useFipsEndpoint: boolean;
+  useDualstackEndpoint: boolean;
+
+  useFipsEndpoint: boolean;
 }
 
 export interface RegionInfoProvider {
-    (region: string, options?: RegionInfoProviderOptions): Promise<RegionInfo | undefined>;
+  (region: string, options?: RegionInfoProviderOptions): Promise<
+    RegionInfo | undefined
+  >;
 }
 
-export declare type UserAgentPair = [
-     string,
-     string
-];
+export declare type UserAgentPair = [string, string];
 
 export declare type UserAgent = UserAgentPair[];

dist-types/ts3.4/waiter.d.ts

 import { AbortController } from "./abort";
 export interface WaiterConfiguration<Client> {
-    
-    client: Client;
-    
-    maxWaitTime: number;
-    
-    abortController?: AbortController;
-    
-    abortSignal?: AbortController["signal"];
-    
-    minDelay?: number;
-    
-    maxDelay?: number;
+  client: Client;
+
+  maxWaitTime: number;
+
+  abortController?: AbortController;
+
+  abortSignal?: AbortController["signal"];
+
+  minDelay?: number;
+
+  maxDelay?: number;
 }

package.json

 {
   "name": "@aws-sdk/types",
-  "version": "3.168.0",
+  "version": "3.170.0",
   "main": "./dist-cjs/index.js",
@@ -45,3 +45,3 @@ "module": "./dist-es/index.js",
     "concurrently": "7.0.0",
-    "downlevel-dts": "0.7.0",
+    "downlevel-dts": "0.10.1",
     "rimraf": "3.0.2",
@@ -48,0 +48,0 @@ "typedoc": "0.19.2",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Lines of code

2128

increased by10.78%

Worsened metrics

Total package byte prevSize

170828

decreased by-0.32%

No dependency changes