serverless-spy
Version:
CDK-based library for writing elegant integration tests on AWS serverless architecture and an additional web console to monitor events in real time.
1,265 lines • 115 kB
JavaScript
import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, limitedParseDouble as __limitedParseDouble, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
import { v4 as generateIdempotencyToken } from "uuid";
import { DynamoDBServiceException as __BaseException } from "../models/DynamoDBServiceException";
import { AttributeValue, BackupInUseException, BackupNotFoundException, ConditionalCheckFailedException, ContinuousBackupsUnavailableException, DuplicateItemException, ExportConflictException, ExportNotFoundException, GlobalTableAlreadyExistsException, GlobalTableNotFoundException, IdempotentParameterMismatchException, ImportConflictException, ImportNotFoundException, IndexNotFoundException, InternalServerError, InvalidEndpointException, InvalidExportTimeException, InvalidRestoreTimeException, ItemCollectionSizeLimitExceededException, LimitExceededException, PointInTimeRecoveryUnavailableException, PolicyNotFoundException, ProvisionedThroughputExceededException, ReplicaAlreadyExistsException, ReplicaNotFoundException, ReplicatedWriteConflictException, RequestLimitExceeded, ResourceInUseException, ResourceNotFoundException, TableAlreadyExistsException, TableInUseException, TableNotFoundException, TransactionCanceledException, TransactionConflictException, TransactionInProgressException, } from "../models/models_0";
export const se_BatchExecuteStatementCommand = async (input, context) => {
const headers = sharedHeaders("BatchExecuteStatement");
let body;
body = JSON.stringify(se_BatchExecuteStatementInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_BatchGetItemCommand = async (input, context) => {
const headers = sharedHeaders("BatchGetItem");
let body;
body = JSON.stringify(se_BatchGetItemInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_BatchWriteItemCommand = async (input, context) => {
const headers = sharedHeaders("BatchWriteItem");
let body;
body = JSON.stringify(se_BatchWriteItemInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_CreateBackupCommand = async (input, context) => {
const headers = sharedHeaders("CreateBackup");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_CreateGlobalTableCommand = async (input, context) => {
const headers = sharedHeaders("CreateGlobalTable");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_CreateTableCommand = async (input, context) => {
const headers = sharedHeaders("CreateTable");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DeleteBackupCommand = async (input, context) => {
const headers = sharedHeaders("DeleteBackup");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DeleteItemCommand = async (input, context) => {
const headers = sharedHeaders("DeleteItem");
let body;
body = JSON.stringify(se_DeleteItemInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DeleteResourcePolicyCommand = async (input, context) => {
const headers = sharedHeaders("DeleteResourcePolicy");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DeleteTableCommand = async (input, context) => {
const headers = sharedHeaders("DeleteTable");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeBackupCommand = async (input, context) => {
const headers = sharedHeaders("DescribeBackup");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeContinuousBackupsCommand = async (input, context) => {
const headers = sharedHeaders("DescribeContinuousBackups");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeContributorInsightsCommand = async (input, context) => {
const headers = sharedHeaders("DescribeContributorInsights");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeEndpointsCommand = async (input, context) => {
const headers = sharedHeaders("DescribeEndpoints");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeExportCommand = async (input, context) => {
const headers = sharedHeaders("DescribeExport");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeGlobalTableCommand = async (input, context) => {
const headers = sharedHeaders("DescribeGlobalTable");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeGlobalTableSettingsCommand = async (input, context) => {
const headers = sharedHeaders("DescribeGlobalTableSettings");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeImportCommand = async (input, context) => {
const headers = sharedHeaders("DescribeImport");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeKinesisStreamingDestinationCommand = async (input, context) => {
const headers = sharedHeaders("DescribeKinesisStreamingDestination");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeLimitsCommand = async (input, context) => {
const headers = sharedHeaders("DescribeLimits");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeTableCommand = async (input, context) => {
const headers = sharedHeaders("DescribeTable");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeTableReplicaAutoScalingCommand = async (input, context) => {
const headers = sharedHeaders("DescribeTableReplicaAutoScaling");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DescribeTimeToLiveCommand = async (input, context) => {
const headers = sharedHeaders("DescribeTimeToLive");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_DisableKinesisStreamingDestinationCommand = async (input, context) => {
const headers = sharedHeaders("DisableKinesisStreamingDestination");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_EnableKinesisStreamingDestinationCommand = async (input, context) => {
const headers = sharedHeaders("EnableKinesisStreamingDestination");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ExecuteStatementCommand = async (input, context) => {
const headers = sharedHeaders("ExecuteStatement");
let body;
body = JSON.stringify(se_ExecuteStatementInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ExecuteTransactionCommand = async (input, context) => {
const headers = sharedHeaders("ExecuteTransaction");
let body;
body = JSON.stringify(se_ExecuteTransactionInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ExportTableToPointInTimeCommand = async (input, context) => {
const headers = sharedHeaders("ExportTableToPointInTime");
let body;
body = JSON.stringify(se_ExportTableToPointInTimeInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_GetItemCommand = async (input, context) => {
const headers = sharedHeaders("GetItem");
let body;
body = JSON.stringify(se_GetItemInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_GetResourcePolicyCommand = async (input, context) => {
const headers = sharedHeaders("GetResourcePolicy");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ImportTableCommand = async (input, context) => {
const headers = sharedHeaders("ImportTable");
let body;
body = JSON.stringify(se_ImportTableInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ListBackupsCommand = async (input, context) => {
const headers = sharedHeaders("ListBackups");
let body;
body = JSON.stringify(se_ListBackupsInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ListContributorInsightsCommand = async (input, context) => {
const headers = sharedHeaders("ListContributorInsights");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ListExportsCommand = async (input, context) => {
const headers = sharedHeaders("ListExports");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ListGlobalTablesCommand = async (input, context) => {
const headers = sharedHeaders("ListGlobalTables");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ListImportsCommand = async (input, context) => {
const headers = sharedHeaders("ListImports");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ListTablesCommand = async (input, context) => {
const headers = sharedHeaders("ListTables");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ListTagsOfResourceCommand = async (input, context) => {
const headers = sharedHeaders("ListTagsOfResource");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_PutItemCommand = async (input, context) => {
const headers = sharedHeaders("PutItem");
let body;
body = JSON.stringify(se_PutItemInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_PutResourcePolicyCommand = async (input, context) => {
const headers = sharedHeaders("PutResourcePolicy");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_QueryCommand = async (input, context) => {
const headers = sharedHeaders("Query");
let body;
body = JSON.stringify(se_QueryInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_RestoreTableFromBackupCommand = async (input, context) => {
const headers = sharedHeaders("RestoreTableFromBackup");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_RestoreTableToPointInTimeCommand = async (input, context) => {
const headers = sharedHeaders("RestoreTableToPointInTime");
let body;
body = JSON.stringify(se_RestoreTableToPointInTimeInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_ScanCommand = async (input, context) => {
const headers = sharedHeaders("Scan");
let body;
body = JSON.stringify(se_ScanInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_TagResourceCommand = async (input, context) => {
const headers = sharedHeaders("TagResource");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_TransactGetItemsCommand = async (input, context) => {
const headers = sharedHeaders("TransactGetItems");
let body;
body = JSON.stringify(se_TransactGetItemsInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_TransactWriteItemsCommand = async (input, context) => {
const headers = sharedHeaders("TransactWriteItems");
let body;
body = JSON.stringify(se_TransactWriteItemsInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UntagResourceCommand = async (input, context) => {
const headers = sharedHeaders("UntagResource");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateContinuousBackupsCommand = async (input, context) => {
const headers = sharedHeaders("UpdateContinuousBackups");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateContributorInsightsCommand = async (input, context) => {
const headers = sharedHeaders("UpdateContributorInsights");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateGlobalTableCommand = async (input, context) => {
const headers = sharedHeaders("UpdateGlobalTable");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateGlobalTableSettingsCommand = async (input, context) => {
const headers = sharedHeaders("UpdateGlobalTableSettings");
let body;
body = JSON.stringify(se_UpdateGlobalTableSettingsInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateItemCommand = async (input, context) => {
const headers = sharedHeaders("UpdateItem");
let body;
body = JSON.stringify(se_UpdateItemInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateKinesisStreamingDestinationCommand = async (input, context) => {
const headers = sharedHeaders("UpdateKinesisStreamingDestination");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateTableCommand = async (input, context) => {
const headers = sharedHeaders("UpdateTable");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateTableReplicaAutoScalingCommand = async (input, context) => {
const headers = sharedHeaders("UpdateTableReplicaAutoScaling");
let body;
body = JSON.stringify(se_UpdateTableReplicaAutoScalingInput(input, context));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const se_UpdateTimeToLiveCommand = async (input, context) => {
const headers = sharedHeaders("UpdateTimeToLive");
let body;
body = JSON.stringify(_json(input));
return buildHttpRpcRequest(context, headers, "/", undefined, body);
};
export const de_BatchExecuteStatementCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_BatchExecuteStatementOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_BatchGetItemCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_BatchGetItemOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_BatchWriteItemCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_BatchWriteItemOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_CreateBackupCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_CreateBackupOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_CreateGlobalTableCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_CreateGlobalTableOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_CreateTableCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_CreateTableOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DeleteBackupCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DeleteBackupOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DeleteItemCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DeleteItemOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DeleteResourcePolicyCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DeleteTableCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DeleteTableOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeBackupCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DescribeBackupOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeContinuousBackupsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DescribeContinuousBackupsOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeContributorInsightsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DescribeContributorInsightsOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeEndpointsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeExportCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DescribeExportOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeGlobalTableCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DescribeGlobalTableOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeGlobalTableSettingsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DescribeGlobalTableSettingsOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeImportCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DescribeImportOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeKinesisStreamingDestinationCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeLimitsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeTableCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DescribeTableOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeTableReplicaAutoScalingCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_DescribeTableReplicaAutoScalingOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DescribeTimeToLiveCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_DisableKinesisStreamingDestinationCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_EnableKinesisStreamingDestinationCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ExecuteStatementCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_ExecuteStatementOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ExecuteTransactionCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_ExecuteTransactionOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ExportTableToPointInTimeCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_ExportTableToPointInTimeOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_GetItemCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_GetItemOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_GetResourcePolicyCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ImportTableCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_ImportTableOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ListBackupsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_ListBackupsOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ListContributorInsightsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ListExportsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ListGlobalTablesCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ListImportsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_ListImportsOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ListTablesCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ListTagsOfResourceCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_PutItemCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_PutItemOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_PutResourcePolicyCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_QueryCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_QueryOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_RestoreTableFromBackupCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_RestoreTableFromBackupOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_RestoreTableToPointInTimeCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_RestoreTableToPointInTimeOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_ScanCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_ScanOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_TagResourceCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
await collectBody(output.body, context);
const response = {
$metadata: deserializeMetadata(output),
};
return response;
};
export const de_TransactGetItemsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_TransactGetItemsOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_TransactWriteItemsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_TransactWriteItemsOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_UntagResourceCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
await collectBody(output.body, context);
const response = {
$metadata: deserializeMetadata(output),
};
return response;
};
export const de_UpdateContinuousBackupsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_UpdateContinuousBackupsOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_UpdateContributorInsightsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_UpdateGlobalTableCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_UpdateGlobalTableOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_UpdateGlobalTableSettingsCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_UpdateGlobalTableSettingsOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_UpdateItemCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_UpdateItemOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_UpdateKinesisStreamingDestinationCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_UpdateTableCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_UpdateTableOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_UpdateTableReplicaAutoScalingCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = de_UpdateTableReplicaAutoScalingOutput(data, context);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
export const de_UpdateTimeToLiveCommand = async (output, context) => {
if (output.statusCode >= 300) {
return de_CommandError(output, context);
}
const data = await parseBody(output.body, context);
let contents = {};
contents = _json(data);
const response = {
$metadata: deserializeMetadata(output),
...contents,
};
return response;
};
const de_CommandError = async (output, context) => {
const parsedOutput = {
...output,
body: await parseErrorBody(output.body, context),
};
const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
switch (errorCode) {
case "InternalServerError":
case "com.amazonaws.dynamodb#InternalServerError":
throw await de_InternalServerErrorRes(parsedOutput, context);
case "RequestLimitExceeded":
case "com.amazonaws.dynamodb#RequestLimitExceeded":
throw await de_RequestLimitExceededRes(parsedOutput, context);
case "InvalidEndpointException":
case "com.amazonaws.dynamodb#InvalidEndpointException":
throw await de_InvalidEndpointExceptionRes(parsedOutput, context);
case "ProvisionedThroughputExceededException":
case "com.amazonaws.dynamodb#ProvisionedThroughputExceededException":
throw await de_ProvisionedThroughputExceededExceptionRes(parsedOutput, context);
case "ResourceNotFoundException":
case "com.amazonaws.dynamodb#ResourceNotFoundException":
throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
case "ItemCollectionSizeLimitExceededException":
case "com.amazonaws.dynamodb#ItemCollectionSizeLimitExceededException":
throw await de_ItemCollectionSizeLimitExceededExceptionRes(parsedOutput, context);
case "BackupInUseException":
case "com.amazonaws.dynamodb#BackupInUseException":
throw await de_BackupInUseExceptionRes(parsedOutput, context);
case "ContinuousBackupsUnavailableException":
case "com.amazonaws.dynamodb#ContinuousBackupsUnavailableException":
throw await de_ContinuousBackupsUnavailableExceptionRes(parsedOutput, context);
case "LimitExceededException":
case "com.amazonaws.dynamodb#LimitExceededException":
throw await de_LimitExceededExceptionRes(parsedOutput, context);
case "TableInUseException":
case "com.amazonaws.dynamodb#TableInUseException":
throw await de_TableInUseExceptionRes(parsedOutput, context);
case "TableNotFoundException":
case "com.amazonaws.dynamodb#TableNotFoundException":
throw await de_TableNotFoundExceptionRes(parsedOutput, context);
case "GlobalTableAlreadyExistsException":
case "com.amazonaws.dynamodb#GlobalTableAlreadyExistsException":
throw await de_GlobalTableAlreadyExistsExceptionRes(parsedOutput, context);
case "ResourceInUseException":
case "com.amazonaws.dynamodb#ResourceInUseException":
throw await de_ResourceInUseExceptionRes(parsedOutput, context);
case "BackupNotFoundException":
case "com.amazonaws.dynamodb#BackupNotFoundException":
throw await de_BackupNotFoundExceptionRes(parsedOutput, context);
case "ConditionalCheckFailedException":
case "com.amazonaws.dynamodb#ConditionalCheckFailedException":
throw await de_ConditionalCheckFailedExceptionRes(parsedOutput, context);
case "ReplicatedWriteConflictException":
case "com.amazonaws.dynamodb#ReplicatedWriteConflictException":
throw await de_ReplicatedWriteConflictExceptionRes(parsedOutput, context);
case "TransactionConflictException":
case "com.amazonaws.dynamodb#TransactionConflictException":
throw await de_TransactionConflictExceptionRes(parsedOutput, context);
case "PolicyNotFoundException":
case "com.amazonaws.dynamodb#PolicyNotFoundException":
throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
case "ExportNotFoundException":
case "com.amazonaws.dynamodb#ExportNotFoundException":
throw await de_ExportNotFoundExceptionRes(parsedOutput, context);
case "GlobalTableNotFoundException":
case "com.amazonaws.dynamodb#GlobalTableNotFoundException":
throw await de_GlobalTableNotFoundExceptionRes(parsedOutput, context);
case "ImportNotFoundException":
case "com.amazonaws.dynamodb#ImportNotFoundException":
throw await de_ImportNotFoundExceptionRes(parsedOutput, context);
case "DuplicateItemException":
case "com.amazonaws.dynamodb#DuplicateItemException":
throw await de_DuplicateItemExceptionRes(parsedOutput, context);
case "IdempotentParameterMismatchException":
case "com.amazonaws.dynamodb#IdempotentParameterMismatchException":
throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
case "TransactionCanceledException":
case "com.amazonaws.dynamodb#TransactionCanceledException":
throw await de_TransactionCanceledExceptionRes(parsedOutput, context);
case "TransactionInProgressException":
case "com.amazonaws.dynamodb#TransactionInProgressException":
throw await de_TransactionInProgressExceptionRes(parsedOutput, context);
case "ExportConflictException":
case "com.amazonaws.dynamodb#ExportConflictException":
throw await de_ExportConflictExceptionRes(parsedOutput, context);
case "InvalidExportTimeException":
case "com.amazonaws.dynamodb#InvalidExportTimeException":
throw await de_InvalidExportTimeExceptionRes(parsedOutput, context);
case "PointInTimeRecoveryUnavailableException":
case "com.amazonaws.dynamodb#PointInTimeRecoveryUnavailableException":
throw await de_PointInTimeRecoveryUnavailableExceptionRes(parsedOutput, context);
case "ImportConflictException":
case "com.amazonaws.dynamodb#ImportConflictException":
throw await de_ImportConflictExceptionRes(parsedOutput, context);
case "TableAlreadyExistsException":
case "com.amazonaws.dynamodb#TableAlreadyExistsException":
throw await de_TableAlreadyExistsExceptionRes(parsedOutput, context);
case "InvalidRestoreTimeException":
case "com.amazonaws.dynamodb#InvalidRestoreTimeException":
throw await de_InvalidRestoreTimeExceptionRes(parsedOutput, context);
case "ReplicaAlreadyExistsException":
case "com.amazonaws.dynamodb#ReplicaAlreadyExistsException":
throw await de_ReplicaAlreadyExistsExceptionRes(parsedOutput, context);
case "ReplicaNotFoundException":
case "com.amazonaws.dynamodb#ReplicaNotFoundException":
throw await de_ReplicaNotFoundExceptionRes(parsedOutput, context);
case "IndexNotFoundException":
case "com.amazonaws.dynamodb#IndexNotFoundException":
throw await de_IndexNotFoundExceptionRes(parsedOutput, context);
default:
const parsedBody = parsedOutput.body;
return throwDefaultError({
output,
parsedBody,
errorCode,
});
}
};
const de_BackupInUseExceptionRes = async (parsedOutput, context) => {
const body = parsedOutput.body;
const deserialized = _json(body);
const exception = new BackupInUseException({
$metadata: deserializeMetadata(parsedOutput),
...deserialized,
});
return __decorateServiceException(exception, body);
};
const de_BackupNotFoundExceptionRes = async (parsedOutput, context) => {
const body = parsedOutput.body;
const deserialized = _json(body);
const exception = new BackupNotFoundException({
$metadata: deserializeMetadata(parsedOutput),
...deserialized,
});
return __decorateServiceException(exception, body);
};
const de_ConditionalCheckFailedExceptionRes = async (parsedOutput, context) => {
const body = parsedOutput.body;
const deserialized = de_ConditionalCheckFailedException(body, context);
const exception = new ConditionalCheckFailedException({
$metadata: deserializeMetadata(parsedOutput),
...deserialized,
});
return __decorateServiceException(exception, body);
};
const de_ContinuousBackupsUnavailableExceptionRes = async (parsedOutput, context) => {
const body = parsedOutput.body;
const deserialized = _json(body);
const exception = new ContinuousBackupsUnavailableException({
$metadata: deserializeMetadata(parsedOutput),
...deserialized,
});
return __decorateServiceException(exception, body);
};
const de_DuplicateItemExceptionRes = async (parsedOutput, context) => {
const body = parsedOutput.body;
const deserialized = _json(body);
const exception = new DuplicateItemException({
$metadata: deserializeMetadata(parsedOutput),
...deserialized,
});
return __decorateServiceException(exception, body);
};
const de_ExportConflictExceptionRes = async (parsedOutput, context) => {
const body = parsedOutput.body;
const deserialized = _json(body);
const exception = new ExportConflictException({
$metadata: deserializeMetadata(parsedOutput),
...deserialized,
});
return __decorateServiceException(exception, body);
};
const de_ExportNotFoundExceptionRes = async (parsedOutput, context) => {
const body = parsedOutput.body;
const deserialized = _json(body);
const exception = new ExportNotFoundException({
$metadata: deserializeMetadata(parsedOutput),
...deserialized,
});
return __decorateServiceException(exception, body);
};
const de_GlobalTableAlreadyExistsExceptionRes = async (parsed