@aws-sdk/types 3.357.0 → 3.369.0

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

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