@aws-sdk/client-connectcases 3.738.0 → 3.743.0

package/dist-es/ConnectCases.js

@@ -1,12 +1,15 @@
 import { createAggregatedClient } from "@smithy/smithy-client";
+import { BatchGetCaseRuleCommand, } from "./commands/BatchGetCaseRuleCommand";
 import { BatchGetFieldCommand, } from "./commands/BatchGetFieldCommand";
 import { BatchPutFieldOptionsCommand, } from "./commands/BatchPutFieldOptionsCommand";
 import { CreateCaseCommand } from "./commands/CreateCaseCommand";
+import { CreateCaseRuleCommand, } from "./commands/CreateCaseRuleCommand";
 import { CreateDomainCommand, } from "./commands/CreateDomainCommand";
 import { CreateFieldCommand } from "./commands/CreateFieldCommand";
 import { CreateLayoutCommand, } from "./commands/CreateLayoutCommand";
 import { CreateRelatedItemCommand, } from "./commands/CreateRelatedItemCommand";
 import { CreateTemplateCommand, } from "./commands/CreateTemplateCommand";
+import { DeleteCaseRuleCommand, } from "./commands/DeleteCaseRuleCommand";
 import { DeleteDomainCommand, } from "./commands/DeleteDomainCommand";
 import { DeleteFieldCommand } from "./commands/DeleteFieldCommand";
 import { DeleteLayoutCommand, } from "./commands/DeleteLayoutCommand";
@@ -17,6 +20,7 @@ import { GetCaseEventConfigurationCommand, } from "./commands/GetCaseEventConfig
 import { GetDomainCommand } from "./commands/GetDomainCommand";
 import { GetLayoutCommand } from "./commands/GetLayoutCommand";
 import { GetTemplateCommand } from "./commands/GetTemplateCommand";
+import { ListCaseRulesCommand, } from "./commands/ListCaseRulesCommand";
 import { ListCasesForContactCommand, } from "./commands/ListCasesForContactCommand";
 import { ListDomainsCommand } from "./commands/ListDomainsCommand";
 import { ListFieldOptionsCommand, } from "./commands/ListFieldOptionsCommand";
@@ -30,19 +34,23 @@ import { SearchRelatedItemsCommand, } from "./commands/SearchRelatedItemsCommand
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateCaseCommand } from "./commands/UpdateCaseCommand";
+import { UpdateCaseRuleCommand, } from "./commands/UpdateCaseRuleCommand";
 import { UpdateFieldCommand } from "./commands/UpdateFieldCommand";
 import { UpdateLayoutCommand, } from "./commands/UpdateLayoutCommand";
 import { UpdateTemplateCommand, } from "./commands/UpdateTemplateCommand";
 import { ConnectCasesClient } from "./ConnectCasesClient";
 const commands = {
+    BatchGetCaseRuleCommand,
     BatchGetFieldCommand,
     BatchPutFieldOptionsCommand,
     CreateCaseCommand,
+    CreateCaseRuleCommand,
     CreateDomainCommand,
     CreateFieldCommand,
     CreateLayoutCommand,
     CreateRelatedItemCommand,
     CreateTemplateCommand,
+    DeleteCaseRuleCommand,
     DeleteDomainCommand,
     DeleteFieldCommand,
     DeleteLayoutCommand,
@@ -53,6 +61,7 @@ const commands = {
     GetDomainCommand,
     GetLayoutCommand,
     GetTemplateCommand,
+    ListCaseRulesCommand,
     ListCasesForContactCommand,
     ListDomainsCommand,
     ListFieldOptionsCommand,
@@ -66,6 +75,7 @@ const commands = {
     TagResourceCommand,
     UntagResourceCommand,
     UpdateCaseCommand,
+    UpdateCaseRuleCommand,
     UpdateFieldCommand,
     UpdateLayoutCommand,
     UpdateTemplateCommand,

package/dist-es/commands/BatchGetCaseRuleCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_BatchGetCaseRuleCommand, se_BatchGetCaseRuleCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class BatchGetCaseRuleCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonConnectCases", "BatchGetCaseRule", {})
+    .n("ConnectCasesClient", "BatchGetCaseRuleCommand")
+    .f(void 0, void 0)
+    .ser(se_BatchGetCaseRuleCommand)
+    .de(de_BatchGetCaseRuleCommand)
+    .build() {
+}

package/dist-es/commands/CreateCaseRuleCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_CreateCaseRuleCommand, se_CreateCaseRuleCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateCaseRuleCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonConnectCases", "CreateCaseRule", {})
+    .n("ConnectCasesClient", "CreateCaseRuleCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateCaseRuleCommand)
+    .de(de_CreateCaseRuleCommand)
+    .build() {
+}

package/dist-es/commands/DeleteCaseRuleCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_DeleteCaseRuleCommand, se_DeleteCaseRuleCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteCaseRuleCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonConnectCases", "DeleteCaseRule", {})
+    .n("ConnectCasesClient", "DeleteCaseRuleCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteCaseRuleCommand)
+    .de(de_DeleteCaseRuleCommand)
+    .build() {
+}

package/dist-es/commands/ListCaseRulesCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_ListCaseRulesCommand, se_ListCaseRulesCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListCaseRulesCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonConnectCases", "ListCaseRules", {})
+    .n("ConnectCasesClient", "ListCaseRulesCommand")
+    .f(void 0, void 0)
+    .ser(se_ListCaseRulesCommand)
+    .de(de_ListCaseRulesCommand)
+    .build() {
+}

package/dist-es/commands/UpdateCaseRuleCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_UpdateCaseRuleCommand, se_UpdateCaseRuleCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateCaseRuleCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonConnectCases", "UpdateCaseRule", {})
+    .n("ConnectCasesClient", "UpdateCaseRuleCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateCaseRuleCommand)
+    .de(de_UpdateCaseRuleCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -1,11 +1,14 @@
+export * from "./BatchGetCaseRuleCommand";
 export * from "./BatchGetFieldCommand";
 export * from "./BatchPutFieldOptionsCommand";
 export * from "./CreateCaseCommand";
+export * from "./CreateCaseRuleCommand";
 export * from "./CreateDomainCommand";
 export * from "./CreateFieldCommand";
 export * from "./CreateLayoutCommand";
 export * from "./CreateRelatedItemCommand";
 export * from "./CreateTemplateCommand";
+export * from "./DeleteCaseRuleCommand";
 export * from "./DeleteDomainCommand";
 export * from "./DeleteFieldCommand";
 export * from "./DeleteLayoutCommand";
@@ -16,6 +19,7 @@ export * from "./GetCaseEventConfigurationCommand";
 export * from "./GetDomainCommand";
 export * from "./GetLayoutCommand";
 export * from "./GetTemplateCommand";
+export * from "./ListCaseRulesCommand";
 export * from "./ListCasesForContactCommand";
 export * from "./ListDomainsCommand";
 export * from "./ListFieldOptionsCommand";
@@ -29,6 +33,7 @@ export * from "./SearchRelatedItemsCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateCaseCommand";
+export * from "./UpdateCaseRuleCommand";
 export * from "./UpdateFieldCommand";
 export * from "./UpdateLayoutCommand";
 export * from "./UpdateTemplateCommand";

package/dist-es/models/models_0.js

@@ -202,6 +202,49 @@ export const Order = {
     ASCENDING: "Asc",
     DESCENDING: "Desc",
 };
+export var OperandOne;
+(function (OperandOne) {
+    OperandOne.visit = (value, visitor) => {
+        if (value.fieldId !== undefined)
+            return visitor.fieldId(value.fieldId);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(OperandOne || (OperandOne = {}));
+export var OperandTwo;
+(function (OperandTwo) {
+    OperandTwo.visit = (value, visitor) => {
+        if (value.stringValue !== undefined)
+            return visitor.stringValue(value.stringValue);
+        if (value.booleanValue !== undefined)
+            return visitor.booleanValue(value.booleanValue);
+        if (value.doubleValue !== undefined)
+            return visitor.doubleValue(value.doubleValue);
+        if (value.emptyValue !== undefined)
+            return visitor.emptyValue(value.emptyValue);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(OperandTwo || (OperandTwo = {}));
+export var BooleanCondition;
+(function (BooleanCondition) {
+    BooleanCondition.visit = (value, visitor) => {
+        if (value.equalTo !== undefined)
+            return visitor.equalTo(value.equalTo);
+        if (value.notEqualTo !== undefined)
+            return visitor.notEqualTo(value.notEqualTo);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(BooleanCondition || (BooleanCondition = {}));
+export var CaseRuleDetails;
+(function (CaseRuleDetails) {
+    CaseRuleDetails.visit = (value, visitor) => {
+        if (value.required !== undefined)
+            return visitor.required(value.required);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(CaseRuleDetails || (CaseRuleDetails = {}));
+export const RuleType = {
+    REQUIRED: "Required",
+};
 export const DomainStatus = {
     ACTIVE: "Active",
     CREATION_FAILED: "CreationFailed",

package/dist-es/pagination/ListCaseRulesPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListCaseRulesCommand, } from "../commands/ListCaseRulesCommand";
+import { ConnectCasesClient } from "../ConnectCasesClient";
+export const paginateListCaseRules = createPaginator(ConnectCasesClient, ListCaseRulesCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/index.js

@@ -1,6 +1,7 @@
 export * from "./GetCaseAuditEventsPaginator";
 export * from "./GetCasePaginator";
 export * from "./Interfaces";
+export * from "./ListCaseRulesPaginator";
 export * from "./ListCasesForContactPaginator";
 export * from "./ListDomainsPaginator";
 export * from "./ListFieldOptionsPaginator";

package/dist-es/protocols/Aws_restJson1.js

@@ -3,7 +3,21 @@ import { requestBuilder as rb } from "@smithy/core";
 import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { ConnectCasesServiceException as __BaseException } from "../models/ConnectCasesServiceException";
-import { AccessDeniedException, CaseFilter, ConflictException, FieldFilter, FieldValueUnion, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, BooleanCondition, CaseFilter, CaseRuleDetails, ConflictException, FieldFilter, FieldValueUnion, InternalServerException, OperandTwo, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+export const se_BatchGetCaseRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/domains/{domainId}/rules-batch");
+    b.p("domainId", () => input.domainId, "{domainId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        caseRules: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_BatchGetFieldCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -50,6 +64,22 @@ export const se_CreateCaseCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_CreateCaseRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/domains/{domainId}/case-rules");
+    b.p("domainId", () => input.domainId, "{domainId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [],
+        name: [],
+        rule: (_) => se_CaseRuleDetails(_, context),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_CreateDomainCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -124,11 +154,22 @@ export const se_CreateTemplateCommand = async (input, context) => {
         layoutConfiguration: (_) => _json(_),
         name: [],
         requiredFields: (_) => _json(_),
+        rules: (_) => _json(_),
         status: [],
     }));
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_DeleteCaseRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/domains/{domainId}/case-rules/{caseRuleId}");
+    b.p("domainId", () => input.domainId, "{domainId}", false);
+    b.p("caseRuleId", () => input.caseRuleId, "{caseRuleId}", false);
+    let body;
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
+};
 export const se_DeleteDomainCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -238,6 +279,19 @@ export const se_GetTemplateCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_ListCaseRulesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/domains/{domainId}/rules-list");
+    b.p("domainId", () => input.domainId, "{domainId}", false);
+    const query = map({
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_nT]: [, input[_nT]],
+    });
+    let body;
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_ListCasesForContactCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -422,6 +476,23 @@ export const se_UpdateCaseCommand = async (input, context) => {
     b.m("PUT").h(headers).b(body);
     return b.build();
 };
+export const se_UpdateCaseRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/domains/{domainId}/case-rules/{caseRuleId}");
+    b.p("domainId", () => input.domainId, "{domainId}", false);
+    b.p("caseRuleId", () => input.caseRuleId, "{caseRuleId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [],
+        name: [],
+        rule: (_) => se_CaseRuleDetails(_, context),
+    }));
+    b.m("PUT").h(headers).b(body);
+    return b.build();
+};
 export const se_UpdateFieldCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -468,11 +539,27 @@ export const se_UpdateTemplateCommand = async (input, context) => {
         layoutConfiguration: (_) => _json(_),
         name: [],
         requiredFields: (_) => _json(_),
+        rules: (_) => _json(_),
         status: [],
     }));
     b.m("PUT").h(headers).b(body);
     return b.build();
 };
+export const de_BatchGetCaseRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        caseRules: (_) => de_BatchGetCaseRuleList(_, context),
+        errors: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_BatchGetFieldCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -517,6 +604,21 @@ export const de_CreateCaseCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_CreateCaseRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        caseRuleArn: __expectString,
+        caseRuleId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_CreateDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -593,6 +695,16 @@ export const de_CreateTemplateCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_DeleteCaseRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_DeleteDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -735,6 +847,7 @@ export const de_GetTemplateCommand = async (output, context) => {
         layoutConfiguration: _json,
         name: __expectString,
         requiredFields: _json,
+        rules: _json,
         status: __expectString,
         tags: (_) => de_Tags(_, context),
         templateArn: __expectString,
@@ -743,6 +856,21 @@ export const de_GetTemplateCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_ListCaseRulesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        caseRules: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_ListCasesForContactCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -917,6 +1045,16 @@ export const de_UpdateCaseCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
+export const de_UpdateCaseRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_UpdateFieldCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1080,6 +1218,27 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const se_BooleanCondition = (input, context) => {
+    return BooleanCondition.visit(input, {
+        equalTo: (value) => ({ equalTo: se_BooleanOperands(value, context) }),
+        notEqualTo: (value) => ({ notEqualTo: se_BooleanOperands(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_BooleanConditionList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_BooleanCondition(entry, context);
+    });
+};
+const se_BooleanOperands = (input, context) => {
+    return take(input, {
+        operandOne: _json,
+        operandTwo: (_) => se_OperandTwo(_, context),
+        result: [],
+    });
+};
 const se_CaseFilter = (input, context) => {
     return CaseFilter.visit(input, {
         andAll: (value) => ({ andAll: se_CaseFilterList(value, context) }),
@@ -1096,6 +1255,12 @@ const se_CaseFilterList = (input, context) => {
         return se_CaseFilter(entry, context);
     });
 };
+const se_CaseRuleDetails = (input, context) => {
+    return CaseRuleDetails.visit(input, {
+        required: (value) => ({ required: se_RequiredCaseRule(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
 const se_FieldFilter = (input, context) => {
     return FieldFilter.visit(input, {
         contains: (value) => ({ contains: se_FieldValue(value, context) }),
@@ -1130,6 +1295,21 @@ const se_FieldValueUnion = (input, context) => {
         _: (name, value) => ({ name: value }),
     });
 };
+const se_OperandTwo = (input, context) => {
+    return OperandTwo.visit(input, {
+        booleanValue: (value) => ({ booleanValue: value }),
+        doubleValue: (value) => ({ doubleValue: __serializeFloat(value) }),
+        emptyValue: (value) => ({ emptyValue: _json(value) }),
+        stringValue: (value) => ({ stringValue: value }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_RequiredCaseRule = (input, context) => {
+    return take(input, {
+        conditions: (_) => se_BooleanConditionList(_, context),
+        defaultValue: [],
+    });
+};
 const se_Tags = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
@@ -1195,6 +1375,14 @@ const de_AuditEventsList = (output, context) => {
     });
     return retVal;
 };
+const de_BatchGetCaseRuleList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_GetCaseRuleResponse(entry, context);
+    });
+    return retVal;
+};
 const de_BatchGetFieldList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -1203,6 +1391,42 @@ const de_BatchGetFieldList = (output, context) => {
     });
     return retVal;
 };
+const de_BooleanCondition = (output, context) => {
+    if (output.equalTo != null) {
+        return {
+            equalTo: de_BooleanOperands(output.equalTo, context),
+        };
+    }
+    if (output.notEqualTo != null) {
+        return {
+            notEqualTo: de_BooleanOperands(output.notEqualTo, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_BooleanConditionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_BooleanCondition(__expectUnion(entry), context);
+    });
+    return retVal;
+};
+const de_BooleanOperands = (output, context) => {
+    return take(output, {
+        operandOne: (_) => _json(__expectUnion(_)),
+        operandTwo: (_) => de_OperandTwo(__expectUnion(_), context),
+        result: __expectBoolean,
+    });
+};
+const de_CaseRuleDetails = (output, context) => {
+    if (output.required != null) {
+        return {
+            required: de_RequiredCaseRule(output.required, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
 const de_ContactContent = (output, context) => {
     return take(output, {
         channel: __expectString,
@@ -1244,6 +1468,19 @@ const de_FieldValueUnion = (output, context) => {
     }
     return { $unknown: Object.entries(output)[0] };
 };
+const de_GetCaseRuleResponse = (output, context) => {
+    return take(output, {
+        caseRuleArn: __expectString,
+        caseRuleId: __expectString,
+        createdTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        deleted: __expectBoolean,
+        description: __expectString,
+        lastModifiedTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        name: __expectString,
+        rule: (_) => de_CaseRuleDetails(__expectUnion(_), context),
+        tags: (_) => de_Tags(_, context),
+    });
+};
 const de_GetFieldResponse = (output, context) => {
     return take(output, {
         createdTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
@@ -1258,6 +1495,23 @@ const de_GetFieldResponse = (output, context) => {
         type: __expectString,
     });
 };
+const de_OperandTwo = (output, context) => {
+    if (__expectBoolean(output.booleanValue) !== undefined) {
+        return { booleanValue: __expectBoolean(output.booleanValue) };
+    }
+    if (__limitedParseDouble(output.doubleValue) !== undefined) {
+        return { doubleValue: __limitedParseDouble(output.doubleValue) };
+    }
+    if (output.emptyValue != null) {
+        return {
+            emptyValue: _json(output.emptyValue),
+        };
+    }
+    if (__expectString(output.stringValue) !== undefined) {
+        return { stringValue: __expectString(output.stringValue) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
 const de_RelatedItemContent = (output, context) => {
     if (output.comment != null) {
         return {
@@ -1276,6 +1530,12 @@ const de_RelatedItemContent = (output, context) => {
     }
     return { $unknown: Object.entries(output)[0] };
 };
+const de_RequiredCaseRule = (output, context) => {
+    return take(output, {
+        conditions: (_) => de_BooleanConditionList(_, context),
+        defaultValue: __expectBoolean,
+    });
+};
 const de_SearchCasesResponseItem = (output, context) => {
     return take(output, {
         caseId: __expectString,