@aws-sdk/client-timestream-write 3.50.0 → 3.53.0

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

@@ -0,0 +1,15 @@
+export * from "./CreateDatabaseCommand";
+export * from "./CreateTableCommand";
+export * from "./DeleteDatabaseCommand";
+export * from "./DeleteTableCommand";
+export * from "./DescribeDatabaseCommand";
+export * from "./DescribeEndpointsCommand";
+export * from "./DescribeTableCommand";
+export * from "./ListDatabasesCommand";
+export * from "./ListTablesCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateDatabaseCommand";
+export * from "./UpdateTableCommand";
+export * from "./WriteRecordsCommand";

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,6 @@
+export * from "./TimestreamWrite";
+export * from "./TimestreamWriteClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export { TimestreamWriteServiceException } from "./models/TimestreamWriteServiceException";

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

@@ -0,0 +1,6 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+
+export declare class TimestreamWriteServiceException 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,547 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { TimestreamWriteServiceException as __BaseException } from "./TimestreamWriteServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateDatabaseRequest {
+    
+    DatabaseName: string | undefined;
+    
+    KmsKeyId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDatabaseRequest {
+    
+    const filterSensitiveLog: (obj: CreateDatabaseRequest) => any;
+}
+
+export interface Database {
+    
+    Arn?: string;
+    
+    DatabaseName?: string;
+    
+    TableCount?: number;
+    
+    KmsKeyId?: string;
+    
+    CreationTime?: Date;
+    
+    LastUpdatedTime?: Date;
+}
+export declare namespace Database {
+    
+    const filterSensitiveLog: (obj: Database) => any;
+}
+export interface CreateDatabaseResponse {
+    
+    Database?: Database;
+}
+export declare namespace CreateDatabaseResponse {
+    
+    const filterSensitiveLog: (obj: CreateDatabaseResponse) => any;
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class InvalidEndpointException extends __BaseException {
+    readonly name: "InvalidEndpointException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidEndpointException, __BaseException>);
+}
+
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export declare enum S3EncryptionOption {
+    SSE_KMS = "SSE_KMS",
+    SSE_S3 = "SSE_S3"
+}
+
+export interface S3Configuration {
+    
+    BucketName?: string;
+    
+    ObjectKeyPrefix?: string;
+    
+    EncryptionOption?: S3EncryptionOption | string;
+    
+    KmsKeyId?: string;
+}
+export declare namespace S3Configuration {
+    
+    const filterSensitiveLog: (obj: S3Configuration) => any;
+}
+
+export interface MagneticStoreRejectedDataLocation {
+    
+    S3Configuration?: S3Configuration;
+}
+export declare namespace MagneticStoreRejectedDataLocation {
+    
+    const filterSensitiveLog: (obj: MagneticStoreRejectedDataLocation) => any;
+}
+
+export interface MagneticStoreWriteProperties {
+    
+    EnableMagneticStoreWrites: boolean | undefined;
+    
+    MagneticStoreRejectedDataLocation?: MagneticStoreRejectedDataLocation;
+}
+export declare namespace MagneticStoreWriteProperties {
+    
+    const filterSensitiveLog: (obj: MagneticStoreWriteProperties) => any;
+}
+
+export interface RetentionProperties {
+    
+    MemoryStoreRetentionPeriodInHours: number | undefined;
+    
+    MagneticStoreRetentionPeriodInDays: number | undefined;
+}
+export declare namespace RetentionProperties {
+    
+    const filterSensitiveLog: (obj: RetentionProperties) => any;
+}
+export interface CreateTableRequest {
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+    
+    RetentionProperties?: RetentionProperties;
+    
+    Tags?: Tag[];
+    
+    MagneticStoreWriteProperties?: MagneticStoreWriteProperties;
+}
+export declare namespace CreateTableRequest {
+    
+    const filterSensitiveLog: (obj: CreateTableRequest) => any;
+}
+export declare enum TableStatus {
+    ACTIVE = "ACTIVE",
+    DELETING = "DELETING"
+}
+
+export interface Table {
+    
+    Arn?: string;
+    
+    TableName?: string;
+    
+    DatabaseName?: string;
+    
+    TableStatus?: TableStatus | string;
+    
+    RetentionProperties?: RetentionProperties;
+    
+    CreationTime?: Date;
+    
+    LastUpdatedTime?: Date;
+    
+    MagneticStoreWriteProperties?: MagneticStoreWriteProperties;
+}
+export declare namespace Table {
+    
+    const filterSensitiveLog: (obj: Table) => any;
+}
+export interface CreateTableResponse {
+    
+    Table?: Table;
+}
+export declare namespace CreateTableResponse {
+    
+    const filterSensitiveLog: (obj: CreateTableResponse) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export interface DeleteDatabaseRequest {
+    
+    DatabaseName: string | undefined;
+}
+export declare namespace DeleteDatabaseRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDatabaseRequest) => any;
+}
+export interface DeleteTableRequest {
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+}
+export declare namespace DeleteTableRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTableRequest) => any;
+}
+export interface DescribeDatabaseRequest {
+    
+    DatabaseName: string | undefined;
+}
+export declare namespace DescribeDatabaseRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDatabaseRequest) => any;
+}
+export interface DescribeDatabaseResponse {
+    
+    Database?: Database;
+}
+export declare namespace DescribeDatabaseResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDatabaseResponse) => any;
+}
+export interface DescribeEndpointsRequest {
+}
+export declare namespace DescribeEndpointsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointsRequest) => any;
+}
+
+export interface Endpoint {
+    
+    Address: string | undefined;
+    
+    CachePeriodInMinutes: number | undefined;
+}
+export declare namespace Endpoint {
+    
+    const filterSensitiveLog: (obj: Endpoint) => any;
+}
+export interface DescribeEndpointsResponse {
+    
+    Endpoints: Endpoint[] | undefined;
+}
+export declare namespace DescribeEndpointsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointsResponse) => any;
+}
+export interface DescribeTableRequest {
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+}
+export declare namespace DescribeTableRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTableRequest) => any;
+}
+export interface DescribeTableResponse {
+    
+    Table?: Table;
+}
+export declare namespace DescribeTableResponse {
+    
+    const filterSensitiveLog: (obj: DescribeTableResponse) => any;
+}
+export declare enum DimensionValueType {
+    VARCHAR = "VARCHAR"
+}
+
+export interface Dimension {
+    
+    Name: string | undefined;
+    
+    Value: string | undefined;
+    
+    DimensionValueType?: DimensionValueType | string;
+}
+export declare namespace Dimension {
+    
+    const filterSensitiveLog: (obj: Dimension) => any;
+}
+export interface ListDatabasesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDatabasesRequest {
+    
+    const filterSensitiveLog: (obj: ListDatabasesRequest) => any;
+}
+export interface ListDatabasesResponse {
+    
+    Databases?: Database[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDatabasesResponse {
+    
+    const filterSensitiveLog: (obj: ListDatabasesResponse) => any;
+}
+export interface ListTablesRequest {
+    
+    DatabaseName?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTablesRequest {
+    
+    const filterSensitiveLog: (obj: ListTablesRequest) => any;
+}
+export interface ListTablesResponse {
+    
+    Tables?: Table[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTablesResponse {
+    
+    const filterSensitiveLog: (obj: ListTablesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export declare enum MeasureValueType {
+    BIGINT = "BIGINT",
+    BOOLEAN = "BOOLEAN",
+    DOUBLE = "DOUBLE",
+    MULTI = "MULTI",
+    TIMESTAMP = "TIMESTAMP",
+    VARCHAR = "VARCHAR"
+}
+
+export interface MeasureValue {
+    
+    Name: string | undefined;
+    
+    Value: string | undefined;
+    
+    Type: MeasureValueType | string | undefined;
+}
+export declare namespace MeasureValue {
+    
+    const filterSensitiveLog: (obj: MeasureValue) => any;
+}
+export declare enum TimeUnit {
+    MICROSECONDS = "MICROSECONDS",
+    MILLISECONDS = "MILLISECONDS",
+    NANOSECONDS = "NANOSECONDS",
+    SECONDS = "SECONDS"
+}
+
+export interface _Record {
+    
+    Dimensions?: Dimension[];
+    
+    MeasureName?: string;
+    
+    MeasureValue?: string;
+    
+    MeasureValueType?: MeasureValueType | string;
+    
+    Time?: string;
+    
+    TimeUnit?: TimeUnit | string;
+    
+    Version?: number;
+    
+    MeasureValues?: MeasureValue[];
+}
+export declare namespace _Record {
+    
+    const filterSensitiveLog: (obj: _Record) => any;
+}
+
+export interface RecordsIngested {
+    
+    Total?: number;
+    
+    MemoryStore?: number;
+    
+    MagneticStore?: number;
+}
+export declare namespace RecordsIngested {
+    
+    const filterSensitiveLog: (obj: RecordsIngested) => any;
+}
+
+export interface RejectedRecord {
+    
+    RecordIndex?: number;
+    
+    Reason?: string;
+    
+    ExistingVersion?: number;
+}
+export declare namespace RejectedRecord {
+    
+    const filterSensitiveLog: (obj: RejectedRecord) => any;
+}
+
+export declare class RejectedRecordsException extends __BaseException {
+    readonly name: "RejectedRecordsException";
+    readonly $fault: "client";
+    Message?: string;
+    RejectedRecords?: RejectedRecord[];
+    
+    constructor(opts: __ExceptionOptionType<RejectedRecordsException, __BaseException>);
+}
+export interface TagResourceRequest {
+    
+    ResourceARN: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceARN: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateDatabaseRequest {
+    
+    DatabaseName: string | undefined;
+    
+    KmsKeyId: string | undefined;
+}
+export declare namespace UpdateDatabaseRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDatabaseRequest) => any;
+}
+export interface UpdateDatabaseResponse {
+    
+    Database?: Database;
+}
+export declare namespace UpdateDatabaseResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDatabaseResponse) => any;
+}
+export interface UpdateTableRequest {
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+    
+    RetentionProperties?: RetentionProperties;
+    
+    MagneticStoreWriteProperties?: MagneticStoreWriteProperties;
+}
+export declare namespace UpdateTableRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTableRequest) => any;
+}
+export interface UpdateTableResponse {
+    
+    Table?: Table;
+}
+export declare namespace UpdateTableResponse {
+    
+    const filterSensitiveLog: (obj: UpdateTableResponse) => any;
+}
+export interface WriteRecordsRequest {
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+    
+    CommonAttributes?: _Record;
+    
+    Records: _Record[] | undefined;
+}
+export declare namespace WriteRecordsRequest {
+    
+    const filterSensitiveLog: (obj: WriteRecordsRequest) => any;
+}
+export interface WriteRecordsResponse {
+    
+    RecordsIngested?: RecordsIngested;
+}
+export declare namespace WriteRecordsResponse {
+    
+    const filterSensitiveLog: (obj: WriteRecordsResponse) => any;
+}

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

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { TimestreamWrite } from "../TimestreamWrite";
+import { TimestreamWriteClient } from "../TimestreamWriteClient";
+export interface TimestreamWritePaginationConfiguration extends PaginationConfiguration {
+    client: TimestreamWrite | TimestreamWriteClient;
+}

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

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListDatabasesCommandInput, ListDatabasesCommandOutput } from "../commands/ListDatabasesCommand";
+import { TimestreamWritePaginationConfiguration } from "./Interfaces";
+export declare function paginateListDatabases(config: TimestreamWritePaginationConfiguration, input: ListDatabasesCommandInput, ...additionalArguments: any): Paginator<ListDatabasesCommandOutput>;

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

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListTablesCommandInput, ListTablesCommandOutput } from "../commands/ListTablesCommand";
+import { TimestreamWritePaginationConfiguration } from "./Interfaces";
+export declare function paginateListTables(config: TimestreamWritePaginationConfiguration, input: ListTablesCommandInput, ...additionalArguments: any): Paginator<ListTablesCommandOutput>;

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

@@ -0,0 +1,3 @@
+export * from "./Interfaces";
+export * from "./ListDatabasesPaginator";
+export * from "./ListTablesPaginator";

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

@@ -0,0 +1,47 @@
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
+import { CreateDatabaseCommandInput, CreateDatabaseCommandOutput } from "../commands/CreateDatabaseCommand";
+import { CreateTableCommandInput, CreateTableCommandOutput } from "../commands/CreateTableCommand";
+import { DeleteDatabaseCommandInput, DeleteDatabaseCommandOutput } from "../commands/DeleteDatabaseCommand";
+import { DeleteTableCommandInput, DeleteTableCommandOutput } from "../commands/DeleteTableCommand";
+import { DescribeDatabaseCommandInput, DescribeDatabaseCommandOutput } from "../commands/DescribeDatabaseCommand";
+import { DescribeEndpointsCommandInput, DescribeEndpointsCommandOutput } from "../commands/DescribeEndpointsCommand";
+import { DescribeTableCommandInput, DescribeTableCommandOutput } from "../commands/DescribeTableCommand";
+import { ListDatabasesCommandInput, ListDatabasesCommandOutput } from "../commands/ListDatabasesCommand";
+import { ListTablesCommandInput, ListTablesCommandOutput } from "../commands/ListTablesCommand";
+import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "../commands/ListTagsForResourceCommand";
+import { TagResourceCommandInput, TagResourceCommandOutput } from "../commands/TagResourceCommand";
+import { UntagResourceCommandInput, UntagResourceCommandOutput } from "../commands/UntagResourceCommand";
+import { UpdateDatabaseCommandInput, UpdateDatabaseCommandOutput } from "../commands/UpdateDatabaseCommand";
+import { UpdateTableCommandInput, UpdateTableCommandOutput } from "../commands/UpdateTableCommand";
+import { WriteRecordsCommandInput, WriteRecordsCommandOutput } from "../commands/WriteRecordsCommand";
+export declare const serializeAws_json1_0CreateDatabaseCommand: (input: CreateDatabaseCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0CreateTableCommand: (input: CreateTableCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0DeleteDatabaseCommand: (input: DeleteDatabaseCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0DeleteTableCommand: (input: DeleteTableCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0DescribeDatabaseCommand: (input: DescribeDatabaseCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0DescribeEndpointsCommand: (input: DescribeEndpointsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0DescribeTableCommand: (input: DescribeTableCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0ListDatabasesCommand: (input: ListDatabasesCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0ListTablesCommand: (input: ListTablesCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0ListTagsForResourceCommand: (input: ListTagsForResourceCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0TagResourceCommand: (input: TagResourceCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0UntagResourceCommand: (input: UntagResourceCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0UpdateDatabaseCommand: (input: UpdateDatabaseCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0UpdateTableCommand: (input: UpdateTableCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_0WriteRecordsCommand: (input: WriteRecordsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const deserializeAws_json1_0CreateDatabaseCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<CreateDatabaseCommandOutput>;
+export declare const deserializeAws_json1_0CreateTableCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<CreateTableCommandOutput>;
+export declare const deserializeAws_json1_0DeleteDatabaseCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DeleteDatabaseCommandOutput>;
+export declare const deserializeAws_json1_0DeleteTableCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DeleteTableCommandOutput>;
+export declare const deserializeAws_json1_0DescribeDatabaseCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeDatabaseCommandOutput>;
+export declare const deserializeAws_json1_0DescribeEndpointsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeEndpointsCommandOutput>;
+export declare const deserializeAws_json1_0DescribeTableCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeTableCommandOutput>;
+export declare const deserializeAws_json1_0ListDatabasesCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListDatabasesCommandOutput>;
+export declare const deserializeAws_json1_0ListTablesCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListTablesCommandOutput>;
+export declare const deserializeAws_json1_0ListTagsForResourceCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListTagsForResourceCommandOutput>;
+export declare const deserializeAws_json1_0TagResourceCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<TagResourceCommandOutput>;
+export declare const deserializeAws_json1_0UntagResourceCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<UntagResourceCommandOutput>;
+export declare const deserializeAws_json1_0UpdateDatabaseCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<UpdateDatabaseCommandOutput>;
+export declare const deserializeAws_json1_0UpdateTableCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<UpdateTableCommandOutput>;
+export declare const deserializeAws_json1_0WriteRecordsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<WriteRecordsCommandOutput>;