@aws-sdk/client-rbin 3.928.0 → 3.929.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,8 +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');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class RbinClient 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));
@@ -110,12 +110,12 @@ class RbinClient extends smithyClient.Client {
     }
 }
 
-class RbinServiceException extends smithyClient.ServiceException {
+let RbinServiceException$1 = class RbinServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, RbinServiceException.prototype);
     }
-}
+};
 
 const UnlockDelayUnit = {
     DAYS: "DAYS",
@@ -136,7 +136,7 @@ const RuleStatus = {
     AVAILABLE: "available",
     PENDING: "pending",
 };
-class InternalServerException extends RbinServiceException {
+let InternalServerException$1 = class InternalServerException extends RbinServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     Message;
@@ -149,11 +149,11 @@ class InternalServerException extends RbinServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const ServiceQuotaExceededExceptionReason = {
     SERVICE_QUOTA_EXCEEDED: "SERVICE_QUOTA_EXCEEDED",
 };
-class ServiceQuotaExceededException extends RbinServiceException {
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends RbinServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     Message;
@@ -168,12 +168,12 @@ class ServiceQuotaExceededException extends RbinServiceException {
         this.Message = opts.Message;
         this.Reason = opts.Reason;
     }
-}
+};
 const ValidationExceptionReason = {
     INVALID_PAGE_TOKEN: "INVALID_PAGE_TOKEN",
     INVALID_PARAMETER_VALUE: "INVALID_PARAMETER_VALUE",
 };
-class ValidationException extends RbinServiceException {
+let ValidationException$1 = class ValidationException extends RbinServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -188,11 +188,11 @@ class ValidationException extends RbinServiceException {
         this.Message = opts.Message;
         this.Reason = opts.Reason;
     }
-}
+};
 const ConflictExceptionReason = {
     INVALID_RULE_STATE: "INVALID_RULE_STATE",
 };
-class ConflictException extends RbinServiceException {
+let ConflictException$1 = class ConflictException extends RbinServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     Message;
@@ -207,11 +207,11 @@ class ConflictException extends RbinServiceException {
         this.Message = opts.Message;
         this.Reason = opts.Reason;
     }
-}
+};
 const ResourceNotFoundExceptionReason = {
     RULE_NOT_FOUND: "RULE_NOT_FOUND",
 };
-class ResourceNotFoundException extends RbinServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends RbinServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -226,440 +226,377 @@ class ResourceNotFoundException extends RbinServiceException {
         this.Message = opts.Message;
         this.Reason = opts.Reason;
     }
-}
-
-const se_CreateRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/rules");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Description: [],
-        ExcludeResourceTags: (_) => smithyClient._json(_),
-        LockConfiguration: (_) => smithyClient._json(_),
-        ResourceTags: (_) => smithyClient._json(_),
-        ResourceType: [],
-        RetentionPeriod: (_) => smithyClient._json(_),
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/rules/{Identifier}");
-    b.p("Identifier", () => input.Identifier, "{Identifier}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_GetRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/rules/{Identifier}");
-    b.p("Identifier", () => input.Identifier, "{Identifier}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListRulesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-rules");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ExcludeResourceTags: (_) => smithyClient._json(_),
-        LockState: [],
-        MaxResults: [],
-        NextToken: [],
-        ResourceTags: (_) => smithyClient._json(_),
-        ResourceType: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_LockRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/rules/{Identifier}/lock");
-    b.p("Identifier", () => input.Identifier, "{Identifier}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        LockConfiguration: (_) => smithyClient._json(_),
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UnlockRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/rules/{Identifier}/unlock");
-    b.p("Identifier", () => input.Identifier, "{Identifier}", false);
-    let body;
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateRuleCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/rules/{Identifier}");
-    b.p("Identifier", () => input.Identifier, "{Identifier}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Description: [],
-        ExcludeResourceTags: (_) => smithyClient._json(_),
-        ResourceTags: (_) => smithyClient._json(_),
-        ResourceType: [],
-        RetentionPeriod: (_) => smithyClient._json(_),
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const de_CreateRuleCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Description: smithyClient.expectString,
-        ExcludeResourceTags: smithyClient._json,
-        Identifier: smithyClient.expectString,
-        LockConfiguration: smithyClient._json,
-        LockState: smithyClient.expectString,
-        ResourceTags: smithyClient._json,
-        ResourceType: smithyClient.expectString,
-        RetentionPeriod: smithyClient._json,
-        RuleArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteRuleCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_GetRuleCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Description: smithyClient.expectString,
-        ExcludeResourceTags: smithyClient._json,
-        Identifier: smithyClient.expectString,
-        LockConfiguration: smithyClient._json,
-        LockEndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LockState: smithyClient.expectString,
-        ResourceTags: smithyClient._json,
-        ResourceType: smithyClient.expectString,
-        RetentionPeriod: smithyClient._json,
-        RuleArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListRulesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        Rules: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_LockRuleCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Description: smithyClient.expectString,
-        ExcludeResourceTags: smithyClient._json,
-        Identifier: smithyClient.expectString,
-        LockConfiguration: smithyClient._json,
-        LockState: smithyClient.expectString,
-        ResourceTags: smithyClient._json,
-        ResourceType: smithyClient.expectString,
-        RetentionPeriod: smithyClient._json,
-        RuleArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UnlockRuleCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Description: smithyClient.expectString,
-        ExcludeResourceTags: smithyClient._json,
-        Identifier: smithyClient.expectString,
-        LockConfiguration: smithyClient._json,
-        LockEndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LockState: smithyClient.expectString,
-        ResourceTags: smithyClient._json,
-        ResourceType: smithyClient.expectString,
-        RetentionPeriod: smithyClient._json,
-        RuleArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateRuleCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Description: smithyClient.expectString,
-        ExcludeResourceTags: smithyClient._json,
-        Identifier: smithyClient.expectString,
-        LockEndTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LockState: smithyClient.expectString,
-        ResourceTags: smithyClient._json,
-        ResourceType: smithyClient.expectString,
-        RetentionPeriod: smithyClient._json,
-        RuleArn: smithyClient.expectString,
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-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 "InternalServerException":
-        case "com.amazonaws.rbin#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.rbin#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.rbin#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.rbin#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.rbin#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
 };
-const throwDefaultError = smithyClient.withBaseException(RbinServiceException);
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        Reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        Reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        Reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        Reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-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 _CE = "ConflictException";
+const _CR = "CreateRule";
+const _CRR = "CreateRuleRequest";
+const _CRRr = "CreateRuleResponse";
+const _D = "Description";
+const _DR = "DeleteRule";
+const _DRR = "DeleteRuleRequest";
+const _DRRe = "DeleteRuleResponse";
+const _ERT = "ExcludeResourceTags";
+const _GR = "GetRule";
+const _GRR = "GetRuleRequest";
+const _GRRe = "GetRuleResponse";
+const _I = "Identifier";
+const _ISE = "InternalServerException";
+const _K = "Key";
+const _LC = "LockConfiguration";
+const _LET = "LockEndTime";
+const _LR = "ListRules";
+const _LRR = "ListRulesRequest";
+const _LRRi = "ListRulesResponse";
+const _LRRo = "LockRuleRequest";
+const _LRRoc = "LockRuleResponse";
+const _LRo = "LockRule";
+const _LS = "LockState";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _M = "Message";
+const _MR = "MaxResults";
+const _NT = "NextToken";
+const _R = "Reason";
+const _RA = "RuleArn";
+const _RAe = "ResourceArn";
+const _RNFE = "ResourceNotFoundException";
+const _RP = "RetentionPeriod";
+const _RPU = "RetentionPeriodUnit";
+const _RPV = "RetentionPeriodValue";
+const _RS = "RuleSummary";
+const _RSL = "RuleSummaryList";
+const _RT = "ResourceType";
+const _RTK = "ResourceTagKey";
+const _RTV = "ResourceTagValue";
+const _RTe = "ResourceTags";
+const _RTes = "ResourceTag";
+const _Ru = "Rules";
+const _S = "Status";
+const _SQEE = "ServiceQuotaExceededException";
+const _T = "Tags";
 const _TK = "TagKeys";
+const _TL = "TagList";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _Ta = "Tag";
+const _UD = "UnlockDelay";
+const _UDU = "UnlockDelayUnit";
+const _UDV = "UnlockDelayValue";
+const _UR = "UnlockRule";
+const _URR = "UnlockRuleRequest";
+const _URRn = "UnlockRuleResponse";
+const _URRnt = "UntagResourceRequest";
+const _URRnta = "UntagResourceResponse";
+const _URRp = "UpdateRuleRequest";
+const _URRpd = "UpdateRuleResponse";
+const _URn = "UntagResource";
+const _URp = "UpdateRule";
+const _V = "Value";
+const _VE = "ValidationException";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.rbin";
 const _tK = "tagKeys";
+const n0 = "com.amazonaws.rbin";
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M, _R],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateRuleRequest = [
+    3,
+    n0,
+    _CRR,
+    0,
+    [_RP, _D, _T, _RT, _RTe, _LC, _ERT],
+    [() => RetentionPeriod, 0, () => TagList, 0, () => ResourceTags, () => LockConfiguration, () => ExcludeResourceTags],
+];
+var CreateRuleResponse = [
+    3,
+    n0,
+    _CRRr,
+    0,
+    [_I, _RP, _D, _T, _RT, _RTe, _S, _LC, _LS, _RA, _ERT],
+    [
+        0,
+        () => RetentionPeriod,
+        0,
+        () => TagList,
+        0,
+        () => ResourceTags,
+        0,
+        () => LockConfiguration,
+        0,
+        0,
+        () => ExcludeResourceTags,
+    ],
+];
+var DeleteRuleRequest = [3, n0, _DRR, 0, [_I], [[0, 1]]];
+var DeleteRuleResponse = [3, n0, _DRRe, 0, [], []];
+var GetRuleRequest = [3, n0, _GRR, 0, [_I], [[0, 1]]];
+var GetRuleResponse = [
+    3,
+    n0,
+    _GRRe,
+    0,
+    [_I, _D, _RT, _RP, _RTe, _S, _LC, _LS, _LET, _RA, _ERT],
+    [0, 0, 0, () => RetentionPeriod, () => ResourceTags, 0, () => LockConfiguration, 0, 4, 0, () => ExcludeResourceTags],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListRulesRequest = [
+    3,
+    n0,
+    _LRR,
+    0,
+    [_MR, _NT, _RT, _RTe, _LS, _ERT],
+    [1, 0, 0, () => ResourceTags, 0, () => ExcludeResourceTags],
+];
+var ListRulesResponse = [3, n0, _LRRi, 0, [_Ru, _NT], [() => RuleSummaryList, 0]];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_RAe], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_T], [() => TagList]];
+var LockConfiguration = [3, n0, _LC, 0, [_UD], [() => UnlockDelay]];
+var LockRuleRequest = [3, n0, _LRRo, 0, [_I, _LC], [[0, 1], () => LockConfiguration]];
+var LockRuleResponse = [
+    3,
+    n0,
+    _LRRoc,
+    0,
+    [_I, _D, _RT, _RP, _RTe, _S, _LC, _LS, _RA, _ERT],
+    [0, 0, 0, () => RetentionPeriod, () => ResourceTags, 0, () => LockConfiguration, 0, 0, () => ExcludeResourceTags],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M, _R],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ResourceTag = [3, n0, _RTes, 0, [_RTK, _RTV], [0, 0]];
+var RetentionPeriod = [3, n0, _RP, 0, [_RPV, _RPU], [1, 0]];
+var RuleSummary = [
+    3,
+    n0,
+    _RS,
+    0,
+    [_I, _D, _RP, _LS, _RA],
+    [0, 0, () => RetentionPeriod, 0, 0],
+];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_M, _R],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var Tag = [3, n0, _Ta, 0, [_K, _V], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_RAe, _T], [[0, 1], () => TagList]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var UnlockDelay = [3, n0, _UD, 0, [_UDV, _UDU], [1, 0]];
+var UnlockRuleRequest = [3, n0, _URR, 0, [_I], [[0, 1]]];
+var UnlockRuleResponse = [
+    3,
+    n0,
+    _URRn,
+    0,
+    [_I, _D, _RT, _RP, _RTe, _S, _LC, _LS, _LET, _RA, _ERT],
+    [0, 0, 0, () => RetentionPeriod, () => ResourceTags, 0, () => LockConfiguration, 0, 4, 0, () => ExcludeResourceTags],
+];
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URRnt,
+    0,
+    [_RAe, _TK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRnta, 0, [], []];
+var UpdateRuleRequest = [
+    3,
+    n0,
+    _URRp,
+    0,
+    [_I, _RP, _D, _RT, _RTe, _ERT],
+    [[0, 1], () => RetentionPeriod, 0, 0, () => ResourceTags, () => ExcludeResourceTags],
+];
+var UpdateRuleResponse = [
+    3,
+    n0,
+    _URRpd,
+    0,
+    [_I, _RP, _D, _RT, _RTe, _S, _LS, _LET, _RA, _ERT],
+    [0, () => RetentionPeriod, 0, 0, () => ResourceTags, 0, 0, 4, 0, () => ExcludeResourceTags],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M, _R],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var RbinServiceException = [-3, _sm, "RbinServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(RbinServiceException, RbinServiceException$1);
+var ExcludeResourceTags = [1, n0, _ERT, 0, () => ResourceTag];
+var ResourceTags = [1, n0, _RTe, 0, () => ResourceTag];
+var RuleSummaryList = [1, n0, _RSL, 0, () => RuleSummary];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var CreateRule = [
+    9,
+    n0,
+    _CR,
+    {
+        [_h]: ["POST", "/rules", 201],
+    },
+    () => CreateRuleRequest,
+    () => CreateRuleResponse,
+];
+var DeleteRule = [
+    9,
+    n0,
+    _DR,
+    {
+        [_h]: ["DELETE", "/rules/{Identifier}", 204],
+    },
+    () => DeleteRuleRequest,
+    () => DeleteRuleResponse,
+];
+var GetRule = [
+    9,
+    n0,
+    _GR,
+    {
+        [_h]: ["GET", "/rules/{Identifier}", 200],
+    },
+    () => GetRuleRequest,
+    () => GetRuleResponse,
+];
+var ListRules = [
+    9,
+    n0,
+    _LR,
+    {
+        [_h]: ["POST", "/list-rules", 200],
+    },
+    () => ListRulesRequest,
+    () => ListRulesResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{ResourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var LockRule = [
+    9,
+    n0,
+    _LRo,
+    {
+        [_h]: ["PATCH", "/rules/{Identifier}/lock", 200],
+    },
+    () => LockRuleRequest,
+    () => LockRuleResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tags/{ResourceArn}", 201],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UnlockRule = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["PATCH", "/rules/{Identifier}/unlock", 200],
+    },
+    () => UnlockRuleRequest,
+    () => UnlockRuleResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _URn,
+    {
+        [_h]: ["DELETE", "/tags/{ResourceArn}", 204],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateRule = [
+    9,
+    n0,
+    _URp,
+    {
+        [_h]: ["PATCH", "/rules/{Identifier}", 200],
+    },
+    () => UpdateRuleRequest,
+    () => UpdateRuleResponse,
+];
 
 class CreateRuleCommand 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("AmazonRecycleBin", "CreateRule", {})
     .n("RbinClient", "CreateRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateRuleCommand)
-    .de(de_CreateRuleCommand)
+    .sc(CreateRule)
     .build() {
 }
 
@@ -667,16 +604,11 @@ class DeleteRuleCommand 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("AmazonRecycleBin", "DeleteRule", {})
     .n("RbinClient", "DeleteRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteRuleCommand)
-    .de(de_DeleteRuleCommand)
+    .sc(DeleteRule)
     .build() {
 }
 
@@ -684,16 +616,11 @@ class GetRuleCommand 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("AmazonRecycleBin", "GetRule", {})
     .n("RbinClient", "GetRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_GetRuleCommand)
-    .de(de_GetRuleCommand)
+    .sc(GetRule)
     .build() {
 }
 
@@ -701,16 +628,11 @@ class ListRulesCommand 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("AmazonRecycleBin", "ListRules", {})
     .n("RbinClient", "ListRulesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListRulesCommand)
-    .de(de_ListRulesCommand)
+    .sc(ListRules)
     .build() {
 }
 
@@ -718,16 +640,11 @@ class ListTagsForResourceCommand 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("AmazonRecycleBin", "ListTagsForResource", {})
     .n("RbinClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -735,16 +652,11 @@ class LockRuleCommand 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("AmazonRecycleBin", "LockRule", {})
     .n("RbinClient", "LockRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_LockRuleCommand)
-    .de(de_LockRuleCommand)
+    .sc(LockRule)
     .build() {
 }
 
@@ -752,16 +664,11 @@ class TagResourceCommand 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("AmazonRecycleBin", "TagResource", {})
     .n("RbinClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -769,16 +676,11 @@ class UnlockRuleCommand 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("AmazonRecycleBin", "UnlockRule", {})
     .n("RbinClient", "UnlockRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_UnlockRuleCommand)
-    .de(de_UnlockRuleCommand)
+    .sc(UnlockRule)
     .build() {
 }
 
@@ -786,16 +688,11 @@ class UntagResourceCommand 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("AmazonRecycleBin", "UntagResource", {})
     .n("RbinClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -803,16 +700,11 @@ class UpdateRuleCommand 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("AmazonRecycleBin", "UpdateRule", {})
     .n("RbinClient", "UpdateRuleCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateRuleCommand)
-    .de(de_UpdateRuleCommand)
+    .sc(UpdateRule)
     .build() {
 }
 
@@ -842,31 +734,31 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.ConflictExceptionReason = ConflictExceptionReason;
 exports.CreateRuleCommand = CreateRuleCommand;
 exports.DeleteRuleCommand = DeleteRuleCommand;
 exports.GetRuleCommand = GetRuleCommand;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListRulesCommand = ListRulesCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.LockRuleCommand = LockRuleCommand;
 exports.LockState = LockState;
 exports.Rbin = Rbin;
 exports.RbinClient = RbinClient;
-exports.RbinServiceException = RbinServiceException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.RbinServiceException = RbinServiceException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ResourceNotFoundExceptionReason = ResourceNotFoundExceptionReason;
 exports.ResourceType = ResourceType;
 exports.RetentionPeriodUnit = RetentionPeriodUnit;
 exports.RuleStatus = RuleStatus;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.ServiceQuotaExceededExceptionReason = ServiceQuotaExceededExceptionReason;
 exports.TagResourceCommand = TagResourceCommand;
 exports.UnlockDelayUnit = UnlockDelayUnit;
 exports.UnlockRuleCommand = UnlockRuleCommand;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateRuleCommand = UpdateRuleCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.ValidationExceptionReason = ValidationExceptionReason;
 exports.paginateListRules = paginateListRules;