@aws-sdk/client-cleanrooms 3.618.0 → 3.619.0

package/dist-es/CleanRooms.js

@@ -7,6 +7,7 @@ import { CreateAnalysisTemplateCommand, } from "./commands/CreateAnalysisTemplat
 import { CreateCollaborationCommand, } from "./commands/CreateCollaborationCommand";
 import { CreateConfiguredAudienceModelAssociationCommand, } from "./commands/CreateConfiguredAudienceModelAssociationCommand";
 import { CreateConfiguredTableAnalysisRuleCommand, } from "./commands/CreateConfiguredTableAnalysisRuleCommand";
+import { CreateConfiguredTableAssociationAnalysisRuleCommand, } from "./commands/CreateConfiguredTableAssociationAnalysisRuleCommand";
 import { CreateConfiguredTableAssociationCommand, } from "./commands/CreateConfiguredTableAssociationCommand";
 import { CreateConfiguredTableCommand, } from "./commands/CreateConfiguredTableCommand";
 import { CreateIdMappingTableCommand, } from "./commands/CreateIdMappingTableCommand";
@@ -17,6 +18,7 @@ import { DeleteAnalysisTemplateCommand, } from "./commands/DeleteAnalysisTemplat
 import { DeleteCollaborationCommand, } from "./commands/DeleteCollaborationCommand";
 import { DeleteConfiguredAudienceModelAssociationCommand, } from "./commands/DeleteConfiguredAudienceModelAssociationCommand";
 import { DeleteConfiguredTableAnalysisRuleCommand, } from "./commands/DeleteConfiguredTableAnalysisRuleCommand";
+import { DeleteConfiguredTableAssociationAnalysisRuleCommand, } from "./commands/DeleteConfiguredTableAssociationAnalysisRuleCommand";
 import { DeleteConfiguredTableAssociationCommand, } from "./commands/DeleteConfiguredTableAssociationCommand";
 import { DeleteConfiguredTableCommand, } from "./commands/DeleteConfiguredTableCommand";
 import { DeleteIdMappingTableCommand, } from "./commands/DeleteIdMappingTableCommand";
@@ -32,6 +34,7 @@ import { GetCollaborationIdNamespaceAssociationCommand, } from "./commands/GetCo
 import { GetCollaborationPrivacyBudgetTemplateCommand, } from "./commands/GetCollaborationPrivacyBudgetTemplateCommand";
 import { GetConfiguredAudienceModelAssociationCommand, } from "./commands/GetConfiguredAudienceModelAssociationCommand";
 import { GetConfiguredTableAnalysisRuleCommand, } from "./commands/GetConfiguredTableAnalysisRuleCommand";
+import { GetConfiguredTableAssociationAnalysisRuleCommand, } from "./commands/GetConfiguredTableAssociationAnalysisRuleCommand";
 import { GetConfiguredTableAssociationCommand, } from "./commands/GetConfiguredTableAssociationCommand";
 import { GetConfiguredTableCommand, } from "./commands/GetConfiguredTableCommand";
 import { GetIdMappingTableCommand, } from "./commands/GetIdMappingTableCommand";
@@ -69,6 +72,7 @@ import { UpdateAnalysisTemplateCommand, } from "./commands/UpdateAnalysisTemplat
 import { UpdateCollaborationCommand, } from "./commands/UpdateCollaborationCommand";
 import { UpdateConfiguredAudienceModelAssociationCommand, } from "./commands/UpdateConfiguredAudienceModelAssociationCommand";
 import { UpdateConfiguredTableAnalysisRuleCommand, } from "./commands/UpdateConfiguredTableAnalysisRuleCommand";
+import { UpdateConfiguredTableAssociationAnalysisRuleCommand, } from "./commands/UpdateConfiguredTableAssociationAnalysisRuleCommand";
 import { UpdateConfiguredTableAssociationCommand, } from "./commands/UpdateConfiguredTableAssociationCommand";
 import { UpdateConfiguredTableCommand, } from "./commands/UpdateConfiguredTableCommand";
 import { UpdateIdMappingTableCommand, } from "./commands/UpdateIdMappingTableCommand";
@@ -86,6 +90,7 @@ const commands = {
     CreateConfiguredTableCommand,
     CreateConfiguredTableAnalysisRuleCommand,
     CreateConfiguredTableAssociationCommand,
+    CreateConfiguredTableAssociationAnalysisRuleCommand,
     CreateIdMappingTableCommand,
     CreateIdNamespaceAssociationCommand,
     CreateMembershipCommand,
@@ -96,6 +101,7 @@ const commands = {
     DeleteConfiguredTableCommand,
     DeleteConfiguredTableAnalysisRuleCommand,
     DeleteConfiguredTableAssociationCommand,
+    DeleteConfiguredTableAssociationAnalysisRuleCommand,
     DeleteIdMappingTableCommand,
     DeleteIdNamespaceAssociationCommand,
     DeleteMemberCommand,
@@ -111,6 +117,7 @@ const commands = {
     GetConfiguredTableCommand,
     GetConfiguredTableAnalysisRuleCommand,
     GetConfiguredTableAssociationCommand,
+    GetConfiguredTableAssociationAnalysisRuleCommand,
     GetIdMappingTableCommand,
     GetIdNamespaceAssociationCommand,
     GetMembershipCommand,
@@ -148,6 +155,7 @@ const commands = {
     UpdateConfiguredTableCommand,
     UpdateConfiguredTableAnalysisRuleCommand,
     UpdateConfiguredTableAssociationCommand,
+    UpdateConfiguredTableAssociationAnalysisRuleCommand,
     UpdateIdMappingTableCommand,
     UpdateIdNamespaceAssociationCommand,
     UpdateMembershipCommand,

package/dist-es/commands/CreateConfiguredTableAssociationAnalysisRuleCommand.js

@@ -0,0 +1,24 @@
+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_CreateConfiguredTableAssociationAnalysisRuleCommand, se_CreateConfiguredTableAssociationAnalysisRuleCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateConfiguredTableAssociationAnalysisRuleCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AWSBastionControlPlaneServiceLambda", "CreateConfiguredTableAssociationAnalysisRule", {})
+    .n("CleanRoomsClient", "CreateConfiguredTableAssociationAnalysisRuleCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateConfiguredTableAssociationAnalysisRuleCommand)
+    .de(de_CreateConfiguredTableAssociationAnalysisRuleCommand)
+    .build() {
+}

package/dist-es/commands/DeleteConfiguredTableAssociationAnalysisRuleCommand.js

@@ -0,0 +1,24 @@
+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_DeleteConfiguredTableAssociationAnalysisRuleCommand, se_DeleteConfiguredTableAssociationAnalysisRuleCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteConfiguredTableAssociationAnalysisRuleCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AWSBastionControlPlaneServiceLambda", "DeleteConfiguredTableAssociationAnalysisRule", {})
+    .n("CleanRoomsClient", "DeleteConfiguredTableAssociationAnalysisRuleCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteConfiguredTableAssociationAnalysisRuleCommand)
+    .de(de_DeleteConfiguredTableAssociationAnalysisRuleCommand)
+    .build() {
+}

package/dist-es/commands/GetConfiguredTableAssociationAnalysisRuleCommand.js

@@ -0,0 +1,24 @@
+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_GetConfiguredTableAssociationAnalysisRuleCommand, se_GetConfiguredTableAssociationAnalysisRuleCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetConfiguredTableAssociationAnalysisRuleCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AWSBastionControlPlaneServiceLambda", "GetConfiguredTableAssociationAnalysisRule", {})
+    .n("CleanRoomsClient", "GetConfiguredTableAssociationAnalysisRuleCommand")
+    .f(void 0, void 0)
+    .ser(se_GetConfiguredTableAssociationAnalysisRuleCommand)
+    .de(de_GetConfiguredTableAssociationAnalysisRuleCommand)
+    .build() {
+}

package/dist-es/commands/UpdateConfiguredTableAssociationAnalysisRuleCommand.js

@@ -0,0 +1,24 @@
+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_UpdateConfiguredTableAssociationAnalysisRuleCommand, se_UpdateConfiguredTableAssociationAnalysisRuleCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateConfiguredTableAssociationAnalysisRuleCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AWSBastionControlPlaneServiceLambda", "UpdateConfiguredTableAssociationAnalysisRule", {})
+    .n("CleanRoomsClient", "UpdateConfiguredTableAssociationAnalysisRuleCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateConfiguredTableAssociationAnalysisRuleCommand)
+    .de(de_UpdateConfiguredTableAssociationAnalysisRuleCommand)
+    .build() {
+}

package/dist-es/commands/UpdateProtectedQueryCommand.js

@@ -2,7 +2,7 @@ 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 { UpdateProtectedQueryOutputFilterSensitiveLog, } from "../models/models_0";
+import { UpdateProtectedQueryOutputFilterSensitiveLog } from "../models/models_1";
 import { de_UpdateProtectedQueryCommand, se_UpdateProtectedQueryCommand } from "../protocols/Aws_restJson1";
 export { $Command };
 export class UpdateProtectedQueryCommand extends $Command

package/dist-es/commands/index.js

@@ -5,6 +5,7 @@ export * from "./CreateAnalysisTemplateCommand";
 export * from "./CreateCollaborationCommand";
 export * from "./CreateConfiguredAudienceModelAssociationCommand";
 export * from "./CreateConfiguredTableAnalysisRuleCommand";
+export * from "./CreateConfiguredTableAssociationAnalysisRuleCommand";
 export * from "./CreateConfiguredTableAssociationCommand";
 export * from "./CreateConfiguredTableCommand";
 export * from "./CreateIdMappingTableCommand";
@@ -15,6 +16,7 @@ export * from "./DeleteAnalysisTemplateCommand";
 export * from "./DeleteCollaborationCommand";
 export * from "./DeleteConfiguredAudienceModelAssociationCommand";
 export * from "./DeleteConfiguredTableAnalysisRuleCommand";
+export * from "./DeleteConfiguredTableAssociationAnalysisRuleCommand";
 export * from "./DeleteConfiguredTableAssociationCommand";
 export * from "./DeleteConfiguredTableCommand";
 export * from "./DeleteIdMappingTableCommand";
@@ -30,6 +32,7 @@ export * from "./GetCollaborationIdNamespaceAssociationCommand";
 export * from "./GetCollaborationPrivacyBudgetTemplateCommand";
 export * from "./GetConfiguredAudienceModelAssociationCommand";
 export * from "./GetConfiguredTableAnalysisRuleCommand";
+export * from "./GetConfiguredTableAssociationAnalysisRuleCommand";
 export * from "./GetConfiguredTableAssociationCommand";
 export * from "./GetConfiguredTableCommand";
 export * from "./GetIdMappingTableCommand";
@@ -67,6 +70,7 @@ export * from "./UpdateAnalysisTemplateCommand";
 export * from "./UpdateCollaborationCommand";
 export * from "./UpdateConfiguredAudienceModelAssociationCommand";
 export * from "./UpdateConfiguredTableAnalysisRuleCommand";
+export * from "./UpdateConfiguredTableAssociationAnalysisRuleCommand";
 export * from "./UpdateConfiguredTableAssociationCommand";
 export * from "./UpdateConfiguredTableCommand";
 export * from "./UpdateIdMappingTableCommand";

package/dist-es/models/index.js

@@ -1 +1,2 @@
 export * from "./models_0";
+export * from "./models_1";

package/dist-es/models/models_0.js

@@ -16,6 +16,11 @@ export class AccessDeniedException extends __BaseException {
         this.reason = opts.reason;
     }
 }
+export const AdditionalAnalyses = {
+    ALLOWED: "ALLOWED",
+    NOT_ALLOWED: "NOT_ALLOWED",
+    REQUIRED: "REQUIRED",
+};
 export const AggregateFunctionName = {
     AVG: "AVG",
     COUNT: "COUNT",
@@ -232,19 +237,25 @@ export class ValidationException extends __BaseException {
         this.fieldList = opts.fieldList;
     }
 }
+export const AnalysisType = {
+    ADDITIONAL_ANALYSIS: "ADDITIONAL_ANALYSIS",
+    DIRECT_ANALYSIS: "DIRECT_ANALYSIS",
+};
 export const SchemaConfiguration = {
-    CUSTOM_ANALYSIS_NOT_ALLOWED: "CUSTOM_ANALYSIS_NOT_ALLOWED",
     DIFFERENTIAL_PRIVACY: "DIFFERENTIAL_PRIVACY",
-    DIFFERENTIAL_PRIVACY_BUDGET_NOT_CONFIGURED: "DIFFERENTIAL_PRIVACY_BUDGET_NOT_CONFIGURED",
-    ID_MAPPING_TABLE_NOT_POPULATED: "ID_MAPPING_TABLE_NOT_POPULATED",
-    NO_MEMBER_ACCOUNT_ALLOWED_TO_PROVIDE_ANALYSIS: "NO_MEMBER_ACCOUNT_ALLOWED_TO_PROVIDE_ANALYSIS",
 };
 export const SchemaStatusReasonCode = {
+    ADDITIONAL_ANALYSES_NOT_ALLOWED: "ADDITIONAL_ANALYSES_NOT_ALLOWED",
+    ADDITIONAL_ANALYSES_NOT_CONFIGURED: "ADDITIONAL_ANALYSES_NOT_CONFIGURED",
     ANALYSIS_PROVIDERS_NOT_CONFIGURED: "ANALYSIS_PROVIDERS_NOT_CONFIGURED",
     ANALYSIS_RULE_MISSING: "ANALYSIS_RULE_MISSING",
+    ANALYSIS_RULE_TYPES_NOT_COMPATIBLE: "ANALYSIS_RULE_TYPES_NOT_COMPATIBLE",
     ANALYSIS_TEMPLATES_NOT_CONFIGURED: "ANALYSIS_TEMPLATES_NOT_CONFIGURED",
+    COLLABORATION_ANALYSIS_RULE_NOT_CONFIGURED: "COLLABORATION_ANALYSIS_RULE_NOT_CONFIGURED",
     DIFFERENTIAL_PRIVACY_POLICY_NOT_CONFIGURED: "DIFFERENTIAL_PRIVACY_POLICY_NOT_CONFIGURED",
     ID_MAPPING_TABLE_NOT_POPULATED: "ID_MAPPING_TABLE_NOT_POPULATED",
+    RESULT_RECEIVERS_NOT_ALLOWED: "RESULT_RECEIVERS_NOT_ALLOWED",
+    RESULT_RECEIVERS_NOT_CONFIGURED: "RESULT_RECEIVERS_NOT_CONFIGURED",
 };
 export const SchemaStatus = {
     NOT_READY: "NOT_READY",
@@ -314,6 +325,31 @@ export const FilterableMemberStatus = {
     ACTIVE: "ACTIVE",
     INVITED: "INVITED",
 };
+export const ConfiguredTableAssociationAnalysisRuleType = {
+    AGGREGATION: "AGGREGATION",
+    CUSTOM: "CUSTOM",
+    LIST: "LIST",
+};
+export var ConfiguredTableAssociationAnalysisRulePolicyV1;
+(function (ConfiguredTableAssociationAnalysisRulePolicyV1) {
+    ConfiguredTableAssociationAnalysisRulePolicyV1.visit = (value, visitor) => {
+        if (value.list !== undefined)
+            return visitor.list(value.list);
+        if (value.aggregation !== undefined)
+            return visitor.aggregation(value.aggregation);
+        if (value.custom !== undefined)
+            return visitor.custom(value.custom);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ConfiguredTableAssociationAnalysisRulePolicyV1 || (ConfiguredTableAssociationAnalysisRulePolicyV1 = {}));
+export var ConfiguredTableAssociationAnalysisRulePolicy;
+(function (ConfiguredTableAssociationAnalysisRulePolicy) {
+    ConfiguredTableAssociationAnalysisRulePolicy.visit = (value, visitor) => {
+        if (value.v1 !== undefined)
+            return visitor.v1(value.v1);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ConfiguredTableAssociationAnalysisRulePolicy || (ConfiguredTableAssociationAnalysisRulePolicy = {}));
 export var TableReference;
 (function (TableReference) {
     TableReference.visit = (value, visitor) => {
@@ -383,6 +419,8 @@ export var ProtectedQueryOutputConfiguration;
     ProtectedQueryOutputConfiguration.visit = (value, visitor) => {
         if (value.s3 !== undefined)
             return visitor.s3(value.s3);
+        if (value.member !== undefined)
+            return visitor.member(value.member);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(ProtectedQueryOutputConfiguration || (ProtectedQueryOutputConfiguration = {}));
@@ -395,6 +433,14 @@ export const ProtectedQueryStatus = {
     SUCCESS: "SUCCESS",
     TIMED_OUT: "TIMED_OUT",
 };
+export var ConfigurationDetails;
+(function (ConfigurationDetails) {
+    ConfigurationDetails.visit = (value, visitor) => {
+        if (value.directAnalysisConfigurationDetails !== undefined)
+            return visitor.directAnalysisConfigurationDetails(value.directAnalysisConfigurationDetails);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ConfigurationDetails || (ConfigurationDetails = {}));
 export var PreviewPrivacyImpactParametersInput;
 (function (PreviewPrivacyImpactParametersInput) {
     PreviewPrivacyImpactParametersInput.visit = (value, visitor) => {
@@ -417,22 +463,6 @@ export const ProtectedQueryType = {
 export const TargetProtectedQueryStatus = {
     CANCELLED: "CANCELLED",
 };
-export var PrivacyBudgetTemplateParametersInput;
-(function (PrivacyBudgetTemplateParametersInput) {
-    PrivacyBudgetTemplateParametersInput.visit = (value, visitor) => {
-        if (value.differentialPrivacy !== undefined)
-            return visitor.differentialPrivacy(value.differentialPrivacy);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(PrivacyBudgetTemplateParametersInput || (PrivacyBudgetTemplateParametersInput = {}));
-export var PrivacyBudgetTemplateUpdateParameters;
-(function (PrivacyBudgetTemplateUpdateParameters) {
-    PrivacyBudgetTemplateUpdateParameters.visit = (value, visitor) => {
-        if (value.differentialPrivacy !== undefined)
-            return visitor.differentialPrivacy(value.differentialPrivacy);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(PrivacyBudgetTemplateUpdateParameters || (PrivacyBudgetTemplateUpdateParameters = {}));
 export const AnalysisParameterFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -503,7 +533,3 @@ export const StartProtectedQueryOutputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.protectedQuery && { protectedQuery: ProtectedQueryFilterSensitiveLog(obj.protectedQuery) }),
 });
-export const UpdateProtectedQueryOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.protectedQuery && { protectedQuery: ProtectedQueryFilterSensitiveLog(obj.protectedQuery) }),
-});

package/dist-es/models/models_1.js

@@ -0,0 +1,21 @@
+import { ProtectedQueryFilterSensitiveLog, } from "./models_0";
+export var PrivacyBudgetTemplateParametersInput;
+(function (PrivacyBudgetTemplateParametersInput) {
+    PrivacyBudgetTemplateParametersInput.visit = (value, visitor) => {
+        if (value.differentialPrivacy !== undefined)
+            return visitor.differentialPrivacy(value.differentialPrivacy);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PrivacyBudgetTemplateParametersInput || (PrivacyBudgetTemplateParametersInput = {}));
+export var PrivacyBudgetTemplateUpdateParameters;
+(function (PrivacyBudgetTemplateUpdateParameters) {
+    PrivacyBudgetTemplateUpdateParameters.visit = (value, visitor) => {
+        if (value.differentialPrivacy !== undefined)
+            return visitor.differentialPrivacy(value.differentialPrivacy);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PrivacyBudgetTemplateUpdateParameters || (PrivacyBudgetTemplateUpdateParameters = {}));
+export const UpdateProtectedQueryOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.protectedQuery && { protectedQuery: ProtectedQueryFilterSensitiveLog(obj.protectedQuery) }),
+});

package/dist-es/protocols/Aws_restJson1.js

@@ -154,6 +154,22 @@ export const se_CreateConfiguredTableAssociationCommand = async (input, context)
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_CreateConfiguredTableAssociationAnalysisRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}/analysisRule");
+    b.p("membershipIdentifier", () => input.membershipIdentifier, "{membershipIdentifier}", false);
+    b.p("configuredTableAssociationIdentifier", () => input.configuredTableAssociationIdentifier, "{configuredTableAssociationIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        analysisRulePolicy: (_) => _json(_),
+        analysisRuleType: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_CreateIdMappingTableCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -282,6 +298,17 @@ export const se_DeleteConfiguredTableAssociationCommand = async (input, context)
     b.m("DELETE").h(headers).b(body);
     return b.build();
 };
+export const se_DeleteConfiguredTableAssociationAnalysisRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}/analysisRule/{analysisRuleType}");
+    b.p("membershipIdentifier", () => input.membershipIdentifier, "{membershipIdentifier}", false);
+    b.p("configuredTableAssociationIdentifier", () => input.configuredTableAssociationIdentifier, "{configuredTableAssociationIdentifier}", false);
+    b.p("analysisRuleType", () => input.analysisRuleType, "{analysisRuleType}", false);
+    let body;
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
+};
 export const se_DeleteIdMappingTableCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -429,6 +456,17 @@ export const se_GetConfiguredTableAssociationCommand = async (input, context) =>
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+export const se_GetConfiguredTableAssociationAnalysisRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}/analysisRule/{analysisRuleType}");
+    b.p("membershipIdentifier", () => input.membershipIdentifier, "{membershipIdentifier}", false);
+    b.p("configuredTableAssociationIdentifier", () => input.configuredTableAssociationIdentifier, "{configuredTableAssociationIdentifier}", false);
+    b.p("analysisRuleType", () => input.analysisRuleType, "{analysisRuleType}", false);
+    let body;
+    b.m("GET").h(headers).b(body);
+    return b.build();
+};
 export const se_GetIdMappingTableCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -906,6 +944,22 @@ export const se_UpdateConfiguredTableAssociationCommand = async (input, context)
     b.m("PATCH").h(headers).b(body);
     return b.build();
 };
+export const se_UpdateConfiguredTableAssociationAnalysisRuleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/memberships/{membershipIdentifier}/configuredTableAssociations/{configuredTableAssociationIdentifier}/analysisRule/{analysisRuleType}");
+    b.p("membershipIdentifier", () => input.membershipIdentifier, "{membershipIdentifier}", false);
+    b.p("configuredTableAssociationIdentifier", () => input.configuredTableAssociationIdentifier, "{configuredTableAssociationIdentifier}", false);
+    b.p("analysisRuleType", () => input.analysisRuleType, "{analysisRuleType}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        analysisRulePolicy: (_) => _json(_),
+    }));
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
+};
 export const se_UpdateIdMappingTableCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -1114,6 +1168,20 @@ export const de_CreateConfiguredTableAssociationCommand = async (output, context
     Object.assign(contents, doc);
     return contents;
 };
+export const de_CreateConfiguredTableAssociationAnalysisRuleCommand = 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, {
+        analysisRule: (_) => de_ConfiguredTableAssociationAnalysisRule(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_CreateIdMappingTableCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1230,6 +1298,16 @@ export const de_DeleteConfiguredTableAssociationCommand = async (output, context
     await collectBody(output.body, context);
     return contents;
 };
+export const de_DeleteConfiguredTableAssociationAnalysisRuleCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_DeleteIdMappingTableCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1420,6 +1498,20 @@ export const de_GetConfiguredTableAssociationCommand = async (output, context) =
     Object.assign(contents, doc);
     return contents;
 };
+export const de_GetConfiguredTableAssociationAnalysisRuleCommand = 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, {
+        analysisRule: (_) => de_ConfiguredTableAssociationAnalysisRule(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_GetIdMappingTableCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1948,6 +2040,20 @@ export const de_UpdateConfiguredTableAssociationCommand = async (output, context
     Object.assign(contents, doc);
     return contents;
 };
+export const de_UpdateConfiguredTableAssociationAnalysisRuleCommand = 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, {
+        analysisRule: (_) => de_ConfiguredTableAssociationAnalysisRule(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_UpdateIdMappingTableCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -2489,6 +2595,7 @@ const de_ConfiguredTableAnalysisRule = (output, context) => {
 };
 const de_ConfiguredTableAssociation = (output, context) => {
     return take(output, {
+        analysisRuleTypes: _json,
         arn: __expectString,
         configuredTableArn: __expectString,
         configuredTableId: __expectString,
@@ -2502,6 +2609,17 @@ const de_ConfiguredTableAssociation = (output, context) => {
         updateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
     });
 };
+const de_ConfiguredTableAssociationAnalysisRule = (output, context) => {
+    return take(output, {
+        configuredTableAssociationArn: __expectString,
+        configuredTableAssociationId: __expectString,
+        createTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        membershipIdentifier: __expectString,
+        policy: (_) => _json(__expectUnion(_)),
+        type: __expectString,
+        updateTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+};
 const de_ConfiguredTableAssociationSummary = (output, context) => {
     return take(output, {
         arn: __expectString,
@@ -2801,6 +2919,7 @@ const de_ProtectedQuerySummary = (output, context) => {
         id: __expectString,
         membershipArn: __expectString,
         membershipId: __expectString,
+        receiverConfigurations: _json,
         status: __expectString,
     });
 };

package/dist-types/CleanRooms.d.ts

@@ -7,6 +7,7 @@ import { CreateAnalysisTemplateCommandInput, CreateAnalysisTemplateCommandOutput
 import { CreateCollaborationCommandInput, CreateCollaborationCommandOutput } from "./commands/CreateCollaborationCommand";
 import { CreateConfiguredAudienceModelAssociationCommandInput, CreateConfiguredAudienceModelAssociationCommandOutput } from "./commands/CreateConfiguredAudienceModelAssociationCommand";
 import { CreateConfiguredTableAnalysisRuleCommandInput, CreateConfiguredTableAnalysisRuleCommandOutput } from "./commands/CreateConfiguredTableAnalysisRuleCommand";
+import { CreateConfiguredTableAssociationAnalysisRuleCommandInput, CreateConfiguredTableAssociationAnalysisRuleCommandOutput } from "./commands/CreateConfiguredTableAssociationAnalysisRuleCommand";
 import { CreateConfiguredTableAssociationCommandInput, CreateConfiguredTableAssociationCommandOutput } from "./commands/CreateConfiguredTableAssociationCommand";
 import { CreateConfiguredTableCommandInput, CreateConfiguredTableCommandOutput } from "./commands/CreateConfiguredTableCommand";
 import { CreateIdMappingTableCommandInput, CreateIdMappingTableCommandOutput } from "./commands/CreateIdMappingTableCommand";
@@ -17,6 +18,7 @@ import { DeleteAnalysisTemplateCommandInput, DeleteAnalysisTemplateCommandOutput
 import { DeleteCollaborationCommandInput, DeleteCollaborationCommandOutput } from "./commands/DeleteCollaborationCommand";
 import { DeleteConfiguredAudienceModelAssociationCommandInput, DeleteConfiguredAudienceModelAssociationCommandOutput } from "./commands/DeleteConfiguredAudienceModelAssociationCommand";
 import { DeleteConfiguredTableAnalysisRuleCommandInput, DeleteConfiguredTableAnalysisRuleCommandOutput } from "./commands/DeleteConfiguredTableAnalysisRuleCommand";
+import { DeleteConfiguredTableAssociationAnalysisRuleCommandInput, DeleteConfiguredTableAssociationAnalysisRuleCommandOutput } from "./commands/DeleteConfiguredTableAssociationAnalysisRuleCommand";
 import { DeleteConfiguredTableAssociationCommandInput, DeleteConfiguredTableAssociationCommandOutput } from "./commands/DeleteConfiguredTableAssociationCommand";
 import { DeleteConfiguredTableCommandInput, DeleteConfiguredTableCommandOutput } from "./commands/DeleteConfiguredTableCommand";
 import { DeleteIdMappingTableCommandInput, DeleteIdMappingTableCommandOutput } from "./commands/DeleteIdMappingTableCommand";
@@ -32,6 +34,7 @@ import { GetCollaborationIdNamespaceAssociationCommandInput, GetCollaborationIdN
 import { GetCollaborationPrivacyBudgetTemplateCommandInput, GetCollaborationPrivacyBudgetTemplateCommandOutput } from "./commands/GetCollaborationPrivacyBudgetTemplateCommand";
 import { GetConfiguredAudienceModelAssociationCommandInput, GetConfiguredAudienceModelAssociationCommandOutput } from "./commands/GetConfiguredAudienceModelAssociationCommand";
 import { GetConfiguredTableAnalysisRuleCommandInput, GetConfiguredTableAnalysisRuleCommandOutput } from "./commands/GetConfiguredTableAnalysisRuleCommand";
+import { GetConfiguredTableAssociationAnalysisRuleCommandInput, GetConfiguredTableAssociationAnalysisRuleCommandOutput } from "./commands/GetConfiguredTableAssociationAnalysisRuleCommand";
 import { GetConfiguredTableAssociationCommandInput, GetConfiguredTableAssociationCommandOutput } from "./commands/GetConfiguredTableAssociationCommand";
 import { GetConfiguredTableCommandInput, GetConfiguredTableCommandOutput } from "./commands/GetConfiguredTableCommand";
 import { GetIdMappingTableCommandInput, GetIdMappingTableCommandOutput } from "./commands/GetIdMappingTableCommand";
@@ -69,6 +72,7 @@ import { UpdateAnalysisTemplateCommandInput, UpdateAnalysisTemplateCommandOutput
 import { UpdateCollaborationCommandInput, UpdateCollaborationCommandOutput } from "./commands/UpdateCollaborationCommand";
 import { UpdateConfiguredAudienceModelAssociationCommandInput, UpdateConfiguredAudienceModelAssociationCommandOutput } from "./commands/UpdateConfiguredAudienceModelAssociationCommand";
 import { UpdateConfiguredTableAnalysisRuleCommandInput, UpdateConfiguredTableAnalysisRuleCommandOutput } from "./commands/UpdateConfiguredTableAnalysisRuleCommand";
+import { UpdateConfiguredTableAssociationAnalysisRuleCommandInput, UpdateConfiguredTableAssociationAnalysisRuleCommandOutput } from "./commands/UpdateConfiguredTableAssociationAnalysisRuleCommand";
 import { UpdateConfiguredTableAssociationCommandInput, UpdateConfiguredTableAssociationCommandOutput } from "./commands/UpdateConfiguredTableAssociationCommand";
 import { UpdateConfiguredTableCommandInput, UpdateConfiguredTableCommandOutput } from "./commands/UpdateConfiguredTableCommand";
 import { UpdateIdMappingTableCommandInput, UpdateIdMappingTableCommandOutput } from "./commands/UpdateIdMappingTableCommand";
@@ -131,6 +135,12 @@ export interface CleanRooms {
     createConfiguredTableAssociation(args: CreateConfiguredTableAssociationCommandInput, options?: __HttpHandlerOptions): Promise<CreateConfiguredTableAssociationCommandOutput>;
     createConfiguredTableAssociation(args: CreateConfiguredTableAssociationCommandInput, cb: (err: any, data?: CreateConfiguredTableAssociationCommandOutput) => void): void;
     createConfiguredTableAssociation(args: CreateConfiguredTableAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateConfiguredTableAssociationCommandOutput) => void): void;
+    /**
+     * @see {@link CreateConfiguredTableAssociationAnalysisRuleCommand}
+     */
+    createConfiguredTableAssociationAnalysisRule(args: CreateConfiguredTableAssociationAnalysisRuleCommandInput, options?: __HttpHandlerOptions): Promise<CreateConfiguredTableAssociationAnalysisRuleCommandOutput>;
+    createConfiguredTableAssociationAnalysisRule(args: CreateConfiguredTableAssociationAnalysisRuleCommandInput, cb: (err: any, data?: CreateConfiguredTableAssociationAnalysisRuleCommandOutput) => void): void;
+    createConfiguredTableAssociationAnalysisRule(args: CreateConfiguredTableAssociationAnalysisRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateConfiguredTableAssociationAnalysisRuleCommandOutput) => void): void;
     /**
      * @see {@link CreateIdMappingTableCommand}
      */
@@ -191,6 +201,12 @@ export interface CleanRooms {
     deleteConfiguredTableAssociation(args: DeleteConfiguredTableAssociationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteConfiguredTableAssociationCommandOutput>;
     deleteConfiguredTableAssociation(args: DeleteConfiguredTableAssociationCommandInput, cb: (err: any, data?: DeleteConfiguredTableAssociationCommandOutput) => void): void;
     deleteConfiguredTableAssociation(args: DeleteConfiguredTableAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteConfiguredTableAssociationCommandOutput) => void): void;
+    /**
+     * @see {@link DeleteConfiguredTableAssociationAnalysisRuleCommand}
+     */
+    deleteConfiguredTableAssociationAnalysisRule(args: DeleteConfiguredTableAssociationAnalysisRuleCommandInput, options?: __HttpHandlerOptions): Promise<DeleteConfiguredTableAssociationAnalysisRuleCommandOutput>;
+    deleteConfiguredTableAssociationAnalysisRule(args: DeleteConfiguredTableAssociationAnalysisRuleCommandInput, cb: (err: any, data?: DeleteConfiguredTableAssociationAnalysisRuleCommandOutput) => void): void;
+    deleteConfiguredTableAssociationAnalysisRule(args: DeleteConfiguredTableAssociationAnalysisRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteConfiguredTableAssociationAnalysisRuleCommandOutput) => void): void;
     /**
      * @see {@link DeleteIdMappingTableCommand}
      */
@@ -281,6 +297,12 @@ export interface CleanRooms {
     getConfiguredTableAssociation(args: GetConfiguredTableAssociationCommandInput, options?: __HttpHandlerOptions): Promise<GetConfiguredTableAssociationCommandOutput>;
     getConfiguredTableAssociation(args: GetConfiguredTableAssociationCommandInput, cb: (err: any, data?: GetConfiguredTableAssociationCommandOutput) => void): void;
     getConfiguredTableAssociation(args: GetConfiguredTableAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetConfiguredTableAssociationCommandOutput) => void): void;
+    /**
+     * @see {@link GetConfiguredTableAssociationAnalysisRuleCommand}
+     */
+    getConfiguredTableAssociationAnalysisRule(args: GetConfiguredTableAssociationAnalysisRuleCommandInput, options?: __HttpHandlerOptions): Promise<GetConfiguredTableAssociationAnalysisRuleCommandOutput>;
+    getConfiguredTableAssociationAnalysisRule(args: GetConfiguredTableAssociationAnalysisRuleCommandInput, cb: (err: any, data?: GetConfiguredTableAssociationAnalysisRuleCommandOutput) => void): void;
+    getConfiguredTableAssociationAnalysisRule(args: GetConfiguredTableAssociationAnalysisRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetConfiguredTableAssociationAnalysisRuleCommandOutput) => void): void;
     /**
      * @see {@link GetIdMappingTableCommand}
      */
@@ -506,6 +528,12 @@ export interface CleanRooms {
     updateConfiguredTableAssociation(args: UpdateConfiguredTableAssociationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateConfiguredTableAssociationCommandOutput>;
     updateConfiguredTableAssociation(args: UpdateConfiguredTableAssociationCommandInput, cb: (err: any, data?: UpdateConfiguredTableAssociationCommandOutput) => void): void;
     updateConfiguredTableAssociation(args: UpdateConfiguredTableAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateConfiguredTableAssociationCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateConfiguredTableAssociationAnalysisRuleCommand}
+     */
+    updateConfiguredTableAssociationAnalysisRule(args: UpdateConfiguredTableAssociationAnalysisRuleCommandInput, options?: __HttpHandlerOptions): Promise<UpdateConfiguredTableAssociationAnalysisRuleCommandOutput>;
+    updateConfiguredTableAssociationAnalysisRule(args: UpdateConfiguredTableAssociationAnalysisRuleCommandInput, cb: (err: any, data?: UpdateConfiguredTableAssociationAnalysisRuleCommandOutput) => void): void;
+    updateConfiguredTableAssociationAnalysisRule(args: UpdateConfiguredTableAssociationAnalysisRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateConfiguredTableAssociationAnalysisRuleCommandOutput) => void): void;
     /**
      * @see {@link UpdateIdMappingTableCommand}
      */