@aws-sdk/types 3.347.0 → 3.369.0

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

@@ -1,52 +1 @@
-import { Command } from "./command";
-import { MiddlewareStack } from "./middleware";
-import { MetadataBearer } from "./response";
-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 {};
+export { Client } from "@smithy/types";

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

@@ -1,17 +1 @@
-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 { Command } from "@smithy/types";

package/dist-types/ts3.4/connection.d.ts

@@ -0,0 +1,6 @@
+export {
+  ConnectConfiguration,
+  ConnectionManager,
+  ConnectionManagerConfiguration,
+  ConnectionPool,
+} from "@smithy/types";

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

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

package/dist-types/ts3.4/encode.d.ts

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

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

@@ -1,43 +1,9 @@
-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 type EndpointObjectProperty =
-  | string
-  | boolean
-  | {
-      [key: string]: EndpointObjectProperty;
-    }
-  | EndpointObjectProperty[];
-export interface EndpointV2 {
-  url: URL;
-  properties?: {
-    authSchemes?: AuthScheme[];
-  } & Record<string, EndpointObjectProperty>;
-  headers?: Record<string, string[]>;
-}
-export type EndpointParameters = {
-  [name: string]: undefined | string | boolean;
-};
+export {
+  EndpointARN,
+  EndpointPartition,
+  EndpointURLScheme,
+  EndpointURL,
+  EndpointObjectProperty,
+  EndpointV2,
+  EndpointParameters,
+} from "@smithy/types";

package/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/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/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/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/dist-types/ts3.4/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./abort";
 export * from "./auth";
+export * from "./blob/blob-types";
 export * from "./checksum";
 export * from "./client";
 export * from "./command";

package/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/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/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/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/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;
 }