@aws-sdk/client-marketplace-metering 3.927.0 → 3.928.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class MarketplaceMeteringClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,19 +110,19 @@ class MarketplaceMeteringClient extends smithyClient.Client {
     }
 }
 
-class MarketplaceMeteringServiceException extends smithyClient.ServiceException {
+let MarketplaceMeteringServiceException$1 = class MarketplaceMeteringServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, MarketplaceMeteringServiceException.prototype);
     }
-}
+};
 
 const UsageRecordResultStatus = {
     CUSTOMER_NOT_SUBSCRIBED: "CustomerNotSubscribed",
     DUPLICATE_RECORD: "DuplicateRecord",
     SUCCESS: "Success",
 };
-class DisabledApiException extends MarketplaceMeteringServiceException {
+let DisabledApiException$1 = class DisabledApiException extends MarketplaceMeteringServiceException$1 {
     name = "DisabledApiException";
     $fault = "client";
     constructor(opts) {
@@ -134,8 +133,8 @@ class DisabledApiException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, DisabledApiException.prototype);
     }
-}
-class InternalServiceErrorException extends MarketplaceMeteringServiceException {
+};
+let InternalServiceErrorException$1 = class InternalServiceErrorException extends MarketplaceMeteringServiceException$1 {
     name = "InternalServiceErrorException";
     $fault = "server";
     constructor(opts) {
@@ -146,8 +145,8 @@ class InternalServiceErrorException extends MarketplaceMeteringServiceException
         });
         Object.setPrototypeOf(this, InternalServiceErrorException.prototype);
     }
-}
-class InvalidCustomerIdentifierException extends MarketplaceMeteringServiceException {
+};
+let InvalidCustomerIdentifierException$1 = class InvalidCustomerIdentifierException extends MarketplaceMeteringServiceException$1 {
     name = "InvalidCustomerIdentifierException";
     $fault = "client";
     constructor(opts) {
@@ -158,8 +157,8 @@ class InvalidCustomerIdentifierException extends MarketplaceMeteringServiceExcep
         });
         Object.setPrototypeOf(this, InvalidCustomerIdentifierException.prototype);
     }
-}
-class InvalidProductCodeException extends MarketplaceMeteringServiceException {
+};
+let InvalidProductCodeException$1 = class InvalidProductCodeException extends MarketplaceMeteringServiceException$1 {
     name = "InvalidProductCodeException";
     $fault = "client";
     constructor(opts) {
@@ -170,8 +169,8 @@ class InvalidProductCodeException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, InvalidProductCodeException.prototype);
     }
-}
-class InvalidTagException extends MarketplaceMeteringServiceException {
+};
+let InvalidTagException$1 = class InvalidTagException extends MarketplaceMeteringServiceException$1 {
     name = "InvalidTagException";
     $fault = "client";
     constructor(opts) {
@@ -182,8 +181,8 @@ class InvalidTagException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, InvalidTagException.prototype);
     }
-}
-class InvalidUsageAllocationsException extends MarketplaceMeteringServiceException {
+};
+let InvalidUsageAllocationsException$1 = class InvalidUsageAllocationsException extends MarketplaceMeteringServiceException$1 {
     name = "InvalidUsageAllocationsException";
     $fault = "client";
     constructor(opts) {
@@ -194,8 +193,8 @@ class InvalidUsageAllocationsException extends MarketplaceMeteringServiceExcepti
         });
         Object.setPrototypeOf(this, InvalidUsageAllocationsException.prototype);
     }
-}
-class InvalidUsageDimensionException extends MarketplaceMeteringServiceException {
+};
+let InvalidUsageDimensionException$1 = class InvalidUsageDimensionException extends MarketplaceMeteringServiceException$1 {
     name = "InvalidUsageDimensionException";
     $fault = "client";
     constructor(opts) {
@@ -206,8 +205,8 @@ class InvalidUsageDimensionException extends MarketplaceMeteringServiceException
         });
         Object.setPrototypeOf(this, InvalidUsageDimensionException.prototype);
     }
-}
-class ThrottlingException extends MarketplaceMeteringServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends MarketplaceMeteringServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -218,8 +217,8 @@ class ThrottlingException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
-class TimestampOutOfBoundsException extends MarketplaceMeteringServiceException {
+};
+let TimestampOutOfBoundsException$1 = class TimestampOutOfBoundsException extends MarketplaceMeteringServiceException$1 {
     name = "TimestampOutOfBoundsException";
     $fault = "client";
     constructor(opts) {
@@ -230,8 +229,8 @@ class TimestampOutOfBoundsException extends MarketplaceMeteringServiceException
         });
         Object.setPrototypeOf(this, TimestampOutOfBoundsException.prototype);
     }
-}
-class CustomerNotEntitledException extends MarketplaceMeteringServiceException {
+};
+let CustomerNotEntitledException$1 = class CustomerNotEntitledException extends MarketplaceMeteringServiceException$1 {
     name = "CustomerNotEntitledException";
     $fault = "client";
     constructor(opts) {
@@ -242,8 +241,8 @@ class CustomerNotEntitledException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, CustomerNotEntitledException.prototype);
     }
-}
-class DuplicateRequestException extends MarketplaceMeteringServiceException {
+};
+let DuplicateRequestException$1 = class DuplicateRequestException extends MarketplaceMeteringServiceException$1 {
     name = "DuplicateRequestException";
     $fault = "client";
     constructor(opts) {
@@ -254,8 +253,8 @@ class DuplicateRequestException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, DuplicateRequestException.prototype);
     }
-}
-class IdempotencyConflictException extends MarketplaceMeteringServiceException {
+};
+let IdempotencyConflictException$1 = class IdempotencyConflictException extends MarketplaceMeteringServiceException$1 {
     name = "IdempotencyConflictException";
     $fault = "client";
     constructor(opts) {
@@ -266,8 +265,8 @@ class IdempotencyConflictException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, IdempotencyConflictException.prototype);
     }
-}
-class InvalidEndpointRegionException extends MarketplaceMeteringServiceException {
+};
+let InvalidEndpointRegionException$1 = class InvalidEndpointRegionException extends MarketplaceMeteringServiceException$1 {
     name = "InvalidEndpointRegionException";
     $fault = "client";
     constructor(opts) {
@@ -278,8 +277,8 @@ class InvalidEndpointRegionException extends MarketplaceMeteringServiceException
         });
         Object.setPrototypeOf(this, InvalidEndpointRegionException.prototype);
     }
-}
-class InvalidPublicKeyVersionException extends MarketplaceMeteringServiceException {
+};
+let InvalidPublicKeyVersionException$1 = class InvalidPublicKeyVersionException extends MarketplaceMeteringServiceException$1 {
     name = "InvalidPublicKeyVersionException";
     $fault = "client";
     constructor(opts) {
@@ -290,8 +289,8 @@ class InvalidPublicKeyVersionException extends MarketplaceMeteringServiceExcepti
         });
         Object.setPrototypeOf(this, InvalidPublicKeyVersionException.prototype);
     }
-}
-class InvalidRegionException extends MarketplaceMeteringServiceException {
+};
+let InvalidRegionException$1 = class InvalidRegionException extends MarketplaceMeteringServiceException$1 {
     name = "InvalidRegionException";
     $fault = "client";
     constructor(opts) {
@@ -302,8 +301,8 @@ class InvalidRegionException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, InvalidRegionException.prototype);
     }
-}
-class PlatformNotSupportedException extends MarketplaceMeteringServiceException {
+};
+let PlatformNotSupportedException$1 = class PlatformNotSupportedException extends MarketplaceMeteringServiceException$1 {
     name = "PlatformNotSupportedException";
     $fault = "client";
     constructor(opts) {
@@ -314,8 +313,8 @@ class PlatformNotSupportedException extends MarketplaceMeteringServiceException
         });
         Object.setPrototypeOf(this, PlatformNotSupportedException.prototype);
     }
-}
-class ExpiredTokenException extends MarketplaceMeteringServiceException {
+};
+let ExpiredTokenException$1 = class ExpiredTokenException extends MarketplaceMeteringServiceException$1 {
     name = "ExpiredTokenException";
     $fault = "client";
     constructor(opts) {
@@ -326,8 +325,8 @@ class ExpiredTokenException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, ExpiredTokenException.prototype);
     }
-}
-class InvalidTokenException extends MarketplaceMeteringServiceException {
+};
+let InvalidTokenException$1 = class InvalidTokenException extends MarketplaceMeteringServiceException$1 {
     name = "InvalidTokenException";
     $fault = "client";
     constructor(opts) {
@@ -338,438 +337,357 @@ class InvalidTokenException extends MarketplaceMeteringServiceException {
         });
         Object.setPrototypeOf(this, InvalidTokenException.prototype);
     }
-}
-
-const se_BatchMeterUsageCommand = async (input, context) => {
-    const headers = sharedHeaders("BatchMeterUsage");
-    let body;
-    body = JSON.stringify(se_BatchMeterUsageRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_MeterUsageCommand = async (input, context) => {
-    const headers = sharedHeaders("MeterUsage");
-    let body;
-    body = JSON.stringify(se_MeterUsageRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RegisterUsageCommand = async (input, context) => {
-    const headers = sharedHeaders("RegisterUsage");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ResolveCustomerCommand = async (input, context) => {
-    const headers = sharedHeaders("ResolveCustomer");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_BatchMeterUsageCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_BatchMeterUsageResult(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_MeterUsageCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RegisterUsageCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_RegisterUsageResult(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ResolveCustomerCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "DisabledApiException":
-        case "com.amazonaws.marketplacemetering#DisabledApiException":
-            throw await de_DisabledApiExceptionRes(parsedOutput);
-        case "InternalServiceErrorException":
-        case "com.amazonaws.marketplacemetering#InternalServiceErrorException":
-            throw await de_InternalServiceErrorExceptionRes(parsedOutput);
-        case "InvalidCustomerIdentifierException":
-        case "com.amazonaws.marketplacemetering#InvalidCustomerIdentifierException":
-            throw await de_InvalidCustomerIdentifierExceptionRes(parsedOutput);
-        case "InvalidProductCodeException":
-        case "com.amazonaws.marketplacemetering#InvalidProductCodeException":
-            throw await de_InvalidProductCodeExceptionRes(parsedOutput);
-        case "InvalidTagException":
-        case "com.amazonaws.marketplacemetering#InvalidTagException":
-            throw await de_InvalidTagExceptionRes(parsedOutput);
-        case "InvalidUsageAllocationsException":
-        case "com.amazonaws.marketplacemetering#InvalidUsageAllocationsException":
-            throw await de_InvalidUsageAllocationsExceptionRes(parsedOutput);
-        case "InvalidUsageDimensionException":
-        case "com.amazonaws.marketplacemetering#InvalidUsageDimensionException":
-            throw await de_InvalidUsageDimensionExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.marketplacemetering#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "TimestampOutOfBoundsException":
-        case "com.amazonaws.marketplacemetering#TimestampOutOfBoundsException":
-            throw await de_TimestampOutOfBoundsExceptionRes(parsedOutput);
-        case "CustomerNotEntitledException":
-        case "com.amazonaws.marketplacemetering#CustomerNotEntitledException":
-            throw await de_CustomerNotEntitledExceptionRes(parsedOutput);
-        case "DuplicateRequestException":
-        case "com.amazonaws.marketplacemetering#DuplicateRequestException":
-            throw await de_DuplicateRequestExceptionRes(parsedOutput);
-        case "IdempotencyConflictException":
-        case "com.amazonaws.marketplacemetering#IdempotencyConflictException":
-            throw await de_IdempotencyConflictExceptionRes(parsedOutput);
-        case "InvalidEndpointRegionException":
-        case "com.amazonaws.marketplacemetering#InvalidEndpointRegionException":
-            throw await de_InvalidEndpointRegionExceptionRes(parsedOutput);
-        case "InvalidPublicKeyVersionException":
-        case "com.amazonaws.marketplacemetering#InvalidPublicKeyVersionException":
-            throw await de_InvalidPublicKeyVersionExceptionRes(parsedOutput);
-        case "InvalidRegionException":
-        case "com.amazonaws.marketplacemetering#InvalidRegionException":
-            throw await de_InvalidRegionExceptionRes(parsedOutput);
-        case "PlatformNotSupportedException":
-        case "com.amazonaws.marketplacemetering#PlatformNotSupportedException":
-            throw await de_PlatformNotSupportedExceptionRes(parsedOutput);
-        case "ExpiredTokenException":
-        case "com.amazonaws.marketplacemetering#ExpiredTokenException":
-            throw await de_ExpiredTokenExceptionRes(parsedOutput);
-        case "InvalidTokenException":
-        case "com.amazonaws.marketplacemetering#InvalidTokenException":
-            throw await de_InvalidTokenExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_CustomerNotEntitledExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new CustomerNotEntitledException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_DisabledApiExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new DisabledApiException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_DuplicateRequestExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new DuplicateRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ExpiredTokenExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ExpiredTokenException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_IdempotencyConflictExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new IdempotencyConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InternalServiceErrorExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InternalServiceErrorException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidCustomerIdentifierExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidCustomerIdentifierException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidEndpointRegionExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidEndpointRegionException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidProductCodeExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidProductCodeException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidPublicKeyVersionExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidPublicKeyVersionException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidRegionExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidRegionException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidTagExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidTagException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidTokenExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidTokenException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidUsageAllocationsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidUsageAllocationsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidUsageDimensionExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidUsageDimensionException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_PlatformNotSupportedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new PlatformNotSupportedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TimestampOutOfBoundsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TimestampOutOfBoundsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_BatchMeterUsageRequest = (input, context) => {
-    return smithyClient.take(input, {
-        ProductCode: [],
-        UsageRecords: (_) => se_UsageRecordList(_),
-    });
-};
-const se_MeterUsageRequest = (input, context) => {
-    return smithyClient.take(input, {
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        DryRun: [],
-        ProductCode: [],
-        Timestamp: (_) => _.getTime() / 1_000,
-        UsageAllocations: smithyClient._json,
-        UsageDimension: [],
-        UsageQuantity: [],
-    });
-};
-const se_UsageRecord = (input, context) => {
-    return smithyClient.take(input, {
-        CustomerAWSAccountId: [],
-        CustomerIdentifier: [],
-        Dimension: [],
-        Quantity: [],
-        Timestamp: (_) => _.getTime() / 1_000,
-        UsageAllocations: smithyClient._json,
-    });
-};
-const se_UsageRecordList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_UsageRecord(entry);
-    });
-};
-const de_BatchMeterUsageResult = (output, context) => {
-    return smithyClient.take(output, {
-        Results: (_) => de_UsageRecordResultList(_),
-        UnprocessedRecords: (_) => de_UsageRecordList(_),
-    });
-};
-const de_RegisterUsageResult = (output, context) => {
-    return smithyClient.take(output, {
-        PublicKeyRotationTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Signature: smithyClient.expectString,
-    });
-};
-const de_UsageRecord = (output, context) => {
-    return smithyClient.take(output, {
-        CustomerAWSAccountId: smithyClient.expectString,
-        CustomerIdentifier: smithyClient.expectString,
-        Dimension: smithyClient.expectString,
-        Quantity: smithyClient.expectInt32,
-        Timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        UsageAllocations: smithyClient._json,
-    });
-};
-const de_UsageRecordList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_UsageRecord(entry);
-    });
-    return retVal;
-};
-const de_UsageRecordResult = (output, context) => {
-    return smithyClient.take(output, {
-        MeteringRecordId: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        UsageRecord: (_) => de_UsageRecord(_),
-    });
-};
-const de_UsageRecordResultList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_UsageRecordResult(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(MarketplaceMeteringServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
 };
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": `AWSMPMeteringService.${operation}`,
-    };
-}
+
+const _AUQ = "AllocatedUsageQuantity";
+const _BMU = "BatchMeterUsage";
+const _BMUR = "BatchMeterUsageRequest";
+const _BMURa = "BatchMeterUsageResult";
+const _CAWSAI = "CustomerAWSAccountId";
+const _CI = "CustomerIdentifier";
+const _CNEE = "CustomerNotEntitledException";
+const _CT = "ClientToken";
+const _D = "Dimension";
+const _DAE = "DisabledApiException";
+const _DR = "DryRun";
+const _DRE = "DuplicateRequestException";
+const _ETE = "ExpiredTokenException";
+const _ICE = "IdempotencyConflictException";
+const _ICIE = "InvalidCustomerIdentifierException";
+const _IERE = "InvalidEndpointRegionException";
+const _IPCE = "InvalidProductCodeException";
+const _IPKVE = "InvalidPublicKeyVersionException";
+const _IRE = "InvalidRegionException";
+const _ISEE = "InternalServiceErrorException";
+const _ITE = "InvalidTagException";
+const _ITEn = "InvalidTokenException";
+const _IUAE = "InvalidUsageAllocationsException";
+const _IUDE = "InvalidUsageDimensionException";
+const _K = "Key";
+const _MRI = "MeteringRecordId";
+const _MU = "MeterUsage";
+const _MUR = "MeterUsageRequest";
+const _MURe = "MeterUsageResult";
+const _N = "Nonce";
+const _PC = "ProductCode";
+const _PKRT = "PublicKeyRotationTimestamp";
+const _PKV = "PublicKeyVersion";
+const _PNSE = "PlatformNotSupportedException";
+const _Q = "Quantity";
+const _R = "Results";
+const _RC = "ResolveCustomer";
+const _RCR = "ResolveCustomerRequest";
+const _RCRe = "ResolveCustomerResult";
+const _RT = "RegistrationToken";
+const _RU = "RegisterUsage";
+const _RUR = "RegisterUsageRequest";
+const _RURe = "RegisterUsageResult";
+const _S = "Signature";
+const _St = "Status";
+const _T = "Timestamp";
+const _TE = "ThrottlingException";
+const _TL = "TagList";
+const _TOOBE = "TimestampOutOfBoundsException";
+const _Ta = "Tag";
+const _Tag = "Tags";
+const _UA = "UsageAllocations";
+const _UAs = "UsageAllocation";
+const _UD = "UsageDimension";
+const _UQ = "UsageQuantity";
+const _UR = "UsageRecords";
+const _URL = "UsageRecordList";
+const _URR = "UsageRecordResult";
+const _URRL = "UsageRecordResultList";
+const _URn = "UnprocessedRecords";
+const _URs = "UsageRecord";
+const _V = "Value";
+const _c = "client";
+const _e = "error";
+const _hE = "httpError";
+const _m = "message";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.marketplacemetering";
+const n0 = "com.amazonaws.marketplacemetering";
+var BatchMeterUsageRequest = [3, n0, _BMUR, 0, [_UR, _PC], [() => UsageRecordList, 0]];
+var BatchMeterUsageResult = [
+    3,
+    n0,
+    _BMURa,
+    0,
+    [_R, _URn],
+    [() => UsageRecordResultList, () => UsageRecordList],
+];
+var CustomerNotEntitledException = [
+    -3,
+    n0,
+    _CNEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(CustomerNotEntitledException, CustomerNotEntitledException$1);
+var DisabledApiException = [
+    -3,
+    n0,
+    _DAE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DisabledApiException, DisabledApiException$1);
+var DuplicateRequestException = [
+    -3,
+    n0,
+    _DRE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DuplicateRequestException, DuplicateRequestException$1);
+var ExpiredTokenException = [
+    -3,
+    n0,
+    _ETE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ExpiredTokenException, ExpiredTokenException$1);
+var IdempotencyConflictException = [
+    -3,
+    n0,
+    _ICE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(IdempotencyConflictException, IdempotencyConflictException$1);
+var InternalServiceErrorException = [
+    -3,
+    n0,
+    _ISEE,
+    {
+        [_e]: _s,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServiceErrorException, InternalServiceErrorException$1);
+var InvalidCustomerIdentifierException = [
+    -3,
+    n0,
+    _ICIE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidCustomerIdentifierException, InvalidCustomerIdentifierException$1);
+var InvalidEndpointRegionException = [
+    -3,
+    n0,
+    _IERE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidEndpointRegionException, InvalidEndpointRegionException$1);
+var InvalidProductCodeException = [
+    -3,
+    n0,
+    _IPCE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidProductCodeException, InvalidProductCodeException$1);
+var InvalidPublicKeyVersionException = [
+    -3,
+    n0,
+    _IPKVE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidPublicKeyVersionException, InvalidPublicKeyVersionException$1);
+var InvalidRegionException = [
+    -3,
+    n0,
+    _IRE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidRegionException, InvalidRegionException$1);
+var InvalidTagException = [
+    -3,
+    n0,
+    _ITE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidTagException, InvalidTagException$1);
+var InvalidTokenException = [
+    -3,
+    n0,
+    _ITEn,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidTokenException, InvalidTokenException$1);
+var InvalidUsageAllocationsException = [
+    -3,
+    n0,
+    _IUAE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidUsageAllocationsException, InvalidUsageAllocationsException$1);
+var InvalidUsageDimensionException = [
+    -3,
+    n0,
+    _IUDE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidUsageDimensionException, InvalidUsageDimensionException$1);
+var MeterUsageRequest = [
+    3,
+    n0,
+    _MUR,
+    0,
+    [_PC, _T, _UD, _UQ, _DR, _UA, _CT],
+    [0, 4, 0, 1, 2, () => UsageAllocations, [0, 4]],
+];
+var MeterUsageResult = [3, n0, _MURe, 0, [_MRI], [0]];
+var PlatformNotSupportedException = [
+    -3,
+    n0,
+    _PNSE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(PlatformNotSupportedException, PlatformNotSupportedException$1);
+var RegisterUsageRequest = [3, n0, _RUR, 0, [_PC, _PKV, _N], [0, 1, 0]];
+var RegisterUsageResult = [3, n0, _RURe, 0, [_PKRT, _S], [4, 0]];
+var ResolveCustomerRequest = [3, n0, _RCR, 0, [_RT], [0]];
+var ResolveCustomerResult = [3, n0, _RCRe, 0, [_CI, _PC, _CAWSAI], [0, 0, 0]];
+var Tag = [3, n0, _Ta, 0, [_K, _V], [0, 0]];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TimestampOutOfBoundsException = [
+    -3,
+    n0,
+    _TOOBE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TimestampOutOfBoundsException, TimestampOutOfBoundsException$1);
+var UsageAllocation = [3, n0, _UAs, 0, [_AUQ, _Tag], [1, () => TagList]];
+var UsageRecord = [
+    3,
+    n0,
+    _URs,
+    0,
+    [_T, _CI, _D, _Q, _UA, _CAWSAI],
+    [4, 0, 0, 1, () => UsageAllocations, 0],
+];
+var UsageRecordResult = [3, n0, _URR, 0, [_URs, _MRI, _St], [() => UsageRecord, 0, 0]];
+var MarketplaceMeteringServiceException = [
+    -3,
+    _sm,
+    "MarketplaceMeteringServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(MarketplaceMeteringServiceException, MarketplaceMeteringServiceException$1);
+var TagList = [1, n0, _TL, 0, () => Tag];
+var UsageAllocations = [1, n0, _UA, 0, () => UsageAllocation];
+var UsageRecordList = [1, n0, _URL, 0, () => UsageRecord];
+var UsageRecordResultList = [1, n0, _URRL, 0, () => UsageRecordResult];
+var BatchMeterUsage = [
+    9,
+    n0,
+    _BMU,
+    0,
+    () => BatchMeterUsageRequest,
+    () => BatchMeterUsageResult,
+];
+var MeterUsage = [9, n0, _MU, 0, () => MeterUsageRequest, () => MeterUsageResult];
+var RegisterUsage = [
+    9,
+    n0,
+    _RU,
+    0,
+    () => RegisterUsageRequest,
+    () => RegisterUsageResult,
+];
+var ResolveCustomer = [
+    9,
+    n0,
+    _RC,
+    0,
+    () => ResolveCustomerRequest,
+    () => ResolveCustomerResult,
+];
 
 class BatchMeterUsageCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSMPMeteringService", "BatchMeterUsage", {})
     .n("MarketplaceMeteringClient", "BatchMeterUsageCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchMeterUsageCommand)
-    .de(de_BatchMeterUsageCommand)
+    .sc(BatchMeterUsage)
     .build() {
 }
 
@@ -777,16 +695,11 @@ class MeterUsageCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSMPMeteringService", "MeterUsage", {})
     .n("MarketplaceMeteringClient", "MeterUsageCommand")
-    .f(void 0, void 0)
-    .ser(se_MeterUsageCommand)
-    .de(de_MeterUsageCommand)
+    .sc(MeterUsage)
     .build() {
 }
 
@@ -794,16 +707,11 @@ class RegisterUsageCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSMPMeteringService", "RegisterUsage", {})
     .n("MarketplaceMeteringClient", "RegisterUsageCommand")
-    .f(void 0, void 0)
-    .ser(se_RegisterUsageCommand)
-    .de(de_RegisterUsageCommand)
+    .sc(RegisterUsage)
     .build() {
 }
 
@@ -811,16 +719,11 @@ class ResolveCustomerCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSMPMeteringService", "ResolveCustomer", {})
     .n("MarketplaceMeteringClient", "ResolveCustomerCommand")
-    .f(void 0, void 0)
-    .ser(se_ResolveCustomerCommand)
-    .de(de_ResolveCustomerCommand)
+    .sc(ResolveCustomer)
     .build() {
 }
 
@@ -843,28 +746,28 @@ Object.defineProperty(exports, "__Client", {
     get: function () { return smithyClient.Client; }
 });
 exports.BatchMeterUsageCommand = BatchMeterUsageCommand;
-exports.CustomerNotEntitledException = CustomerNotEntitledException;
-exports.DisabledApiException = DisabledApiException;
-exports.DuplicateRequestException = DuplicateRequestException;
-exports.ExpiredTokenException = ExpiredTokenException;
-exports.IdempotencyConflictException = IdempotencyConflictException;
-exports.InternalServiceErrorException = InternalServiceErrorException;
-exports.InvalidCustomerIdentifierException = InvalidCustomerIdentifierException;
-exports.InvalidEndpointRegionException = InvalidEndpointRegionException;
-exports.InvalidProductCodeException = InvalidProductCodeException;
-exports.InvalidPublicKeyVersionException = InvalidPublicKeyVersionException;
-exports.InvalidRegionException = InvalidRegionException;
-exports.InvalidTagException = InvalidTagException;
-exports.InvalidTokenException = InvalidTokenException;
-exports.InvalidUsageAllocationsException = InvalidUsageAllocationsException;
-exports.InvalidUsageDimensionException = InvalidUsageDimensionException;
+exports.CustomerNotEntitledException = CustomerNotEntitledException$1;
+exports.DisabledApiException = DisabledApiException$1;
+exports.DuplicateRequestException = DuplicateRequestException$1;
+exports.ExpiredTokenException = ExpiredTokenException$1;
+exports.IdempotencyConflictException = IdempotencyConflictException$1;
+exports.InternalServiceErrorException = InternalServiceErrorException$1;
+exports.InvalidCustomerIdentifierException = InvalidCustomerIdentifierException$1;
+exports.InvalidEndpointRegionException = InvalidEndpointRegionException$1;
+exports.InvalidProductCodeException = InvalidProductCodeException$1;
+exports.InvalidPublicKeyVersionException = InvalidPublicKeyVersionException$1;
+exports.InvalidRegionException = InvalidRegionException$1;
+exports.InvalidTagException = InvalidTagException$1;
+exports.InvalidTokenException = InvalidTokenException$1;
+exports.InvalidUsageAllocationsException = InvalidUsageAllocationsException$1;
+exports.InvalidUsageDimensionException = InvalidUsageDimensionException$1;
 exports.MarketplaceMetering = MarketplaceMetering;
 exports.MarketplaceMeteringClient = MarketplaceMeteringClient;
-exports.MarketplaceMeteringServiceException = MarketplaceMeteringServiceException;
+exports.MarketplaceMeteringServiceException = MarketplaceMeteringServiceException$1;
 exports.MeterUsageCommand = MeterUsageCommand;
-exports.PlatformNotSupportedException = PlatformNotSupportedException;
+exports.PlatformNotSupportedException = PlatformNotSupportedException$1;
 exports.RegisterUsageCommand = RegisterUsageCommand;
 exports.ResolveCustomerCommand = ResolveCustomerCommand;
-exports.ThrottlingException = ThrottlingException;
-exports.TimestampOutOfBoundsException = TimestampOutOfBoundsException;
+exports.ThrottlingException = ThrottlingException$1;
+exports.TimestampOutOfBoundsException = TimestampOutOfBoundsException$1;
 exports.UsageRecordResultStatus = UsageRecordResultStatus;