@aws-sdk/client-cognito-sync 3.50.0 → 3.51.0

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

@@ -0,0 +1,618 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AlreadyStreamedException extends __SmithyException, $MetadataBearer {
+    name: "AlreadyStreamedException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface BulkPublishRequest {
+    
+    IdentityPoolId: string | undefined;
+}
+export declare namespace BulkPublishRequest {
+    
+    const filterSensitiveLog: (obj: BulkPublishRequest) => any;
+}
+
+export interface BulkPublishResponse {
+    
+    IdentityPoolId?: string;
+}
+export declare namespace BulkPublishResponse {
+    
+    const filterSensitiveLog: (obj: BulkPublishResponse) => any;
+}
+
+export interface DuplicateRequestException extends __SmithyException, $MetadataBearer {
+    name: "DuplicateRequestException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface InternalErrorException extends __SmithyException, $MetadataBearer {
+    name: "InternalErrorException";
+    $fault: "server";
+    
+    message: string | undefined;
+}
+
+export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface NotAuthorizedException extends __SmithyException, $MetadataBearer {
+    name: "NotAuthorizedException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface DeleteDatasetRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    IdentityId: string | undefined;
+    
+    DatasetName: string | undefined;
+}
+export declare namespace DeleteDatasetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDatasetRequest) => any;
+}
+
+export interface Dataset {
+    
+    IdentityId?: string;
+    
+    DatasetName?: string;
+    
+    CreationDate?: Date;
+    
+    LastModifiedDate?: Date;
+    
+    LastModifiedBy?: string;
+    
+    DataStorage?: number;
+    
+    NumRecords?: number;
+}
+export declare namespace Dataset {
+    
+    const filterSensitiveLog: (obj: Dataset) => any;
+}
+
+export interface DeleteDatasetResponse {
+    
+    Dataset?: Dataset;
+}
+export declare namespace DeleteDatasetResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDatasetResponse) => any;
+}
+
+export interface ResourceConflictException extends __SmithyException, $MetadataBearer {
+    name: "ResourceConflictException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface TooManyRequestsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyRequestsException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface DescribeDatasetRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    IdentityId: string | undefined;
+    
+    DatasetName: string | undefined;
+}
+export declare namespace DescribeDatasetRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDatasetRequest) => any;
+}
+
+export interface DescribeDatasetResponse {
+    
+    Dataset?: Dataset;
+}
+export declare namespace DescribeDatasetResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDatasetResponse) => any;
+}
+
+export interface DescribeIdentityPoolUsageRequest {
+    
+    IdentityPoolId: string | undefined;
+}
+export declare namespace DescribeIdentityPoolUsageRequest {
+    
+    const filterSensitiveLog: (obj: DescribeIdentityPoolUsageRequest) => any;
+}
+
+export interface IdentityPoolUsage {
+    
+    IdentityPoolId?: string;
+    
+    SyncSessionsCount?: number;
+    
+    DataStorage?: number;
+    
+    LastModifiedDate?: Date;
+}
+export declare namespace IdentityPoolUsage {
+    
+    const filterSensitiveLog: (obj: IdentityPoolUsage) => any;
+}
+
+export interface DescribeIdentityPoolUsageResponse {
+    
+    IdentityPoolUsage?: IdentityPoolUsage;
+}
+export declare namespace DescribeIdentityPoolUsageResponse {
+    
+    const filterSensitiveLog: (obj: DescribeIdentityPoolUsageResponse) => any;
+}
+
+export interface DescribeIdentityUsageRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    IdentityId: string | undefined;
+}
+export declare namespace DescribeIdentityUsageRequest {
+    
+    const filterSensitiveLog: (obj: DescribeIdentityUsageRequest) => any;
+}
+
+export interface IdentityUsage {
+    
+    IdentityId?: string;
+    
+    IdentityPoolId?: string;
+    
+    LastModifiedDate?: Date;
+    
+    DatasetCount?: number;
+    
+    DataStorage?: number;
+}
+export declare namespace IdentityUsage {
+    
+    const filterSensitiveLog: (obj: IdentityUsage) => any;
+}
+
+export interface DescribeIdentityUsageResponse {
+    
+    IdentityUsage?: IdentityUsage;
+}
+export declare namespace DescribeIdentityUsageResponse {
+    
+    const filterSensitiveLog: (obj: DescribeIdentityUsageResponse) => any;
+}
+
+export interface GetBulkPublishDetailsRequest {
+    
+    IdentityPoolId: string | undefined;
+}
+export declare namespace GetBulkPublishDetailsRequest {
+    
+    const filterSensitiveLog: (obj: GetBulkPublishDetailsRequest) => any;
+}
+export declare enum BulkPublishStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    NOT_STARTED = "NOT_STARTED",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface GetBulkPublishDetailsResponse {
+    
+    IdentityPoolId?: string;
+    
+    BulkPublishStartTime?: Date;
+    
+    BulkPublishCompleteTime?: Date;
+    
+    BulkPublishStatus?: BulkPublishStatus | string;
+    
+    FailureMessage?: string;
+}
+export declare namespace GetBulkPublishDetailsResponse {
+    
+    const filterSensitiveLog: (obj: GetBulkPublishDetailsResponse) => any;
+}
+
+export interface GetCognitoEventsRequest {
+    
+    IdentityPoolId: string | undefined;
+}
+export declare namespace GetCognitoEventsRequest {
+    
+    const filterSensitiveLog: (obj: GetCognitoEventsRequest) => any;
+}
+
+export interface GetCognitoEventsResponse {
+    
+    Events?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetCognitoEventsResponse {
+    
+    const filterSensitiveLog: (obj: GetCognitoEventsResponse) => any;
+}
+
+export interface GetIdentityPoolConfigurationRequest {
+    
+    IdentityPoolId: string | undefined;
+}
+export declare namespace GetIdentityPoolConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetIdentityPoolConfigurationRequest) => any;
+}
+export declare type StreamingStatus = "DISABLED" | "ENABLED";
+
+export interface CognitoStreams {
+    
+    StreamName?: string;
+    
+    RoleArn?: string;
+    
+    StreamingStatus?: StreamingStatus | string;
+}
+export declare namespace CognitoStreams {
+    
+    const filterSensitiveLog: (obj: CognitoStreams) => any;
+}
+
+export interface PushSync {
+    
+    ApplicationArns?: string[];
+    
+    RoleArn?: string;
+}
+export declare namespace PushSync {
+    
+    const filterSensitiveLog: (obj: PushSync) => any;
+}
+
+export interface GetIdentityPoolConfigurationResponse {
+    
+    IdentityPoolId?: string;
+    
+    PushSync?: PushSync;
+    
+    CognitoStreams?: CognitoStreams;
+}
+export declare namespace GetIdentityPoolConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetIdentityPoolConfigurationResponse) => any;
+}
+
+export interface ListDatasetsRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    IdentityId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDatasetsRequest {
+    
+    const filterSensitiveLog: (obj: ListDatasetsRequest) => any;
+}
+
+export interface ListDatasetsResponse {
+    
+    Datasets?: Dataset[];
+    
+    Count?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListDatasetsResponse {
+    
+    const filterSensitiveLog: (obj: ListDatasetsResponse) => any;
+}
+
+export interface ListIdentityPoolUsageRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListIdentityPoolUsageRequest {
+    
+    const filterSensitiveLog: (obj: ListIdentityPoolUsageRequest) => any;
+}
+
+export interface ListIdentityPoolUsageResponse {
+    
+    IdentityPoolUsages?: IdentityPoolUsage[];
+    
+    MaxResults?: number;
+    
+    Count?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListIdentityPoolUsageResponse {
+    
+    const filterSensitiveLog: (obj: ListIdentityPoolUsageResponse) => any;
+}
+
+export interface ListRecordsRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    IdentityId: string | undefined;
+    
+    DatasetName: string | undefined;
+    
+    LastSyncCount?: number;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    SyncSessionToken?: string;
+}
+export declare namespace ListRecordsRequest {
+    
+    const filterSensitiveLog: (obj: ListRecordsRequest) => any;
+}
+
+export interface _Record {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    SyncCount?: number;
+    
+    LastModifiedDate?: Date;
+    
+    LastModifiedBy?: string;
+    
+    DeviceLastModifiedDate?: Date;
+}
+export declare namespace _Record {
+    
+    const filterSensitiveLog: (obj: _Record) => any;
+}
+
+export interface ListRecordsResponse {
+    
+    Records?: _Record[];
+    
+    NextToken?: string;
+    
+    Count?: number;
+    
+    DatasetSyncCount?: number;
+    
+    LastModifiedBy?: string;
+    
+    MergedDatasetNames?: string[];
+    
+    DatasetExists?: boolean;
+    
+    DatasetDeletedAfterRequestedSyncCount?: boolean;
+    
+    SyncSessionToken?: string;
+}
+export declare namespace ListRecordsResponse {
+    
+    const filterSensitiveLog: (obj: ListRecordsResponse) => any;
+}
+export interface InvalidConfigurationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidConfigurationException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+export declare type Platform = "ADM" | "APNS" | "APNS_SANDBOX" | "GCM";
+
+export interface RegisterDeviceRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    IdentityId: string | undefined;
+    
+    Platform: Platform | string | undefined;
+    
+    Token: string | undefined;
+}
+export declare namespace RegisterDeviceRequest {
+    
+    const filterSensitiveLog: (obj: RegisterDeviceRequest) => any;
+}
+
+export interface RegisterDeviceResponse {
+    
+    DeviceId?: string;
+}
+export declare namespace RegisterDeviceResponse {
+    
+    const filterSensitiveLog: (obj: RegisterDeviceResponse) => any;
+}
+
+export interface SetCognitoEventsRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    Events: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace SetCognitoEventsRequest {
+    
+    const filterSensitiveLog: (obj: SetCognitoEventsRequest) => any;
+}
+
+export interface ConcurrentModificationException extends __SmithyException, $MetadataBearer {
+    name: "ConcurrentModificationException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface SetIdentityPoolConfigurationRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    PushSync?: PushSync;
+    
+    CognitoStreams?: CognitoStreams;
+}
+export declare namespace SetIdentityPoolConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: SetIdentityPoolConfigurationRequest) => any;
+}
+
+export interface SetIdentityPoolConfigurationResponse {
+    
+    IdentityPoolId?: string;
+    
+    PushSync?: PushSync;
+    
+    CognitoStreams?: CognitoStreams;
+}
+export declare namespace SetIdentityPoolConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: SetIdentityPoolConfigurationResponse) => any;
+}
+
+export interface SubscribeToDatasetRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    IdentityId: string | undefined;
+    
+    DatasetName: string | undefined;
+    
+    DeviceId: string | undefined;
+}
+export declare namespace SubscribeToDatasetRequest {
+    
+    const filterSensitiveLog: (obj: SubscribeToDatasetRequest) => any;
+}
+
+export interface SubscribeToDatasetResponse {
+}
+export declare namespace SubscribeToDatasetResponse {
+    
+    const filterSensitiveLog: (obj: SubscribeToDatasetResponse) => any;
+}
+
+export interface UnsubscribeFromDatasetRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    IdentityId: string | undefined;
+    
+    DatasetName: string | undefined;
+    
+    DeviceId: string | undefined;
+}
+export declare namespace UnsubscribeFromDatasetRequest {
+    
+    const filterSensitiveLog: (obj: UnsubscribeFromDatasetRequest) => any;
+}
+
+export interface UnsubscribeFromDatasetResponse {
+}
+export declare namespace UnsubscribeFromDatasetResponse {
+    
+    const filterSensitiveLog: (obj: UnsubscribeFromDatasetResponse) => any;
+}
+
+export interface InvalidLambdaFunctionOutputException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLambdaFunctionOutputException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface LambdaThrottledException extends __SmithyException, $MetadataBearer {
+    name: "LambdaThrottledException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    
+    message: string | undefined;
+}
+export declare type Operation = "remove" | "replace";
+
+export interface RecordPatch {
+    
+    Op: Operation | string | undefined;
+    
+    Key: string | undefined;
+    
+    Value?: string;
+    
+    SyncCount: number | undefined;
+    
+    DeviceLastModifiedDate?: Date;
+}
+export declare namespace RecordPatch {
+    
+    const filterSensitiveLog: (obj: RecordPatch) => any;
+}
+
+export interface UpdateRecordsRequest {
+    
+    IdentityPoolId: string | undefined;
+    
+    IdentityId: string | undefined;
+    
+    DatasetName: string | undefined;
+    
+    DeviceId?: string;
+    
+    RecordPatches?: RecordPatch[];
+    
+    SyncSessionToken: string | undefined;
+    
+    ClientContext?: string;
+}
+export declare namespace UpdateRecordsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRecordsRequest) => any;
+}
+
+export interface UpdateRecordsResponse {
+    
+    Records?: _Record[];
+}
+export declare namespace UpdateRecordsResponse {
+    
+    const filterSensitiveLog: (obj: UpdateRecordsResponse) => any;
+}

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

@@ -0,0 +1,53 @@
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
+import { BulkPublishCommandInput, BulkPublishCommandOutput } from "../commands/BulkPublishCommand";
+import { DeleteDatasetCommandInput, DeleteDatasetCommandOutput } from "../commands/DeleteDatasetCommand";
+import { DescribeDatasetCommandInput, DescribeDatasetCommandOutput } from "../commands/DescribeDatasetCommand";
+import { DescribeIdentityPoolUsageCommandInput, DescribeIdentityPoolUsageCommandOutput } from "../commands/DescribeIdentityPoolUsageCommand";
+import { DescribeIdentityUsageCommandInput, DescribeIdentityUsageCommandOutput } from "../commands/DescribeIdentityUsageCommand";
+import { GetBulkPublishDetailsCommandInput, GetBulkPublishDetailsCommandOutput } from "../commands/GetBulkPublishDetailsCommand";
+import { GetCognitoEventsCommandInput, GetCognitoEventsCommandOutput } from "../commands/GetCognitoEventsCommand";
+import { GetIdentityPoolConfigurationCommandInput, GetIdentityPoolConfigurationCommandOutput } from "../commands/GetIdentityPoolConfigurationCommand";
+import { ListDatasetsCommandInput, ListDatasetsCommandOutput } from "../commands/ListDatasetsCommand";
+import { ListIdentityPoolUsageCommandInput, ListIdentityPoolUsageCommandOutput } from "../commands/ListIdentityPoolUsageCommand";
+import { ListRecordsCommandInput, ListRecordsCommandOutput } from "../commands/ListRecordsCommand";
+import { RegisterDeviceCommandInput, RegisterDeviceCommandOutput } from "../commands/RegisterDeviceCommand";
+import { SetCognitoEventsCommandInput, SetCognitoEventsCommandOutput } from "../commands/SetCognitoEventsCommand";
+import { SetIdentityPoolConfigurationCommandInput, SetIdentityPoolConfigurationCommandOutput } from "../commands/SetIdentityPoolConfigurationCommand";
+import { SubscribeToDatasetCommandInput, SubscribeToDatasetCommandOutput } from "../commands/SubscribeToDatasetCommand";
+import { UnsubscribeFromDatasetCommandInput, UnsubscribeFromDatasetCommandOutput } from "../commands/UnsubscribeFromDatasetCommand";
+import { UpdateRecordsCommandInput, UpdateRecordsCommandOutput } from "../commands/UpdateRecordsCommand";
+export declare const serializeAws_restJson1BulkPublishCommand: (input: BulkPublishCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1DeleteDatasetCommand: (input: DeleteDatasetCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1DescribeDatasetCommand: (input: DescribeDatasetCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1DescribeIdentityPoolUsageCommand: (input: DescribeIdentityPoolUsageCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1DescribeIdentityUsageCommand: (input: DescribeIdentityUsageCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1GetBulkPublishDetailsCommand: (input: GetBulkPublishDetailsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1GetCognitoEventsCommand: (input: GetCognitoEventsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1GetIdentityPoolConfigurationCommand: (input: GetIdentityPoolConfigurationCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1ListDatasetsCommand: (input: ListDatasetsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1ListIdentityPoolUsageCommand: (input: ListIdentityPoolUsageCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1ListRecordsCommand: (input: ListRecordsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1RegisterDeviceCommand: (input: RegisterDeviceCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1SetCognitoEventsCommand: (input: SetCognitoEventsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1SetIdentityPoolConfigurationCommand: (input: SetIdentityPoolConfigurationCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1SubscribeToDatasetCommand: (input: SubscribeToDatasetCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1UnsubscribeFromDatasetCommand: (input: UnsubscribeFromDatasetCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1UpdateRecordsCommand: (input: UpdateRecordsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const deserializeAws_restJson1BulkPublishCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<BulkPublishCommandOutput>;
+export declare const deserializeAws_restJson1DeleteDatasetCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DeleteDatasetCommandOutput>;
+export declare const deserializeAws_restJson1DescribeDatasetCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeDatasetCommandOutput>;
+export declare const deserializeAws_restJson1DescribeIdentityPoolUsageCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeIdentityPoolUsageCommandOutput>;
+export declare const deserializeAws_restJson1DescribeIdentityUsageCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DescribeIdentityUsageCommandOutput>;
+export declare const deserializeAws_restJson1GetBulkPublishDetailsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetBulkPublishDetailsCommandOutput>;
+export declare const deserializeAws_restJson1GetCognitoEventsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetCognitoEventsCommandOutput>;
+export declare const deserializeAws_restJson1GetIdentityPoolConfigurationCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetIdentityPoolConfigurationCommandOutput>;
+export declare const deserializeAws_restJson1ListDatasetsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListDatasetsCommandOutput>;
+export declare const deserializeAws_restJson1ListIdentityPoolUsageCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListIdentityPoolUsageCommandOutput>;
+export declare const deserializeAws_restJson1ListRecordsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListRecordsCommandOutput>;
+export declare const deserializeAws_restJson1RegisterDeviceCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<RegisterDeviceCommandOutput>;
+export declare const deserializeAws_restJson1SetCognitoEventsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SetCognitoEventsCommandOutput>;
+export declare const deserializeAws_restJson1SetIdentityPoolConfigurationCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SetIdentityPoolConfigurationCommandOutput>;
+export declare const deserializeAws_restJson1SubscribeToDatasetCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SubscribeToDatasetCommandOutput>;
+export declare const deserializeAws_restJson1UnsubscribeFromDatasetCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<UnsubscribeFromDatasetCommandOutput>;
+export declare const deserializeAws_restJson1UpdateRecordsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<UpdateRecordsCommandOutput>;

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

@@ -0,0 +1,38 @@
+import { FetchHttpHandler as RequestHandler } from "@aws-sdk/fetch-http-handler";
+import { CognitoSyncClientConfig } from "./CognitoSyncClient";
+
+export declare const getRuntimeConfig: (config: CognitoSyncClientConfig) => {
+    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;
+};