@aws-sdk/client-dynamodb-streams 3.50.0 → 3.53.0

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

@@ -0,0 +1,77 @@
+import { EndpointsInputConfig, EndpointsResolvedConfig, RegionInputConfig, RegionResolvedConfig } from "@aws-sdk/config-resolver";
+import { HostHeaderInputConfig, HostHeaderResolvedConfig } from "@aws-sdk/middleware-host-header";
+import { RetryInputConfig, RetryResolvedConfig } from "@aws-sdk/middleware-retry";
+import { AwsAuthInputConfig, AwsAuthResolvedConfig } from "@aws-sdk/middleware-signing";
+import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
+import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
+import { Client as __Client, DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
+import { Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@aws-sdk/types";
+import { DescribeStreamCommandInput, DescribeStreamCommandOutput } from "./commands/DescribeStreamCommand";
+import { GetRecordsCommandInput, GetRecordsCommandOutput } from "./commands/GetRecordsCommand";
+import { GetShardIteratorCommandInput, GetShardIteratorCommandOutput } from "./commands/GetShardIteratorCommand";
+import { ListStreamsCommandInput, ListStreamsCommandOutput } from "./commands/ListStreamsCommand";
+export declare type ServiceInputTypes = DescribeStreamCommandInput | GetRecordsCommandInput | GetShardIteratorCommandInput | ListStreamsCommandInput;
+export declare type ServiceOutputTypes = DescribeStreamCommandOutput | GetRecordsCommandOutput | GetShardIteratorCommandOutput | ListStreamsCommandOutput;
+export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
+    
+    requestHandler?: __HttpHandler;
+    
+    sha256?: __HashConstructor;
+    
+    urlParser?: __UrlParser;
+    
+    bodyLengthChecker?: (body: any) => number | undefined;
+    
+    streamCollector?: __StreamCollector;
+    
+    base64Decoder?: __Decoder;
+    
+    base64Encoder?: __Encoder;
+    
+    utf8Decoder?: __Decoder;
+    
+    utf8Encoder?: __Encoder;
+    
+    runtime?: string;
+    
+    disableHostPrefix?: boolean;
+    
+    maxAttempts?: number | __Provider<number>;
+    
+    retryMode?: string | __Provider<string>;
+    
+    logger?: __Logger;
+    
+    useDualstackEndpoint?: boolean | __Provider<boolean>;
+    
+    useFipsEndpoint?: boolean | __Provider<boolean>;
+    
+    serviceId?: string;
+    
+    region?: string | __Provider<string>;
+    
+    credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
+    
+    regionInfoProvider?: RegionInfoProvider;
+    
+    defaultUserAgentProvider?: Provider<__UserAgent>;
+    
+    defaultsMode?: DefaultsMode | Provider<DefaultsMode>;
+}
+declare type DynamoDBStreamsClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
+
+export interface DynamoDBStreamsClientConfig extends DynamoDBStreamsClientConfigType {
+}
+declare type DynamoDBStreamsClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
+
+export interface DynamoDBStreamsClientResolvedConfig extends DynamoDBStreamsClientResolvedConfigType {
+}
+
+export declare class DynamoDBStreamsClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, DynamoDBStreamsClientResolvedConfig> {
+    
+    readonly config: DynamoDBStreamsClientResolvedConfig;
+    constructor(configuration: DynamoDBStreamsClientConfig);
+    
+    destroy(): void;
+}
+export {};

package/dist-types/ts3.4/commands/DescribeStreamCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBStreamsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBStreamsClient";
+import { DescribeStreamInput, DescribeStreamOutput } from "../models/models_0";
+export interface DescribeStreamCommandInput extends DescribeStreamInput {
+}
+export interface DescribeStreamCommandOutput extends DescribeStreamOutput, __MetadataBearer {
+}
+
+export declare class DescribeStreamCommand extends $Command<DescribeStreamCommandInput, DescribeStreamCommandOutput, DynamoDBStreamsClientResolvedConfig> {
+    readonly input: DescribeStreamCommandInput;
+    constructor(input: DescribeStreamCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBStreamsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStreamCommandInput, DescribeStreamCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetRecordsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBStreamsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBStreamsClient";
+import { GetRecordsInput, GetRecordsOutput } from "../models/models_0";
+export interface GetRecordsCommandInput extends GetRecordsInput {
+}
+export interface GetRecordsCommandOutput extends GetRecordsOutput, __MetadataBearer {
+}
+
+export declare class GetRecordsCommand extends $Command<GetRecordsCommandInput, GetRecordsCommandOutput, DynamoDBStreamsClientResolvedConfig> {
+    readonly input: GetRecordsCommandInput;
+    constructor(input: GetRecordsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBStreamsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRecordsCommandInput, GetRecordsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetShardIteratorCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBStreamsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBStreamsClient";
+import { GetShardIteratorInput, GetShardIteratorOutput } from "../models/models_0";
+export interface GetShardIteratorCommandInput extends GetShardIteratorInput {
+}
+export interface GetShardIteratorCommandOutput extends GetShardIteratorOutput, __MetadataBearer {
+}
+
+export declare class GetShardIteratorCommand extends $Command<GetShardIteratorCommandInput, GetShardIteratorCommandOutput, DynamoDBStreamsClientResolvedConfig> {
+    readonly input: GetShardIteratorCommandInput;
+    constructor(input: GetShardIteratorCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBStreamsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetShardIteratorCommandInput, GetShardIteratorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListStreamsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DynamoDBStreamsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../DynamoDBStreamsClient";
+import { ListStreamsInput, ListStreamsOutput } from "../models/models_0";
+export interface ListStreamsCommandInput extends ListStreamsInput {
+}
+export interface ListStreamsCommandOutput extends ListStreamsOutput, __MetadataBearer {
+}
+
+export declare class ListStreamsCommand extends $Command<ListStreamsCommandInput, ListStreamsCommandOutput, DynamoDBStreamsClientResolvedConfig> {
+    readonly input: ListStreamsCommandInput;
+    constructor(input: ListStreamsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: DynamoDBStreamsClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStreamsCommandInput, ListStreamsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,4 @@
+export * from "./DescribeStreamCommand";
+export * from "./GetRecordsCommand";
+export * from "./GetShardIteratorCommand";
+export * from "./ListStreamsCommand";

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

@@ -0,0 +1,2 @@
+import { RegionInfoProvider } from "@aws-sdk/types";
+export declare const defaultRegionInfoProvider: RegionInfoProvider;

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

@@ -0,0 +1,5 @@
+export * from "./DynamoDBStreams";
+export * from "./DynamoDBStreamsClient";
+export * from "./commands";
+export * from "./models";
+export { DynamoDBStreamsServiceException } from "./models/DynamoDBStreamsServiceException";

package/dist-types/ts3.4/models/DynamoDBStreamsServiceException.d.ts

@@ -0,0 +1,6 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+
+export declare class DynamoDBStreamsServiceException extends __ServiceException {
+    
+    constructor(options: __ServiceExceptionOptions);
+}

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

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

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,446 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { DynamoDBStreamsServiceException as __BaseException } from "./DynamoDBStreamsServiceException";
+
+export interface DescribeStreamInput {
+    
+    StreamArn: string | undefined;
+    
+    Limit?: number;
+    
+    ExclusiveStartShardId?: string;
+}
+export declare namespace DescribeStreamInput {
+    
+    const filterSensitiveLog: (obj: DescribeStreamInput) => any;
+}
+export declare type KeyType = "HASH" | "RANGE";
+
+export interface KeySchemaElement {
+    
+    AttributeName: string | undefined;
+    
+    KeyType: KeyType | string | undefined;
+}
+export declare namespace KeySchemaElement {
+    
+    const filterSensitiveLog: (obj: KeySchemaElement) => any;
+}
+
+export interface SequenceNumberRange {
+    
+    StartingSequenceNumber?: string;
+    
+    EndingSequenceNumber?: string;
+}
+export declare namespace SequenceNumberRange {
+    
+    const filterSensitiveLog: (obj: SequenceNumberRange) => any;
+}
+
+export interface Shard {
+    
+    ShardId?: string;
+    
+    SequenceNumberRange?: SequenceNumberRange;
+    
+    ParentShardId?: string;
+}
+export declare namespace Shard {
+    
+    const filterSensitiveLog: (obj: Shard) => any;
+}
+export declare type StreamStatus = "DISABLED" | "DISABLING" | "ENABLED" | "ENABLING";
+export declare type StreamViewType = "KEYS_ONLY" | "NEW_AND_OLD_IMAGES" | "NEW_IMAGE" | "OLD_IMAGE";
+
+export interface StreamDescription {
+    
+    StreamArn?: string;
+    
+    StreamLabel?: string;
+    
+    StreamStatus?: StreamStatus | string;
+    
+    StreamViewType?: StreamViewType | string;
+    
+    CreationRequestDateTime?: Date;
+    
+    TableName?: string;
+    
+    KeySchema?: KeySchemaElement[];
+    
+    Shards?: Shard[];
+    
+    LastEvaluatedShardId?: string;
+}
+export declare namespace StreamDescription {
+    
+    const filterSensitiveLog: (obj: StreamDescription) => any;
+}
+
+export interface DescribeStreamOutput {
+    
+    StreamDescription?: StreamDescription;
+}
+export declare namespace DescribeStreamOutput {
+    
+    const filterSensitiveLog: (obj: DescribeStreamOutput) => any;
+}
+
+export declare class InternalServerError extends __BaseException {
+    readonly name: "InternalServerError";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<InternalServerError, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ExpiredIteratorException extends __BaseException {
+    readonly name: "ExpiredIteratorException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ExpiredIteratorException, __BaseException>);
+}
+
+export interface GetRecordsInput {
+    
+    ShardIterator: string | undefined;
+    
+    Limit?: number;
+}
+export declare namespace GetRecordsInput {
+    
+    const filterSensitiveLog: (obj: GetRecordsInput) => any;
+}
+export declare type OperationType = "INSERT" | "MODIFY" | "REMOVE";
+
+export interface Identity {
+    
+    PrincipalId?: string;
+    
+    Type?: string;
+}
+export declare namespace Identity {
+    
+    const filterSensitiveLog: (obj: Identity) => any;
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+
+export declare class TrimmedDataAccessException extends __BaseException {
+    readonly name: "TrimmedDataAccessException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TrimmedDataAccessException, __BaseException>);
+}
+export declare type ShardIteratorType = "AFTER_SEQUENCE_NUMBER" | "AT_SEQUENCE_NUMBER" | "LATEST" | "TRIM_HORIZON";
+
+export interface GetShardIteratorInput {
+    
+    StreamArn: string | undefined;
+    
+    ShardId: string | undefined;
+    
+    ShardIteratorType: ShardIteratorType | string | undefined;
+    
+    SequenceNumber?: string;
+}
+export declare namespace GetShardIteratorInput {
+    
+    const filterSensitiveLog: (obj: GetShardIteratorInput) => any;
+}
+
+export interface GetShardIteratorOutput {
+    
+    ShardIterator?: string;
+}
+export declare namespace GetShardIteratorOutput {
+    
+    const filterSensitiveLog: (obj: GetShardIteratorOutput) => any;
+}
+
+export interface ListStreamsInput {
+    
+    TableName?: string;
+    
+    Limit?: number;
+    
+    ExclusiveStartStreamArn?: string;
+}
+export declare namespace ListStreamsInput {
+    
+    const filterSensitiveLog: (obj: ListStreamsInput) => any;
+}
+
+export interface _Stream {
+    
+    StreamArn?: string;
+    
+    TableName?: string;
+    
+    StreamLabel?: string;
+}
+export declare namespace _Stream {
+    
+    const filterSensitiveLog: (obj: _Stream) => any;
+}
+
+export interface ListStreamsOutput {
+    
+    Streams?: _Stream[];
+    
+    LastEvaluatedStreamArn?: string;
+}
+export declare namespace ListStreamsOutput {
+    
+    const filterSensitiveLog: (obj: ListStreamsOutput) => any;
+}
+
+export declare type AttributeValue = AttributeValue.BMember | AttributeValue.BOOLMember | AttributeValue.BSMember | AttributeValue.LMember | AttributeValue.MMember | AttributeValue.NMember | AttributeValue.NSMember | AttributeValue.NULLMember | AttributeValue.SMember | AttributeValue.SSMember | AttributeValue.$UnknownMember;
+export declare namespace AttributeValue {
+    
+    interface SMember {
+        S: string;
+        N?: never;
+        B?: never;
+        SS?: never;
+        NS?: never;
+        BS?: never;
+        M?: never;
+        L?: never;
+        NULL?: never;
+        BOOL?: never;
+        $unknown?: never;
+    }
+    
+    interface NMember {
+        S?: never;
+        N: string;
+        B?: never;
+        SS?: never;
+        NS?: never;
+        BS?: never;
+        M?: never;
+        L?: never;
+        NULL?: never;
+        BOOL?: never;
+        $unknown?: never;
+    }
+    
+    interface BMember {
+        S?: never;
+        N?: never;
+        B: Uint8Array;
+        SS?: never;
+        NS?: never;
+        BS?: never;
+        M?: never;
+        L?: never;
+        NULL?: never;
+        BOOL?: never;
+        $unknown?: never;
+    }
+    
+    interface SSMember {
+        S?: never;
+        N?: never;
+        B?: never;
+        SS: string[];
+        NS?: never;
+        BS?: never;
+        M?: never;
+        L?: never;
+        NULL?: never;
+        BOOL?: never;
+        $unknown?: never;
+    }
+    
+    interface NSMember {
+        S?: never;
+        N?: never;
+        B?: never;
+        SS?: never;
+        NS: string[];
+        BS?: never;
+        M?: never;
+        L?: never;
+        NULL?: never;
+        BOOL?: never;
+        $unknown?: never;
+    }
+    
+    interface BSMember {
+        S?: never;
+        N?: never;
+        B?: never;
+        SS?: never;
+        NS?: never;
+        BS: Uint8Array[];
+        M?: never;
+        L?: never;
+        NULL?: never;
+        BOOL?: never;
+        $unknown?: never;
+    }
+    
+    interface MMember {
+        S?: never;
+        N?: never;
+        B?: never;
+        SS?: never;
+        NS?: never;
+        BS?: never;
+        M: {
+            [key: string]: AttributeValue;
+        };
+        L?: never;
+        NULL?: never;
+        BOOL?: never;
+        $unknown?: never;
+    }
+    
+    interface LMember {
+        S?: never;
+        N?: never;
+        B?: never;
+        SS?: never;
+        NS?: never;
+        BS?: never;
+        M?: never;
+        L: AttributeValue[];
+        NULL?: never;
+        BOOL?: never;
+        $unknown?: never;
+    }
+    
+    interface NULLMember {
+        S?: never;
+        N?: never;
+        B?: never;
+        SS?: never;
+        NS?: never;
+        BS?: never;
+        M?: never;
+        L?: never;
+        NULL: boolean;
+        BOOL?: never;
+        $unknown?: never;
+    }
+    
+    interface BOOLMember {
+        S?: never;
+        N?: never;
+        B?: never;
+        SS?: never;
+        NS?: never;
+        BS?: never;
+        M?: never;
+        L?: never;
+        NULL?: never;
+        BOOL: boolean;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        S?: never;
+        N?: never;
+        B?: never;
+        SS?: never;
+        NS?: never;
+        BS?: never;
+        M?: never;
+        L?: never;
+        NULL?: never;
+        BOOL?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        S: (value: string) => T;
+        N: (value: string) => T;
+        B: (value: Uint8Array) => T;
+        SS: (value: string[]) => T;
+        NS: (value: string[]) => T;
+        BS: (value: Uint8Array[]) => T;
+        M: (value: {
+            [key: string]: AttributeValue;
+        }) => T;
+        L: (value: AttributeValue[]) => T;
+        NULL: (value: boolean) => T;
+        BOOL: (value: boolean) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: AttributeValue, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: AttributeValue) => any;
+}
+
+export interface StreamRecord {
+    
+    ApproximateCreationDateTime?: Date;
+    
+    Keys?: {
+        [key: string]: AttributeValue;
+    };
+    
+    NewImage?: {
+        [key: string]: AttributeValue;
+    };
+    
+    OldImage?: {
+        [key: string]: AttributeValue;
+    };
+    
+    SequenceNumber?: string;
+    
+    SizeBytes?: number;
+    
+    StreamViewType?: StreamViewType | string;
+}
+export declare namespace StreamRecord {
+    
+    const filterSensitiveLog: (obj: StreamRecord) => any;
+}
+
+export interface _Record {
+    
+    eventID?: string;
+    
+    eventName?: OperationType | string;
+    
+    eventVersion?: string;
+    
+    eventSource?: string;
+    
+    awsRegion?: string;
+    
+    dynamodb?: StreamRecord;
+    
+    userIdentity?: Identity;
+}
+export declare namespace _Record {
+    
+    const filterSensitiveLog: (obj: _Record) => any;
+}
+
+export interface GetRecordsOutput {
+    
+    Records?: _Record[];
+    
+    NextShardIterator?: string;
+}
+export declare namespace GetRecordsOutput {
+    
+    const filterSensitiveLog: (obj: GetRecordsOutput) => any;
+}

package/dist-types/ts3.4/protocols/Aws_json1_0.d.ts

@@ -0,0 +1,14 @@
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
+import { DescribeStreamCommandInput, DescribeStreamCommandOutput } from "../commands/DescribeStreamCommand";
+import { GetRecordsCommandInput, GetRecordsCommandOutput } from "../commands/GetRecordsCommand";
+import { GetShardIteratorCommandInput, GetShardIteratorCommandOutput } from "../commands/GetShardIteratorCommand";
+import { ListStreamsCommandInput, ListStreamsCommandOutput } from "../commands/ListStreamsCommand";
+export declare const serializeAws_json1_0DescribeStreamCommand: (input: DescribeStreamCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0GetRecordsCommand: (input: GetRecordsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0GetShardIteratorCommand: (input: GetShardIteratorCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0ListStreamsCommand: (input: ListStreamsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const deserializeAws_json1_0DescribeStreamCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeStreamCommandOutput>;
+export declare const deserializeAws_json1_0GetRecordsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetRecordsCommandOutput>;
+export declare const deserializeAws_json1_0GetShardIteratorCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetShardIteratorCommandOutput>;
+export declare const deserializeAws_json1_0ListStreamsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListStreamsCommandOutput>;

package/dist-types/ts3.4/runtimeConfig.browser.d.ts

@@ -0,0 +1,38 @@
+import { FetchHttpHandler as RequestHandler } from "@aws-sdk/fetch-http-handler";
+import { DynamoDBStreamsClientConfig } from "./DynamoDBStreamsClient";
+
+export declare const getRuntimeConfig: (config: DynamoDBStreamsClientConfig) => {
+    runtime: string;
+    defaultsMode: import("@aws-sdk/types").Provider<import("@aws-sdk/smithy-client").ResolvedDefaultsMode>;
+    base64Decoder: import("@aws-sdk/types").Decoder;
+    base64Encoder: import("@aws-sdk/types").Encoder;
+    bodyLengthChecker: (body: any) => number | undefined;
+    credentialDefaultProvider: (input: any) => import("@aws-sdk/types").Provider<import("@aws-sdk/types").Credentials>;
+    defaultUserAgentProvider: import("@aws-sdk/types").Provider<import("@aws-sdk/types").UserAgent>;
+    maxAttempts: number | import("@aws-sdk/types").Provider<number>;
+    region: string | import("@aws-sdk/types").Provider<any>;
+    requestHandler: (import("@aws-sdk/types").RequestHandler<any, any, import("@aws-sdk/types").HttpHandlerOptions> & import("@aws-sdk/protocol-http").HttpHandler) | RequestHandler;
+    retryMode: string | import("@aws-sdk/types").Provider<string>;
+    sha256: import("@aws-sdk/types").HashConstructor;
+    streamCollector: import("@aws-sdk/types").StreamCollector;
+    useDualstackEndpoint: boolean | import("@aws-sdk/types").Provider<boolean>;
+    useFipsEndpoint: boolean | import("@aws-sdk/types").Provider<boolean>;
+    utf8Decoder: import("@aws-sdk/types").Decoder;
+    utf8Encoder: import("@aws-sdk/types").Encoder;
+    apiVersion: string;
+    urlParser: import("@aws-sdk/types").UrlParser;
+    disableHostPrefix: boolean;
+    logger: import("@aws-sdk/types").Logger;
+    serviceId: string;
+    regionInfoProvider: import("@aws-sdk/types").RegionInfoProvider;
+    endpoint?: string | import("@aws-sdk/types").Endpoint | import("@aws-sdk/types").Provider<import("@aws-sdk/types").Endpoint> | undefined;
+    tls?: boolean | undefined;
+    retryStrategy?: import("@aws-sdk/types").RetryStrategy | undefined;
+    credentials?: import("@aws-sdk/types").Credentials | import("@aws-sdk/types").Provider<import("@aws-sdk/types").Credentials> | undefined;
+    signer?: import("@aws-sdk/types").RequestSigner | import("@aws-sdk/types").Provider<import("@aws-sdk/types").RequestSigner> | undefined;
+    signingEscapePath?: boolean | undefined;
+    systemClockOffset?: number | undefined;
+    signingRegion?: string | undefined;
+    signerConstructor?: (new (options: import("@aws-sdk/signature-v4").SignatureV4Init & import("@aws-sdk/signature-v4").SignatureV4CryptoInit) => import("@aws-sdk/types").RequestSigner) | undefined;
+    customUserAgent?: string | import("@aws-sdk/types").UserAgent | undefined;
+};