@aws-sdk/types
- Version 3.296.0
- Published
- 114 kB
- 1 dependency
- Apache-2.0 license
Install
npm i @aws-sdk/types
yarn add @aws-sdk/types
pnpm add @aws-sdk/types
Overview
Types for the AWS SDK
Index
Interfaces
Enums
Type Aliases
- AwsCredentialIdentityProvider
- CredentialProvider
- DateInput
- DocumentType
- EndpointObjectProperty
- EndpointParameters
- ExponentialBackoffJitterType
- Handler
- HeaderBag
- IniSection
- LoginIdentityProvider
- LogLevel
- MessageHeaders
- MessageHeaderValue
- MiddlewareType
- Paginator
- ParsedIniData
- Priority
- QueryParameterBag
- Relation
- RelativeMiddlewareOptions
- RequestHandlerOutput
- RetryErrorType
- SdkError
- SdkStream
- SourceData
- Step
- TokenIdentityProvider
- TokenProvider
- UserAgent
- UserAgentPair
- WithSdkStreamMixin
Interfaces
interface AbortController
interface AbortController {}
The AWS SDK uses a Controller/Signal model to allow for cooperative cancellation of asynchronous operations. When initiating such an operation, the caller can create an AbortController and then provide linked signal to subtasks. This allows a single source to communicate to multiple consumers that an action has been aborted without dictating how that cancellation should be handled.
See Also
https://developer.mozilla.org/en-US/docs/Web/API/AbortController
Modifiers
@public
interface AbortHandler
interface AbortHandler {}
Modifiers
@public
call signature
(this: AbortSignal, ev: any): any;
interface AbortSignal
interface AbortSignal {}
Holders of an AbortSignal object may query if the associated operation has been aborted and register an onabort handler.
See Also
https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
Modifiers
@public
interface AbsoluteLocation
interface AbsoluteLocation {}
Modifiers
@public
property priority
priority?: Priority;
By default middleware will be added to individual step in un-guaranteed order. In the case that
interface AnonymousIdentity
interface AnonymousIdentity extends Identity {}
Modifiers
@public
interface AwsCredentialIdentity
interface AwsCredentialIdentity extends Identity {}
Modifiers
@public
property accessKeyId
readonly accessKeyId: string;
AWS access key ID
property secretAccessKey
readonly secretAccessKey: string;
AWS secret access key
property sessionToken
readonly sessionToken?: string;
A security or session token to use with these credentials. Usually present for temporary credentials.
interface BinaryHeaderValue
interface BinaryHeaderValue {}
Modifiers
@public
interface BodyLengthCalculator
interface BodyLengthCalculator {}
A function that, given a request body, determines the length of the body. This is used to determine the Content-Length that should be sent with a request.
Example 1
A function that reads a file stream and calculates the size of the file.
Modifiers
@public
call signature
(body: any): number | undefined;
interface BooleanHeaderValue
interface BooleanHeaderValue {}
Modifiers
@public
interface BuildHandler
interface BuildHandler<Input extends object, Output extends object> {}
Modifiers
@public
call signature
(args: BuildHandlerArguments<Input>): Promise<BuildHandlerOutput<Output>>;
interface BuildHandlerArguments
interface BuildHandlerArguments<Input extends object> extends FinalizeHandlerArguments<Input> {}
Modifiers
@public
interface BuildHandlerOptions
interface BuildHandlerOptions extends HandlerOptions {}
Modifiers
@public
property step
step: 'build';
interface BuildHandlerOutput
interface BuildHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {}
Modifiers
@public
interface BuildMiddleware
interface BuildMiddleware<Input extends object, Output extends object> {}
Modifiers
@public
call signature
( next: BuildHandler<Input, Output>, context: HandlerExecutionContext): BuildHandler<Input, Output>;
interface ByteHeaderValue
interface ByteHeaderValue {}
Modifiers
@public
interface Checksum
interface Checksum {}
An object that provides a checksum of data provided in chunks to
update
. The checksum may be performed incrementally as chunks are received or all at once when the checksum is finalized, depending on the underlying implementation.It's recommended to compute checksum incrementally to avoid reading the entire payload in memory.
A class that implements this interface may accept an optional secret key in its constructor while computing checksum value, when using HMAC. If provided, this secret key would be used when computing checksum.
Modifiers
@public
property digestLength
digestLength?: number;
Constant length of the digest created by the algorithm in bytes.
method copy
copy: () => Checksum;
Creates a new checksum object that contains a deep copy of the internal state of the current
Checksum
object.
method digest
digest: () => Promise<Uint8Array>;
Returns the digest of all of the data passed.
method mark
mark: (readLimit: number) => void;
Allows marking a checksum for checksums that support the ability to mark and reset.
Parameter readLimit
The maximum limit of bytes that can be read before the mark position becomes invalid.
method reset
reset: () => void;
Resets the checksum to its initial value.
method update
update: (chunk: Uint8Array) => void;
Adds a chunk of data for which checksum needs to be computed. This can be called many times with new data as it is streamed.
Implementations may override this method which passes second param which makes Checksum object stateless.
Parameter chunk
The buffer to update checksum with.
interface ChecksumConstructor
interface ChecksumConstructor {}
A constructor for a Checksum that may be used to calculate an HMAC. Implementing classes should not directly hold the provided key in memory beyond the lexical scope of the constructor.
Modifiers
@public
construct signature
new (secret?: SourceData): Checksum;
interface Client
interface Client< Input extends object, Output extends MetadataBearer, ResolvedClientConfiguration> {}
A general interface for service clients, idempotent to browser or node clients This type corresponds to SmithyClient(https://github.com/aws/aws-sdk-js-v3/blob/main/packages/smithy-client/src/client.ts). It's provided for using without importing the SmithyClient class.
property config
readonly config: ResolvedClientConfiguration;
property destroy
destroy: () => void;
property middlewareStack
middlewareStack: MiddlewareStack<Input, Output>;
property send
send: InvokeFunction<Input, Output, ResolvedClientConfiguration>;
interface Command
interface Command< ClientInput extends object, InputType extends ClientInput, ClientOutput extends MetadataBearer, OutputType extends ClientOutput, ResolvedConfiguration> {}
Modifiers
@public
property input
readonly input: InputType;
property middlewareStack
readonly middlewareStack: MiddlewareStack<InputType, OutputType>;
method resolveMiddleware
resolveMiddleware: ( stack: MiddlewareStack<ClientInput, ClientOutput>, configuration: ResolvedConfiguration, options: any) => Handler<InputType, OutputType>;
interface Credentials
interface Credentials extends AwsCredentialIdentity {}
An object representing temporary or permanent AWS credentials.
Modifiers
@public
Deprecated
interface Decoder
interface Decoder {}
A function that, given a string, can derive the bytes represented by that string.
Example 1
A decoder function that converts bytes to hexadecimal representation would return
new Uint8Array([0xde, 0xad, 0xbe, 0xef])
when given the string'deadbeef'
.Modifiers
@public
call signature
(input: string): Uint8Array;
interface DeserializeHandler
interface DeserializeHandler<Input extends object, Output extends object> {}
Modifiers
@public
call signature
(args: DeserializeHandlerArguments<Input>): Promise< DeserializeHandlerOutput<Output>>;
interface DeserializeHandlerArguments
interface DeserializeHandlerArguments<Input extends object> extends FinalizeHandlerArguments<Input> {}
Modifiers
@public
interface DeserializeHandlerOptions
interface DeserializeHandlerOptions extends HandlerOptions {}
Modifiers
@public
property step
step: 'deserialize';
interface DeserializeHandlerOutput
interface DeserializeHandlerOutput<Output extends object> {}
Modifiers
@public
property output
output?: Output;
property response
response: unknown;
The raw response object from runtime is deserialized to structured output object. The response object is unknown so you cannot modify it directly. When work with response, you need to guard its type to e.g. HttpResponse with 'instanceof' operand.
During the deserialize phase of the execution of a middleware stack, a deserialized response may or may not be available
interface DeserializeMiddleware
interface DeserializeMiddleware<Input extends object, Output extends object> {}
Modifiers
@public
call signature
( next: DeserializeHandler<Input, Output>, context: HandlerExecutionContext): DeserializeHandler<Input, Output>;
interface Encoder
interface Encoder {}
A function that, given a TypedArray of bytes, can produce a string representation thereof.
Example 1
An encoder function that converts bytes to hexadecimal representation would return
'deadbeef'
when givennew Uint8Array([0xde, 0xad, 0xbe, 0xef])
.Modifiers
@public
call signature
(input: Uint8Array): string;
interface Endpoint
interface Endpoint {}
interface EndpointARN
interface EndpointARN {}
Modifiers
@public
property accountId
accountId: string;
property partition
partition: string;
property region
region: string;
property resourceId
resourceId: Array<string>;
property service
service: string;
interface EndpointBearer
interface EndpointBearer {}
Interface for object requires an Endpoint set.
Modifiers
@public
property endpoint
endpoint: Provider<Endpoint>;
interface EndpointPartition
interface EndpointPartition {}
Modifiers
@public
property dnsSuffix
dnsSuffix: string;
property dualStackDnsSuffix
dualStackDnsSuffix: string;
property name
name: string;
property supportsDualStack
supportsDualStack: boolean;
property supportsFIPS
supportsFIPS: boolean;
interface EndpointURL
interface EndpointURL {}
Modifiers
@public
property authority
authority: string;
The authority is the host and optional port component of the URL.
property isIp
isIp: boolean;
A boolean indicating whether the authority is an IP address.
property normalizedPath
normalizedPath: string;
The parsed path segment of the URL. This value is guranteed to start and end with a "/".
property path
path: string;
The parsed path segment of the URL. This value is as-is as provided by the user.
property scheme
scheme: EndpointURLScheme;
The URL scheme such as http or https.
interface EndpointV2
interface EndpointV2 {}
Modifiers
@public
property headers
headers?: Record<string, string[]>;
property properties
properties?: { authSchemes?: AuthScheme[];} & Record<string, EndpointObjectProperty>;
property url
url: URL;
interface EventSigner
interface EventSigner {}
Modifiers
@public
method sign
sign: (event: FormattedEvent, options: EventSigningArguments) => Promise<string>;
Sign the individual event of the event stream.
interface EventSigningArguments
interface EventSigningArguments extends SigningArguments {}
Modifiers
@public
property priorSignature
priorSignature: string;
interface EventStreamMarshaller
interface EventStreamMarshaller<StreamType = any> {}
An interface which provides functions for serializing and deserializing binary event stream to/from corresponsing modeled shape.
Modifiers
@public
property deserialize
deserialize: EventStreamMarshallerDeserFn<StreamType>;
property serialize
serialize: EventStreamMarshallerSerFn<StreamType>;
interface EventStreamMarshallerDeserFn
interface EventStreamMarshallerDeserFn<StreamType> {}
A function which deserializes binary event stream message into modeled shape.
Modifiers
@public
call signature
<T>( body: StreamType, deserializer: (input: Record<string, Message>) => Promise<T>): AsyncIterable<T>;
interface EventStreamMarshallerSerFn
interface EventStreamMarshallerSerFn<StreamType> {}
A function that serializes modeled shape into binary stream message.
Modifiers
@public
call signature
<T>(input: AsyncIterable<T>, serializer: (event: T) => Message): StreamType;
interface EventStreamPayloadHandler
interface EventStreamPayloadHandler {}
Modifiers
@public
property handle
handle: <Input extends object, Output extends MetadataBearer>( next: FinalizeHandler<Input, Output>, args: FinalizeHandlerArguments<Input>, context?: HandlerExecutionContext) => Promise<FinalizeHandlerOutput<Output>>;
interface EventStreamPayloadHandlerProvider
interface EventStreamPayloadHandlerProvider {}
Modifiers
@public
call signature
(options: any): EventStreamPayloadHandler;
interface EventStreamRequestSigner
interface EventStreamRequestSigner {}
Modifiers
@public
method sign
sign: (request: HttpRequest) => Promise<HttpRequest>;
interface EventStreamSerdeContext
interface EventStreamSerdeContext {}
Util functions for serializing or deserializing event stream
Modifiers
@public
property eventStreamMarshaller
eventStreamMarshaller: EventStreamMarshaller;
interface EventStreamSerdeProvider
interface EventStreamSerdeProvider {}
Modifiers
@public
call signature
(options: any): EventStreamMarshaller;
interface EventStreamSignerProvider
interface EventStreamSignerProvider {}
Modifiers
@public
call signature
(options: any): EventStreamRequestSigner;
interface ExponentialBackoffStrategyOptions
interface ExponentialBackoffStrategyOptions {}
Modifiers
@public
property backoffScaleValue
backoffScaleValue?: number;
property jitterType
jitterType: ExponentialBackoffJitterType;
interface FinalizeHandler
interface FinalizeHandler<Input extends object, Output extends object> {}
Modifiers
@public
call signature
(args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>>;
Asynchronously converts an input object into an output object.
Parameter args
An object containing a input to the command as well as any associated or previously generated execution artifacts.
interface FinalizeHandlerArguments
interface FinalizeHandlerArguments<Input extends object> extends SerializeHandlerArguments<Input> {}
Modifiers
@public
property request
request: unknown;
The user input serialized as a request.
interface FinalizeHandlerOutput
interface FinalizeHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {}
Modifiers
@public
interface FinalizeRequestHandlerOptions
interface FinalizeRequestHandlerOptions extends HandlerOptions {}
Modifiers
@public
property step
step: 'finalizeRequest';
interface FinalizeRequestMiddleware
interface FinalizeRequestMiddleware<Input extends object, Output extends object> {}
A factory function that creates functions implementing the
FinalizeHandler
interface.Modifiers
@public
call signature
( next: FinalizeHandler<Input, Output>, context: HandlerExecutionContext): FinalizeHandler<Input, Output>;
Parameter next
The handler to invoke after this middleware has operated on the user input and before this middleware operates on the output.
Parameter context
Invariant data and functions for use by the handler.
interface FormattedEvent
interface FormattedEvent {}
Modifiers
@public
interface GetAwsChunkedEncodingStream
interface GetAwsChunkedEncodingStream<StreamType = any> {}
A function that returns Readable Stream which follows aws-chunked encoding stream. It optionally adds checksum if options are provided.
Modifiers
@public
call signature
( readableStream: StreamType, options: GetAwsChunkedEncodingStreamOptions): StreamType;
interface GetAwsChunkedEncodingStreamOptions
interface GetAwsChunkedEncodingStreamOptions {}
Modifiers
@public
property base64Encoder
base64Encoder?: Encoder;
property bodyLengthChecker
bodyLengthChecker: BodyLengthCalculator;
property checksumAlgorithmFn
checksumAlgorithmFn?: ChecksumConstructor | HashConstructor;
property checksumLocationName
checksumLocationName?: string;
property streamHasher
streamHasher?: StreamHasher;
interface HandlerExecutionContext
interface HandlerExecutionContext {}
Data and helper objects that are not expected to change from one execution of a composed handler to another.
Modifiers
@public
property authSchemes
authSchemes?: AuthScheme[];
Set at the same time as endpointV2.
property currentAuthConfig
currentAuthConfig?: HttpAuthDefinition;
The current auth configuration that has been set by any auth middleware and that will prevent from being set more than once.
property dynamoDbDocumentClientOptions
dynamoDbDocumentClientOptions?: Partial<{ overrideInputFilterSensitiveLog(...args: any[]): string | void; overrideOutputFilterSensitiveLog(...args: any[]): string | void;}>;
Used by DynamoDbDocumentClient.
property endpointV2
endpointV2?: EndpointV2;
Resolved by the endpointMiddleware function of
@aws-sdk/middleware-endpoint
in the serialization stage.
property logger
logger?: Logger;
A logger that may be invoked by any handler during execution of an operation.
property userAgent
userAgent?: UserAgent;
Additional user agent that inferred by middleware. It can be used to save the internal user agent sections without overriding the
customUserAgent
config in clients.
index signature
[key: string]: any;
interface HandlerOptions
interface HandlerOptions {}
Modifiers
@public
property name
name?: string;
A unique name to refer to a middleware
property step
step?: Step;
Handlers are ordered using a "step" that describes the stage of command execution at which the handler will be executed. The available steps are:
- initialize: The input is being prepared. Examples of typical initialization tasks include injecting default options computing derived parameters. - serialize: The input is complete and ready to be serialized. Examples of typical serialization tasks include input validation and building an HTTP request from user input. - build: The input has been serialized into an HTTP request, but that request may require further modification. Any request alterations will be applied to all retries. Examples of typical build tasks include injecting HTTP headers that describe a stable aspect of the request, such as
Content-Length
or a body checksum. - finalizeRequest: The request is being prepared to be sent over the wire. The request in this stage should already be semantically complete and should therefore only be altered as match the recipient's expectations. Examples of typical finalization tasks include request signing and injecting hop-by-hop headers. - deserialize: The response has arrived, the middleware here will deserialize the raw response object to structured responseUnlike initialization and build handlers, which are executed once per operation execution, finalization and deserialize handlers will be executed foreach HTTP request sent.
property tags
tags?: Array<string>;
A list of strings to any that identify the general purpose or important characteristics of a given handler.
interface Hash
interface Hash {}
An object that provides a hash of data provided in chunks to
update
. The hash may be performed incrementally as chunks are received or all at once when the hash is finalized, depending on the underlying implementation.Modifiers
@public
Deprecated
use Checksum
method digest
digest: () => Promise<Uint8Array>;
Finalizes the hash and provides a promise that will be fulfilled with the raw bytes of the calculated hash.
method update
update: (toHash: SourceData, encoding?: 'utf8' | 'ascii' | 'latin1') => void;
Adds a chunk of data to the hash. If a buffer is provided, the
encoding
argument will be ignored. If a string is provided without a specified encoding, implementations must assume UTF-8 encoding.Not all encodings are supported on all platforms, though all must support UTF-8.
interface HashConstructor
interface HashConstructor {}
A constructor for a hash that may be used to calculate an HMAC. Implementing classes should not directly hold the provided key in memory beyond the lexical scope of the constructor.
Modifiers
@public
Deprecated
construct signature
new (secret?: SourceData): Hash;
interface Headers
interface Headers extends Map<string, string> {}
A collection of key/value pairs with case-insensitive keys.
Modifiers
@public
method withHeader
withHeader: (headerName: string, headerValue: string) => Headers;
Returns a new instance of Headers with the specified header set to the provided value. Does not modify the original Headers instance.
Parameter headerName
The name of the header to add or overwrite
Parameter headerValue
The value to which the header should be set
method withoutHeader
withoutHeader: (headerName: string) => Headers;
Returns a new instance of Headers without the specified header. Does not modify the original Headers instance.
Parameter headerName
The name of the header to remove
interface HostAddress
interface HostAddress {}
Modifiers
@public
property address
address: string;
The resolved numerical address represented as a string.
property addressType
addressType: HostAddressType;
The HostAddressType of the host address.
property hostName
hostName: string;
The host name the address was resolved from.
property service
service?: string;
The service record of hostName.
interface HostResolver
interface HostResolver {}
Host Resolver interface for DNS queries
Modifiers
@public
method purgeCache
purgeCache: (args?: HostResolverArguments) => void;
Empties the cache (if implemented) for a HostResolverArguments.hostName. If HostResolverArguments.hostName is not provided, the cache (if implemented) is emptied for all host names.
Parameter args
optional arguments to empty the cache for
method reportFailureOnAddress
reportFailureOnAddress: (addr: HostAddress) => void;
Reports a failure on a HostAddress so that the cache (if implemented) can accomodate the failure and likely not return the address until it recovers.
Parameter addr
host address to report a failure on
method resolveAddress
resolveAddress: (args: HostResolverArguments) => Promise<HostAddress[]>;
Resolves the address(es) for HostResolverArguments and returns a list of addresses with (most likely) two addresses, one HostAddressType.AAAA and one HostAddressType.A. Calls to this function will likely alter the cache (if implemented) so that if there's multiple addresses, a different set will be returned on the next call. In the case of multi-answer, still only a maximum of two records should be returned. The resolver implementation is responsible for caching and rotation of the multiple addresses that get returned. Implementations don't have to explictly call getaddrinfo(), they can use high level abstractions provided in their language runtimes/libraries.
Parameter args
arguments with host name query addresses for
Returns
promise with a list of HostAddress
interface HostResolverArguments
interface HostResolverArguments {}
Modifiers
@public
interface HttpHandlerOptions
interface HttpHandlerOptions {}
Represents the options that may be passed to an Http Handler.
Modifiers
@public
property abortSignal
abortSignal?: AbortSignal;
property requestTimeout
requestTimeout?: number;
The maximum time in milliseconds that the connection phase of a request may take before the connection attempt is abandoned.
interface HttpMessage
interface HttpMessage {}
Represents an HTTP message with headers and an optional static or streaming body. bode: ArrayBuffer | ArrayBufferView | string | Uint8Array | Readable | ReadableStream;
Modifiers
@public
interface HttpRequest
interface HttpRequest extends HttpMessage, Endpoint {}
Interface an HTTP request class. Contains addressing information in addition to standard message properties.
Modifiers
@public
property method
method: string;
interface HttpResponse
interface HttpResponse extends HttpMessage {}
Represents an HTTP message as received in reply to a request. Contains a numeric status code in addition to standard message properties.
Modifiers
@public
property statusCode
statusCode: number;
interface Identity
interface Identity {}
Modifiers
@public
property expiration
readonly expiration?: Date;
A
Date
when the identity or credential will no longer be accepted.
interface IdentityProvider
interface IdentityProvider<IdentityT extends Identity> {}
Modifiers
@public
call signature
(identityProperties?: Record<string, any>): Promise<IdentityT>;
interface InitializeHandler
interface InitializeHandler<Input extends object, Output extends object> {}
Modifiers
@public
call signature
(args: InitializeHandlerArguments<Input>): Promise< InitializeHandlerOutput<Output>>;
Asynchronously converts an input object into an output object.
Parameter args
An object containing a input to the command as well as any associated or previously generated execution artifacts.
interface InitializeHandlerArguments
interface InitializeHandlerArguments<Input extends object> {}
Modifiers
@public
property input
input: Input;
User input to a command. Reflects the userland representation of the union of data types the command can effectively handle.
interface InitializeHandlerOptions
interface InitializeHandlerOptions extends HandlerOptions {}
Modifiers
@public
property step
step?: 'initialize';
interface InitializeHandlerOutput
interface InitializeHandlerOutput<Output extends object> extends DeserializeHandlerOutput<Output> {}
Modifiers
@public
property output
output: Output;
interface InitializeMiddleware
interface InitializeMiddleware<Input extends object, Output extends object> {}
A factory function that creates functions implementing the
Handler
interface.Modifiers
@public
call signature
( next: InitializeHandler<Input, Output>, context: HandlerExecutionContext): InitializeHandler<Input, Output>;
Parameter next
The handler to invoke after this middleware has operated on the user input and before this middleware operates on the output.
Parameter context
Invariant data and functions for use by the handler.
interface Int64
interface Int64 {}
Modifiers
@public
interface IntegerHeaderValue
interface IntegerHeaderValue {}
Modifiers
@public
interface Logger
interface Logger {}
Represents a logger object that is available in HandlerExecutionContext throughout the middleware stack.
Modifiers
@public
interface LoggerOptions
interface LoggerOptions {}
An object consumed by Logger constructor to initiate a logger object.
Modifiers
@public
interface LoginIdentity
interface LoginIdentity extends Identity {}
Modifiers
@public
interface LongHeaderValue
interface LongHeaderValue {}
Modifiers
@public
interface MemoizedProvider
interface MemoizedProvider<T> {}
A function that, when invoked, returns a promise that will be fulfilled with a value of type T. It memoizes the result from the previous invocation instead of calling the underlying resources every time.
You can force the provider to refresh the memoized value by invoke the function with optional parameter hash with
forceRefresh
boolean key and valuetrue
.Example 1
A function that reads credentials from IMDS service that could return expired credentials. The SDK will keep using the expired credentials until an unretryable service error requiring a force refresh of the credentials.
Modifiers
@public
call signature
(options?: { forceRefresh?: boolean }): Promise<T>;
interface Message
interface Message {}
An event stream message. The headers and body properties will always be defined, with empty headers represented as an object with no keys and an empty body represented as a zero-length Uint8Array.
Modifiers
@public
interface MiddlewareStack
interface MiddlewareStack<Input extends object, Output extends object> extends Pluggable<Input, Output> {}
A stack storing middleware. It can be resolved into a handler. It supports 2 approaches for adding middleware: 1. Adding middleware to specific step with
add()
. The order of middleware added into same step is determined by order of adding them. If one middleware needs to be executed at the front of the step or at the end of step, setpriority
options tohigh
orlow
. 2. Adding middleware to location relative to known middleware withaddRelativeTo()
. This is useful when given middleware must be executed before or after specific middleware(toMiddleware
). You can add a middleware relatively to another middleware which also added relatively. But eventually, this relative middleware chain **must** be 'anchored' by a middleware that added usingadd()
API with absolutestep
andpriority
. This mothod will throw if specifiedtoMiddleware
is not found.Modifiers
@public
method add
add: { ( middleware: InitializeMiddleware<Input, Output>, options?: InitializeHandlerOptions & AbsoluteLocation ): void; ( middleware: SerializeMiddleware<Input, Output>, options: SerializeHandlerOptions & AbsoluteLocation ): void; ( middleware: BuildMiddleware<Input, Output>, options: BuildHandlerOptions & AbsoluteLocation ): void; ( middleware: FinalizeRequestMiddleware<Input, Output>, options: FinalizeRequestHandlerOptions & AbsoluteLocation ): void; ( middleware: DeserializeMiddleware<Input, Output>, options: DeserializeHandlerOptions & AbsoluteLocation ): void;};
Add middleware to the stack to be executed during the "initialize" step, optionally specifying a priority, tags and name
Add middleware to the stack to be executed during the "serialize" step, optionally specifying a priority, tags and name
Add middleware to the stack to be executed during the "build" step, optionally specifying a priority, tags and name
Add middleware to the stack to be executed during the "finalizeRequest" step, optionally specifying a priority, tags and name
Add middleware to the stack to be executed during the "deserialize" step, optionally specifying a priority, tags and name
method addRelativeTo
addRelativeTo: ( middleware: MiddlewareType<Input, Output>, options: RelativeMiddlewareOptions) => void;
Add middleware to a stack position before or after a known middleware,optionally specifying name and tags.
method clone
clone: () => MiddlewareStack<Input, Output>;
Create a shallow clone of this stack. Step bindings and handler priorities and tags are preserved in the copy.
method concat
concat: <InputType extends Input, OutputType extends Output>( from: MiddlewareStack<InputType, OutputType>) => MiddlewareStack<InputType, OutputType>;
Create a stack containing the middlewares in this stack as well as the middlewares in the
from
stack. Neither source is modified, and step bindings and handler priorities and tags are preserved in the copy.
method identify
identify: () => string[];
Returns a list of the current order of middleware in the stack. This does not execute the middleware functions, nor does it provide a reference to the stack itself.
method remove
remove: (toRemove: MiddlewareType<Input, Output> | string) => boolean;
Removes middleware from the stack.
If a string is provided, it will be treated as middleware name. If a middleware is inserted with the given name, it will be removed.
If a middleware class is provided, all usages thereof will be removed.
method removeByTag
removeByTag: (toRemove: string) => boolean;
Removes middleware that contains given tag
Multiple middleware will potentially be removed
method resolve
resolve: <InputType extends Input, OutputType extends Output>( handler: DeserializeHandler<InputType, OutputType>, context: HandlerExecutionContext) => InitializeHandler<InputType, OutputType>;
Builds a single handler function from zero or more middleware classes and a core handler. The core handler is meant to send command objects to AWS services and return promises that will resolve with the operation result or be rejected with an error.
When a composed handler is invoked, the arguments will pass through all middleware in a defined order, and the return from the innermost handler will pass through all middleware in the reverse of that order.
method use
use: (pluggable: Pluggable<Input, Output>) => void;
Apply a customization function to mutate the middleware stack, often used for customizations that requires mutating multiple middleware.
interface PaginationConfiguration
interface PaginationConfiguration {}
Expected paginator configuration passed to an operation. Services will extend this interface definition and may type client further.
Modifiers
@public
property client
client: Client<any, any, any>;
property pageSize
pageSize?: number;
property startingToken
startingToken?: any;
property stopOnSameToken
stopOnSameToken?: boolean;
For some APIs, such as CloudWatchLogs events, the next page token will always be present.
When true, this config field will have the paginator stop when the token doesn't change instead of when it is not present.
interface Pluggable
interface Pluggable<Input extends object, Output extends object> {}
Modifiers
@public
property applyToStack
applyToStack: (stack: MiddlewareStack<Input, Output>) => void;
A function that mutate the passed in middleware stack. Functions implementing this interface can add, remove, modify existing middleware stack from clients or commands
interface Profile
interface Profile extends IniSection {}
interface Provider
interface Provider<T> {}
A function that, when invoked, returns a promise that will be fulfilled with a value of type T.
Example 1
A function that reads credentials from shared SDK configuration files, assuming roles and collecting MFA tokens as necessary.
Modifiers
@public
call signature
(): Promise<T>;
interface randomValues
interface randomValues {}
A function that returns a promise fulfilled with bytes from a cryptographically secure pseudorandom number generator.
Modifiers
@public
call signature
(byteLength: number): Promise<Uint8Array>;
interface RegionInfo
interface RegionInfo {}
Object containing regionalization information of AWS services.
Modifiers
@public
property hostname
hostname: string;
property partition
partition: string;
property path
path?: string;
property signingRegion
signingRegion?: string;
property signingService
signingService?: string;
interface RegionInfoProvider
interface RegionInfoProvider {}
Function returns designated service's regionalization information from given region. Each service client comes with its regionalization provider. it serves to provide the default values of related configurations
Modifiers
@public
call signature
(region: string, options?: RegionInfoProviderOptions): Promise< RegionInfo | undefined>;
interface RegionInfoProviderOptions
interface RegionInfoProviderOptions {}
Options to pass when calling RegionInfoProvider
Modifiers
@public
property useDualstackEndpoint
useDualstackEndpoint: boolean;
Enables IPv6/IPv4 dualstack endpoint.
property useFipsEndpoint
useFipsEndpoint: boolean;
Enables FIPS compatible endpoints.
interface RelativeLocation
interface RelativeLocation {}
Modifiers
@public
property relation
relation: Relation;
Specify the relation to be before or after a know middleware.
property toMiddleware
toMiddleware: string;
A known middleware name to indicate inserting middleware's location.
interface RequestContext
interface RequestContext {}
property destination
destination: URL;
interface RequestHandler
interface RequestHandler<RequestType, ResponseType, HandlerOptions = {}> {}
Modifiers
@public
property destroy
destroy?: () => void;
property handle
handle: ( request: RequestType, handlerOptions?: HandlerOptions) => Promise<RequestHandlerOutput<ResponseType>>;
property metadata
metadata?: RequestHandlerMetadata;
metadata contains information of a handler. For example 'h2' refers this handler is for handling HTTP/2 requests, whereas 'h1' refers handling HTTP1 requests
interface RequestHandlerMetadata
interface RequestHandlerMetadata {}
Modifiers
@public
property handlerProtocol
handlerProtocol: RequestHandlerProtocol | string;
interface RequestPresigner
interface RequestPresigner {}
Modifiers
@public
method presign
presign: ( requestToSign: HttpRequest, options?: RequestPresigningArguments) => Promise<HttpRequest>;
Signs a request for future use.
The request will be valid until either the provided
expiration
time has passed or the underlying credentials have expired.Parameter requestToSign
The request that should be signed.
Parameter options
Additional signing options.
interface RequestPresigningArguments
interface RequestPresigningArguments extends RequestSigningArguments {}
Modifiers
@public
property expiresIn
expiresIn?: number;
The number of seconds before the presigned URL expires
property unhoistableHeaders
unhoistableHeaders?: Set<string>;
A set of strings whose representing headers that should not be hoisted to presigned request's query string. If not supplied, the presigner moves all the AWS-specific headers (starting with
x-amz-
) to the request query string. If supplied, these headers remain in the presigned request's header. All headers in the provided request will have their names converted to lower case and then checked for existence in the unhoistableHeaders set.
interface RequestSerializer
interface RequestSerializer<Request, Context extends EndpointBearer = any> {}
Modifiers
@public
call signature
(input: any, context: Context): Promise<Request>;
Converts the provided
input
into a request objectParameter input
The user input to serialize.
Parameter context
Context containing runtime-specific util functions.
interface RequestSigner
interface RequestSigner {}
An object that signs request objects with AWS credentials using one of the AWS authentication protocols.
Modifiers
@public
method sign
sign: ( requestToSign: HttpRequest, options?: RequestSigningArguments) => Promise<HttpRequest>;
Sign the provided request for immediate dispatch.
interface RequestSigningArguments
interface RequestSigningArguments extends SigningArguments {}
Modifiers
@public
property signableHeaders
signableHeaders?: Set<string>;
A set of strings whose members represents headers that should be signed. Any values passed here will override those provided via unsignableHeaders, allowing them to be signed.
All headers in the provided request will have their names converted to lower case before signing.
property unsignableHeaders
unsignableHeaders?: Set<string>;
A set of strings whose members represents headers that cannot be signed. All headers in the provided request will have their names converted to lower case and then checked for existence in the unsignableHeaders set.
interface ResolvedHttpResponse
interface ResolvedHttpResponse extends HttpResponse {}
Represents HTTP message whose body has been resolved to a string. This is used in parsing http message.
Modifiers
@public
property body
body: string;
interface ResponseDeserializer
interface ResponseDeserializer<OutputType, ResponseType = any, Context = any> {}
Modifiers
@public
call signature
(output: ResponseType, context: Context): Promise<OutputType>;
Converts the output of an operation into JavaScript types.
Parameter output
The HTTP response received from the service
Parameter context
context containing runtime-specific util functions.
interface RetryableTrait
interface RetryableTrait {}
A structure shape with the error trait. https://smithy.io/2.0/spec/behavior-traits.html#smithy-api-retryable-trait
Modifiers
@public
property throttling
readonly throttling?: boolean;
Indicates that the error is a retryable throttling error.
interface RetryBackoffStrategy
interface RetryBackoffStrategy {}
Modifiers
@public
method computeNextBackoffDelay
computeNextBackoffDelay: (retryAttempt: number) => number;
Returns
the number of milliseconds to wait before retrying an action.
interface RetryErrorInfo
interface RetryErrorInfo {}
Modifiers
@public
property errorType
errorType: RetryErrorType;
property retryAfterHint
retryAfterHint?: Date;
Protocol hint. This could come from Http's 'retry-after' header or something from MQTT or any other protocol that has the ability to convey retry info from a peer.
Returns
the Date after which a retry should be attempted.
interface RetryStrategy
interface RetryStrategy {}
Interface that specifies the retry behavior
Modifiers
@public
property mode
mode?: string;
The retry mode describing how the retry strategy control the traffic flow.
property retry
retry: <Input extends object, Output extends MetadataBearer>( next: FinalizeHandler<Input, Output>, args: FinalizeHandlerArguments<Input>) => Promise<FinalizeHandlerOutput<Output>>;
the retry behavior the will invoke the next handler and handle the retry accordingly. This function should also update the $metadata from the response accordingly.
See Also
interface RetryStrategyOptions
interface RetryStrategyOptions {}
Modifiers
@public
property backoffStrategy
backoffStrategy: RetryBackoffStrategy;
property maxRetriesBase
maxRetriesBase: number;
interface RetryStrategyV2
interface RetryStrategyV2 {}
Modifiers
@public
method acquireInitialRetryToken
acquireInitialRetryToken: (retryTokenScope: string) => Promise<RetryToken>;
Called before any retries (for the first call to the operation). It either returns a retry token or an error upon the failure to acquire a token prior.
tokenScope is arbitrary and out of scope for this component. However, adding it here offers us a lot of future flexibility for outage detection. For example, it could be "us-east-1" on a shared retry strategy, or "us-west-2-c:dynamodb".
method recordSuccess
recordSuccess: (token: RetryToken) => void;
Upon successful completion of the operation, a user calls this function to record that the operation was successful.
method refreshRetryTokenForRetry
refreshRetryTokenForRetry: ( tokenToRenew: RetryToken, errorInfo: RetryErrorInfo) => Promise<RetryToken>;
After a failed operation call, this function is invoked to refresh the retryToken returned by acquireInitialRetryToken(). This function can either choose to allow another retry and send a new or updated token, or reject the retry attempt and report the error either in an exception or returning an error.
interface RetryToken
interface RetryToken {}
Modifiers
@public
method getRetryCount
getRetryCount: () => number;
Returns
the current count of retry.
method getRetryDelay
getRetryDelay: () => number;
Returns
the number of milliseconds to wait before retrying an action.
interface SdkStreamMixin
interface SdkStreamMixin {}
The interface contains mix-in utility functions to transfer the runtime-specific stream implementation to specified format. Each stream can ONLY be transformed once.
property transformToByteArray
transformToByteArray: () => Promise<Uint8Array>;
property transformToString
transformToString: (encoding?: string) => Promise<string>;
property transformToWebStream
transformToWebStream: () => ReadableStream;
interface SerdeContext
interface SerdeContext extends EndpointBearer {}
Request and Response serde util functions and settings for AWS services
Modifiers
@public
property base64Decoder
base64Decoder: Decoder;
property base64Encoder
base64Encoder: Encoder;
property disableHostPrefix
disableHostPrefix: boolean;
property requestHandler
requestHandler: RequestHandler<any, any>;
property streamCollector
streamCollector: StreamCollector;
property utf8Decoder
utf8Decoder: Decoder;
property utf8Encoder
utf8Encoder: Encoder;
interface SerializeHandler
interface SerializeHandler<Input extends object, Output extends object> {}
Modifiers
@public
call signature
(args: SerializeHandlerArguments<Input>): Promise< SerializeHandlerOutput<Output>>;
Asynchronously converts an input object into an output object.
Parameter args
An object containing a input to the command as well as any associated or previously generated execution artifacts.
interface SerializeHandlerArguments
interface SerializeHandlerArguments<Input extends object> extends InitializeHandlerArguments<Input> {}
Modifiers
@public
property request
request?: unknown;
The user input serialized as a request object. The request object is unknown, so you cannot modify it directly. When work with request, you need to guard its type to e.g. HttpRequest with 'instanceof' operand
During the build phase of the execution of a middleware stack, a built request may or may not be available.
interface SerializeHandlerOptions
interface SerializeHandlerOptions extends HandlerOptions {}
Modifiers
@public
property step
step: 'serialize';
interface SerializeHandlerOutput
interface SerializeHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {}
Modifiers
@public
interface SerializeMiddleware
interface SerializeMiddleware<Input extends object, Output extends object> {}
A factory function that creates functions implementing the
BuildHandler
interface.Modifiers
@public
call signature
( next: SerializeHandler<Input, Output>, context: HandlerExecutionContext): SerializeHandler<Input, Output>;
Parameter next
The handler to invoke after this middleware has operated on the user input and before this middleware operates on the output.
Parameter context
Invariant data and functions for use by the handler.
interface SharedConfigFiles
interface SharedConfigFiles {}
Modifiers
@public
property configFile
configFile: ParsedIniData;
property credentialsFile
credentialsFile: ParsedIniData;
interface ShortHeaderValue
interface ShortHeaderValue {}
Modifiers
@public
interface SigningArguments
interface SigningArguments {}
Modifiers
@public
property signingDate
signingDate?: DateInput;
The date and time to be used as signature metadata. This value should be a Date object, a unix (epoch) timestamp, or a string that can be understood by the JavaScript
Date
constructor.If not supplied, the value returned bynew Date()
will be used.
property signingRegion
signingRegion?: string;
The region name to sign the request. It will override the signing region of the signer in current invocation
property signingService
signingService?: string;
The service signing name. It will override the service name of the signer in current invocation
interface SmithyException
interface SmithyException {}
Type that is implemented by all Smithy shapes marked with the error trait.
Modifiers
@public
Deprecated
property $fault
readonly $fault: 'client' | 'server';
Whether the client or server are at fault.
property $response
readonly $response?: HttpResponse;
Reference to low-level HTTP response object.
property $retryable
readonly $retryable?: RetryableTrait;
Indicates that an error MAY be retried by the client.
property $service
readonly $service?: string;
The service that encountered the exception.
property name
readonly name: string;
The shape ID name of the exception.
interface StandardRetryBackoffStrategy
interface StandardRetryBackoffStrategy extends RetryBackoffStrategy {}
Modifiers
@public
method setDelayBase
setDelayBase: (delayBase: number) => void;
Sets the delayBase used to compute backoff delays.
Parameter delayBase
interface StandardRetryToken
interface StandardRetryToken extends RetryToken {}
Modifiers
@public
method getLastRetryCost
getLastRetryCost: () => number | undefined;
Returns
the cost of the last retry attemp.
method getRetryTokenCount
getRetryTokenCount: (errorInfo: RetryErrorInfo) => number;
Returns
the number of available tokens.
method hasRetryTokens
hasRetryTokens: (errorType: RetryErrorType) => boolean;
Returns
wheather token has remaining tokens.
method releaseRetryTokens
releaseRetryTokens: (amount?: number) => void;
Releases a number of tokens.
Parameter amount
of tokens to release.
interface StreamCollector
interface StreamCollector {}
Modifiers
@public
call signature
(stream: any): Promise<Uint8Array>;
A function that converts a stream into an array of bytes.
Parameter stream
The low-level native stream from browser or Nodejs runtime
interface StreamHasher
interface StreamHasher<StreamType = any> {}
A function that calculates the hash of a data stream. Determining the hash will consume the stream, so only replayable streams should be provided to an implementation of this interface.
Modifiers
@public
call signature
(hashCtor: HashConstructor, stream: StreamType): Promise<Uint8Array>;
interface StringHeaderValue
interface StringHeaderValue {}
Modifiers
@public
interface StringSigner
interface StringSigner {}
Modifiers
@public
method sign
sign: (stringToSign: string, options?: SigningArguments) => Promise<string>;
Sign the provided
stringToSign
for use outside of the context of request signing. Typical uses include signed policy generation.
interface Terminalware
interface Terminalware {}
A factory function that creates the terminal handler atop which a middleware stack sits.
Modifiers
@public
call signature
<Input extends object, Output extends object>( context: HandlerExecutionContext): DeserializeHandler<Input, Output>;
interface TimestampHeaderValue
interface TimestampHeaderValue {}
Modifiers
@public
interface Token
interface Token extends TokenIdentity {}
interface TokenIdentity
interface TokenIdentity extends Identity {}
Modifiers
@public
property token
readonly token: string;
The literal token string
interface UrlParser
interface UrlParser {}
Parses a URL in string form into an Endpoint object.
Modifiers
@public
call signature
(url: string | URL): Endpoint;
interface UuidHeaderValue
interface UuidHeaderValue {}
Modifiers
@public
interface WaiterConfiguration
interface WaiterConfiguration<Client> {}
Modifiers
@public
property abortController
abortController?: AbortController;
Deprecated
Use abortSignal Abort controller. Used for ending the waiter early.
property abortSignal
abortSignal?: AbortController['signal'];
Abort Signal. Used for ending the waiter early.
property client
client: Client;
Required service client
property maxDelay
maxDelay?: number;
The maximum amount of time to delay between retries in seconds. This is the ceiling of the exponential backoff. This value defaults to service default if not specified. If specified, this value MUST be greater than or equal to 1.
property maxWaitTime
maxWaitTime: number;
The amount of time in seconds a user is willing to wait for a waiter to complete.
property minDelay
minDelay?: number;
The minimum amount of time to delay between retries in seconds. This is the floor of the exponential backoff. This value defaults to service default if not specified. This value MUST be less than or equal to maxDelay and greater than 0.
Enums
enum EndpointURLScheme
enum EndpointURLScheme { HTTP = 'http', HTTPS = 'https',}
Modifiers
@public
enum HostAddressType
enum HostAddressType { AAAA = 'AAAA', A = 'A',}
DNS record types
Modifiers
@public
enum RequestHandlerProtocol
enum RequestHandlerProtocol { HTTP_0_9 = 'http/0.9', HTTP_1_0 = 'http/1.0', TDS_8_0 = 'tds/8.0',}
Type Aliases
type AwsCredentialIdentityProvider
type AwsCredentialIdentityProvider = IdentityProvider<AwsCredentialIdentity>;
Modifiers
@public
type CredentialProvider
type CredentialProvider = Provider<Credentials>;
type DateInput
type DateInput = number | string | Date;
A
Date
object, a unix (epoch) timestamp in seconds, or a string that can be understood by the JavaScriptDate
constructor.Modifiers
@public
type DocumentType
type DocumentType = | null | boolean | number | string | DocumentType[] | { [prop: string]: DocumentType; };
A document type represents an untyped JSON-like value.
Not all protocols support document types, and the serialization format of a document type is protocol specific. All JSON protocols SHOULD support document types and they SHOULD serialize document types inline as normal JSON values.
Modifiers
@public
type EndpointObjectProperty
type EndpointObjectProperty = | string | boolean | { [key: string]: EndpointObjectProperty; } | EndpointObjectProperty[];
Modifiers
@public
type EndpointParameters
type EndpointParameters = { [name: string]: undefined | string | boolean;};
Modifiers
@public
type ExponentialBackoffJitterType
type ExponentialBackoffJitterType = 'DEFAULT' | 'NONE' | 'FULL' | 'DECORRELATED';
Modifiers
@public
type Handler
type Handler<Input extends object, Output extends object> = InitializeHandler< Input, Output>;
Modifiers
@public
type HeaderBag
type HeaderBag = Record<string, string>;
A mapping of header names to string values. Multiple values for the same header should be represented as a single string with values separated by
,
.Keys should be considered case insensitive, even if this is not enforced by a particular implementation. For example, given the following HeaderBag, where keys differ only in case:
{'x-amz-date': '2000-01-01T00:00:00Z','X-Amz-Date': '2001-01-01T00:00:00Z'}The SDK may at any point during processing remove one of the object properties in favor of the other. The headers may or may not be combined, and the SDK will not deterministically select which header candidate to use.
Modifiers
@public
type IniSection
type IniSection = Record<string, string | undefined>;
Modifiers
@public
type LoginIdentityProvider
type LoginIdentityProvider = IdentityProvider<LoginIdentity>;
Modifiers
@public
type LogLevel
type LogLevel = | 'all' | 'trace' | 'debug' | 'log' | 'info' | 'warn' | 'error' | 'off';
A list of logger's log level. These levels are sorted in order of increasing severity. Each log level includes itself and all the levels behind itself.
Example 1
new Logger({logLevel: 'warn'})
will print all the warn and error message.Modifiers
@public
type MessageHeaders
type MessageHeaders = Record<string, MessageHeaderValue>;
Modifiers
@public
type MessageHeaderValue
type MessageHeaderValue = | BooleanHeaderValue | ByteHeaderValue | ShortHeaderValue | IntegerHeaderValue | LongHeaderValue | BinaryHeaderValue | StringHeaderValue | TimestampHeaderValue | UuidHeaderValue;
Modifiers
@public
type MiddlewareType
type MiddlewareType<Input extends object, Output extends object> = | InitializeMiddleware<Input, Output> | SerializeMiddleware<Input, Output> | BuildMiddleware<Input, Output> | FinalizeRequestMiddleware<Input, Output> | DeserializeMiddleware<Input, Output>;
Modifiers
@public
type Paginator
type Paginator<T> = AsyncGenerator<T, T, unknown>;
Expected type definition of a paginator.
Modifiers
@public
type ParsedIniData
type ParsedIniData = Record<string, IniSection>;
Modifiers
@public
type Priority
type Priority = 'high' | 'normal' | 'low';
Modifiers
@public
type QueryParameterBag
type QueryParameterBag = Record<string, string | Array<string> | null>;
A mapping of query parameter names to strings or arrays of strings, with the second being used when a parameter contains a list of values. Value can be set to null when query is not in key-value pairs shape
Modifiers
@public
type Relation
type Relation = 'before' | 'after';
Modifiers
@public
type RelativeMiddlewareOptions
type RelativeMiddlewareOptions = RelativeLocation & Omit<HandlerOptions, 'step'>;
Modifiers
@public
type RequestHandlerOutput
type RequestHandlerOutput<ResponseType> = { response: ResponseType;};
Modifiers
@public
type RetryErrorType
type RetryErrorType = /** * This is a connection level error such as a socket timeout, socket connect * error, tls negotiation timeout etc... * Typically these should never be applied for non-idempotent request types * since in this scenario, it's impossible to know whether the operation had * a side effect on the server. */ | 'TRANSIENT' /** * This is an error where the server explicitly told the client to back off, * such as a 429 or 503 Http error. */ | 'THROTTLING' /** * This is a server error that isn't explicitly throttling but is considered * by the client to be something that should be retried. */ | 'SERVER_ERROR' /** * Doesn't count against any budgets. This could be something like a 401 * challenge in Http. */ | 'CLIENT_ERROR';
Modifiers
@public
type SdkError
type SdkError = Error & Partial<SmithyException> & Partial<MetadataBearer>;
Modifiers
@public
Deprecated
See https://aws.amazon.com/blogs/developer/service-error-handling-modular-aws-sdk-js/
This type should not be used in your application. Users of the AWS SDK for JavaScript v3 service clients should prefer to use the specific Exception classes corresponding to each operation. These can be found as code in the deserializer for the operation's Command class, or as declarations in the service model file in codegen/sdk-codegen/aws-models.
If no exceptions are enumerated by a particular Command operation, the base exception for the service should be used. Each client exports a base ServiceException prefixed with the service name.
type SdkStream
type SdkStream<BaseStream> = BaseStream & SdkStreamMixin;
The type describing a runtime-specific stream implementation with mix-in utility functions.
Modifiers
@public
type SourceData
type SourceData = string | ArrayBuffer | ArrayBufferView;
Modifiers
@public
type Step
type Step = 'initialize' | 'serialize' | 'build' | 'finalizeRequest' | 'deserialize';
Modifiers
@public
type TokenIdentityProvider
type TokenIdentityProvider = IdentityProvider<TokenIdentity>;
Modifiers
@public
type TokenProvider
type TokenProvider = Provider<Token>;
type UserAgent
type UserAgent = UserAgentPair[];
User agent data that to be put into the request's user agent.
Modifiers
@public
type UserAgentPair
type UserAgentPair = [name: string, version?: string];
A tuple that represents an API name and optional version of a library built using the AWS SDK.
Modifiers
@public
type WithSdkStreamMixin
type WithSdkStreamMixin<T, StreamKey extends keyof T> = { [key in keyof T]: key extends StreamKey ? SdkStream<T[StreamKey]> : T[key];};
Indicates that the member of type T with key StreamKey have been extended with the SdkStreamMixin helper methods.
Modifiers
@public
Package Files (29)
- dist-types/abort.d.ts
- dist-types/checksum.d.ts
- dist-types/client.d.ts
- dist-types/command.d.ts
- dist-types/credentials.d.ts
- dist-types/crypto.d.ts
- dist-types/dns.d.ts
- dist-types/endpoint.d.ts
- dist-types/eventStream.d.ts
- dist-types/http.d.ts
- dist-types/identity/AnonymousIdentity.d.ts
- dist-types/identity/AwsCredentialIdentity.d.ts
- dist-types/identity/Identity.d.ts
- dist-types/identity/LoginIdentity.d.ts
- dist-types/identity/TokenIdentity.d.ts
- dist-types/index.d.ts
- dist-types/logger.d.ts
- dist-types/middleware.d.ts
- dist-types/pagination.d.ts
- dist-types/profile.d.ts
- dist-types/retry.d.ts
- dist-types/serde.d.ts
- dist-types/shapes.d.ts
- dist-types/signature.d.ts
- dist-types/stream.d.ts
- dist-types/token.d.ts
- dist-types/transfer.d.ts
- dist-types/util.d.ts
- dist-types/waiter.d.ts
Dependencies (1)
Dev Dependencies (6)
Peer Dependencies (0)
No peer dependencies.
Badge
To add a badge like this oneto your package's README, use the codes available below.
You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@aws-sdk/types
.
- Markdown[](https://www.jsdocs.io/package/@aws-sdk/types)
- HTML<a href="https://www.jsdocs.io/package/@aws-sdk/types"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>
- Updated .
Package analyzed in 4726 ms. - Missing or incorrect documentation? Open an issue for this package.