@aws-sdk/client-cleanrooms 3.250.0

package/dist-es/models/models_0.js

@@ -0,0 +1,663 @@
+import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
+import { CleanRoomsServiceException as __BaseException } from "./CleanRoomsServiceException";
+export var AccessDeniedExceptionReason;
+(function (AccessDeniedExceptionReason) {
+    AccessDeniedExceptionReason["INSUFFICIENT_PERMISSIONS"] = "INSUFFICIENT_PERMISSIONS";
+})(AccessDeniedExceptionReason || (AccessDeniedExceptionReason = {}));
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export var AggregateFunctionName;
+(function (AggregateFunctionName) {
+    AggregateFunctionName["AVG"] = "AVG";
+    AggregateFunctionName["COUNT"] = "COUNT";
+    AggregateFunctionName["COUNT_DISTINCT"] = "COUNT_DISTINCT";
+    AggregateFunctionName["SUM"] = "SUM";
+    AggregateFunctionName["SUM_DISTINCT"] = "SUM_DISTINCT";
+})(AggregateFunctionName || (AggregateFunctionName = {}));
+export var AggregationType;
+(function (AggregationType) {
+    AggregationType["COUNT_DISTINCT"] = "COUNT_DISTINCT";
+})(AggregationType || (AggregationType = {}));
+export var AnalysisMethod;
+(function (AnalysisMethod) {
+    AnalysisMethod["DIRECT_QUERY"] = "DIRECT_QUERY";
+})(AnalysisMethod || (AnalysisMethod = {}));
+export var JoinRequiredOption;
+(function (JoinRequiredOption) {
+    JoinRequiredOption["QUERY_RUNNER"] = "QUERY_RUNNER";
+})(JoinRequiredOption || (JoinRequiredOption = {}));
+export var ScalarFunctions;
+(function (ScalarFunctions) {
+    ScalarFunctions["ABS"] = "ABS";
+    ScalarFunctions["CAST"] = "CAST";
+    ScalarFunctions["CEILING"] = "CEILING";
+    ScalarFunctions["COALESCE"] = "COALESCE";
+    ScalarFunctions["FLOOR"] = "FLOOR";
+    ScalarFunctions["LN"] = "LN";
+    ScalarFunctions["LOG"] = "LOG";
+    ScalarFunctions["LOWER"] = "LOWER";
+    ScalarFunctions["ROUND"] = "ROUND";
+    ScalarFunctions["RTRIM"] = "RTRIM";
+    ScalarFunctions["SQRT"] = "SQRT";
+    ScalarFunctions["TRUNC"] = "TRUNC";
+    ScalarFunctions["UPPER"] = "UPPER";
+})(ScalarFunctions || (ScalarFunctions = {}));
+export var AnalysisRulePolicyV1;
+(function (AnalysisRulePolicyV1) {
+    AnalysisRulePolicyV1.visit = (value, visitor) => {
+        if (value.list !== undefined)
+            return visitor.list(value.list);
+        if (value.aggregation !== undefined)
+            return visitor.aggregation(value.aggregation);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AnalysisRulePolicyV1 || (AnalysisRulePolicyV1 = {}));
+export var AnalysisRulePolicy;
+(function (AnalysisRulePolicy) {
+    AnalysisRulePolicy.visit = (value, visitor) => {
+        if (value.v1 !== undefined)
+            return visitor.v1(value.v1);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AnalysisRulePolicy || (AnalysisRulePolicy = {}));
+export var AnalysisRuleType;
+(function (AnalysisRuleType) {
+    AnalysisRuleType["AGGREGATION"] = "AGGREGATION";
+    AnalysisRuleType["LIST"] = "LIST";
+})(AnalysisRuleType || (AnalysisRuleType = {}));
+export var SchemaType;
+(function (SchemaType) {
+    SchemaType["TABLE"] = "TABLE";
+})(SchemaType || (SchemaType = {}));
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+    }
+}
+export var ResourceType;
+(function (ResourceType) {
+    ResourceType["COLLABORATION"] = "COLLABORATION";
+    ResourceType["CONFIGURED_TABLE"] = "CONFIGURED_TABLE";
+    ResourceType["CONFIGURED_TABLE_ASSOCIATION"] = "CONFIGURED_TABLE_ASSOCIATION";
+    ResourceType["MEMBERSHIP"] = "MEMBERSHIP";
+})(ResourceType || (ResourceType = {}));
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.resourceId = opts.resourceId;
+        this.resourceType = opts.resourceType;
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+export var ValidationExceptionReason;
+(function (ValidationExceptionReason) {
+    ValidationExceptionReason["FIELD_VALIDATION_FAILED"] = "FIELD_VALIDATION_FAILED";
+    ValidationExceptionReason["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
+})(ValidationExceptionReason || (ValidationExceptionReason = {}));
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.reason = opts.reason;
+        this.fieldList = opts.fieldList;
+    }
+}
+export var MemberAbility;
+(function (MemberAbility) {
+    MemberAbility["CAN_QUERY"] = "CAN_QUERY";
+    MemberAbility["CAN_RECEIVE_RESULTS"] = "CAN_RECEIVE_RESULTS";
+})(MemberAbility || (MemberAbility = {}));
+export var CollaborationQueryLogStatus;
+(function (CollaborationQueryLogStatus) {
+    CollaborationQueryLogStatus["DISABLED"] = "DISABLED";
+    CollaborationQueryLogStatus["ENABLED"] = "ENABLED";
+})(CollaborationQueryLogStatus || (CollaborationQueryLogStatus = {}));
+export var MemberStatus;
+(function (MemberStatus) {
+    MemberStatus["ACTIVE"] = "ACTIVE";
+    MemberStatus["INVITED"] = "INVITED";
+    MemberStatus["LEFT"] = "LEFT";
+    MemberStatus["REMOVED"] = "REMOVED";
+})(MemberStatus || (MemberStatus = {}));
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.quotaName = opts.quotaName;
+        this.quotaValue = opts.quotaValue;
+    }
+}
+export var ConflictExceptionReason;
+(function (ConflictExceptionReason) {
+    ConflictExceptionReason["ALREADY_EXISTS"] = "ALREADY_EXISTS";
+    ConflictExceptionReason["INVALID_STATE"] = "INVALID_STATE";
+    ConflictExceptionReason["SUBRESOURCES_EXIST"] = "SUBRESOURCES_EXIST";
+})(ConflictExceptionReason || (ConflictExceptionReason = {}));
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.resourceId = opts.resourceId;
+        this.resourceType = opts.resourceType;
+        this.reason = opts.reason;
+    }
+}
+export var FilterableMemberStatus;
+(function (FilterableMemberStatus) {
+    FilterableMemberStatus["ACTIVE"] = "ACTIVE";
+    FilterableMemberStatus["INVITED"] = "INVITED";
+})(FilterableMemberStatus || (FilterableMemberStatus = {}));
+export var TableReference;
+(function (TableReference) {
+    TableReference.visit = (value, visitor) => {
+        if (value.glue !== undefined)
+            return visitor.glue(value.glue);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(TableReference || (TableReference = {}));
+export var ConfiguredTableAnalysisRuleType;
+(function (ConfiguredTableAnalysisRuleType) {
+    ConfiguredTableAnalysisRuleType["AGGREGATION"] = "AGGREGATION";
+    ConfiguredTableAnalysisRuleType["LIST"] = "LIST";
+})(ConfiguredTableAnalysisRuleType || (ConfiguredTableAnalysisRuleType = {}));
+export var ConfiguredTableAnalysisRulePolicyV1;
+(function (ConfiguredTableAnalysisRulePolicyV1) {
+    ConfiguredTableAnalysisRulePolicyV1.visit = (value, visitor) => {
+        if (value.list !== undefined)
+            return visitor.list(value.list);
+        if (value.aggregation !== undefined)
+            return visitor.aggregation(value.aggregation);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ConfiguredTableAnalysisRulePolicyV1 || (ConfiguredTableAnalysisRulePolicyV1 = {}));
+export var ConfiguredTableAnalysisRulePolicy;
+(function (ConfiguredTableAnalysisRulePolicy) {
+    ConfiguredTableAnalysisRulePolicy.visit = (value, visitor) => {
+        if (value.v1 !== undefined)
+            return visitor.v1(value.v1);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ConfiguredTableAnalysisRulePolicy || (ConfiguredTableAnalysisRulePolicy = {}));
+export var MembershipQueryLogStatus;
+(function (MembershipQueryLogStatus) {
+    MembershipQueryLogStatus["DISABLED"] = "DISABLED";
+    MembershipQueryLogStatus["ENABLED"] = "ENABLED";
+})(MembershipQueryLogStatus || (MembershipQueryLogStatus = {}));
+export var MembershipStatus;
+(function (MembershipStatus) {
+    MembershipStatus["ACTIVE"] = "ACTIVE";
+    MembershipStatus["COLLABORATION_DELETED"] = "COLLABORATION_DELETED";
+    MembershipStatus["REMOVED"] = "REMOVED";
+})(MembershipStatus || (MembershipStatus = {}));
+export var ProtectedQueryOutput;
+(function (ProtectedQueryOutput) {
+    ProtectedQueryOutput.visit = (value, visitor) => {
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ProtectedQueryOutput || (ProtectedQueryOutput = {}));
+export var ResultFormat;
+(function (ResultFormat) {
+    ResultFormat["CSV"] = "CSV";
+    ResultFormat["PARQUET"] = "PARQUET";
+})(ResultFormat || (ResultFormat = {}));
+export var ProtectedQueryOutputConfiguration;
+(function (ProtectedQueryOutputConfiguration) {
+    ProtectedQueryOutputConfiguration.visit = (value, visitor) => {
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ProtectedQueryOutputConfiguration || (ProtectedQueryOutputConfiguration = {}));
+export var ProtectedQueryStatus;
+(function (ProtectedQueryStatus) {
+    ProtectedQueryStatus["CANCELLED"] = "CANCELLED";
+    ProtectedQueryStatus["CANCELLING"] = "CANCELLING";
+    ProtectedQueryStatus["FAILED"] = "FAILED";
+    ProtectedQueryStatus["STARTED"] = "STARTED";
+    ProtectedQueryStatus["SUBMITTED"] = "SUBMITTED";
+    ProtectedQueryStatus["SUCCESS"] = "SUCCESS";
+    ProtectedQueryStatus["TIMED_OUT"] = "TIMED_OUT";
+})(ProtectedQueryStatus || (ProtectedQueryStatus = {}));
+export var ProtectedQueryType;
+(function (ProtectedQueryType) {
+    ProtectedQueryType["SQL"] = "SQL";
+})(ProtectedQueryType || (ProtectedQueryType = {}));
+export var TargetProtectedQueryStatus;
+(function (TargetProtectedQueryStatus) {
+    TargetProtectedQueryStatus["CANCELLED"] = "CANCELLED";
+})(TargetProtectedQueryStatus || (TargetProtectedQueryStatus = {}));
+export const AggregateColumnFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AggregationConstraintFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AnalysisRuleAggregationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AnalysisRuleListFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AnalysisRulePolicyV1FilterSensitiveLog = (obj) => {
+    if (obj.list !== undefined)
+        return { list: AnalysisRuleListFilterSensitiveLog(obj.list) };
+    if (obj.aggregation !== undefined)
+        return { aggregation: AnalysisRuleAggregationFilterSensitiveLog(obj.aggregation) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const AnalysisRulePolicyFilterSensitiveLog = (obj) => {
+    if (obj.v1 !== undefined)
+        return { v1: AnalysisRulePolicyV1FilterSensitiveLog(obj.v1) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const AnalysisRuleFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.policy && { policy: AnalysisRulePolicyFilterSensitiveLog(obj.policy) }),
+});
+export const BatchGetSchemaInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BatchGetSchemaErrorFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ColumnFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SchemaFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BatchGetSchemaOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ValidationExceptionFieldFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DataEncryptionMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const MemberSpecificationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateCollaborationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CollaborationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateCollaborationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteCollaborationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteCollaborationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteMemberInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteMemberOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetCollaborationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetCollaborationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSchemaInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSchemaOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSchemaAnalysisRuleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSchemaAnalysisRuleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.analysisRule && { analysisRule: AnalysisRuleFilterSensitiveLog(obj.analysisRule) }),
+});
+export const ListCollaborationsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CollaborationSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListCollaborationsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListMembersInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const MemberSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListMembersOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSchemasInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SchemaSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSchemasOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateCollaborationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateCollaborationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateConfiguredTableAssociationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ConfiguredTableAssociationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateConfiguredTableAssociationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteConfiguredTableAssociationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteConfiguredTableAssociationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetConfiguredTableAssociationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetConfiguredTableAssociationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListConfiguredTableAssociationsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ConfiguredTableAssociationSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListConfiguredTableAssociationsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateConfiguredTableAssociationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateConfiguredTableAssociationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GlueTableReferenceFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TableReferenceFilterSensitiveLog = (obj) => {
+    if (obj.glue !== undefined)
+        return { glue: GlueTableReferenceFilterSensitiveLog(obj.glue) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateConfiguredTableInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tableReference && { tableReference: TableReferenceFilterSensitiveLog(obj.tableReference) }),
+});
+export const ConfiguredTableFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tableReference && { tableReference: TableReferenceFilterSensitiveLog(obj.tableReference) }),
+});
+export const CreateConfiguredTableOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.configuredTable && { configuredTable: ConfiguredTableFilterSensitiveLog(obj.configuredTable) }),
+});
+export const ConfiguredTableAnalysisRulePolicyV1FilterSensitiveLog = (obj) => {
+    if (obj.list !== undefined)
+        return { list: AnalysisRuleListFilterSensitiveLog(obj.list) };
+    if (obj.aggregation !== undefined)
+        return { aggregation: AnalysisRuleAggregationFilterSensitiveLog(obj.aggregation) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ConfiguredTableAnalysisRulePolicyFilterSensitiveLog = (obj) => {
+    if (obj.v1 !== undefined)
+        return { v1: ConfiguredTableAnalysisRulePolicyV1FilterSensitiveLog(obj.v1) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateConfiguredTableAnalysisRuleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.analysisRulePolicy && {
+        analysisRulePolicy: ConfiguredTableAnalysisRulePolicyFilterSensitiveLog(obj.analysisRulePolicy),
+    }),
+});
+export const ConfiguredTableAnalysisRuleFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.policy && { policy: ConfiguredTableAnalysisRulePolicyFilterSensitiveLog(obj.policy) }),
+});
+export const CreateConfiguredTableAnalysisRuleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.analysisRule && { analysisRule: ConfiguredTableAnalysisRuleFilterSensitiveLog(obj.analysisRule) }),
+});
+export const DeleteConfiguredTableInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteConfiguredTableOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteConfiguredTableAnalysisRuleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteConfiguredTableAnalysisRuleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetConfiguredTableInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetConfiguredTableOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.configuredTable && { configuredTable: ConfiguredTableFilterSensitiveLog(obj.configuredTable) }),
+});
+export const GetConfiguredTableAnalysisRuleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetConfiguredTableAnalysisRuleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.analysisRule && { analysisRule: ConfiguredTableAnalysisRuleFilterSensitiveLog(obj.analysisRule) }),
+});
+export const ListConfiguredTablesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ConfiguredTableSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListConfiguredTablesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateConfiguredTableInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateConfiguredTableOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.configuredTable && { configuredTable: ConfiguredTableFilterSensitiveLog(obj.configuredTable) }),
+});
+export const UpdateConfiguredTableAnalysisRuleInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.analysisRulePolicy && {
+        analysisRulePolicy: ConfiguredTableAnalysisRulePolicyFilterSensitiveLog(obj.analysisRulePolicy),
+    }),
+});
+export const UpdateConfiguredTableAnalysisRuleOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.analysisRule && { analysisRule: ConfiguredTableAnalysisRuleFilterSensitiveLog(obj.analysisRule) }),
+});
+export const CreateMembershipInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const MembershipFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateMembershipOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteMembershipInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteMembershipOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetMembershipInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetMembershipOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetProtectedQueryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProtectedQueryErrorFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProtectedQueryS3OutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProtectedQueryOutputFilterSensitiveLog = (obj) => {
+    if (obj.s3 !== undefined)
+        return { s3: ProtectedQueryS3OutputFilterSensitiveLog(obj.s3) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ProtectedQueryResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.output && { output: ProtectedQueryOutputFilterSensitiveLog(obj.output) }),
+});
+export const ProtectedQueryS3OutputConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProtectedQueryOutputConfigurationFilterSensitiveLog = (obj) => {
+    if (obj.s3 !== undefined)
+        return { s3: ProtectedQueryS3OutputConfigurationFilterSensitiveLog(obj.s3) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const ProtectedQueryResultConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.outputConfiguration && {
+        outputConfiguration: ProtectedQueryOutputConfigurationFilterSensitiveLog(obj.outputConfiguration),
+    }),
+});
+export const ProtectedQuerySQLParametersFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProtectedQueryStatisticsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProtectedQueryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.sqlParameters && { sqlParameters: SENSITIVE_STRING }),
+    ...(obj.resultConfiguration && {
+        resultConfiguration: ProtectedQueryResultConfigurationFilterSensitiveLog(obj.resultConfiguration),
+    }),
+    ...(obj.result && { result: ProtectedQueryResultFilterSensitiveLog(obj.result) }),
+});
+export const GetProtectedQueryOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.protectedQuery && { protectedQuery: ProtectedQueryFilterSensitiveLog(obj.protectedQuery) }),
+});
+export const ListMembershipsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const MembershipSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListMembershipsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListProtectedQueriesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProtectedQuerySummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListProtectedQueriesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StartProtectedQueryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.sqlParameters && { sqlParameters: SENSITIVE_STRING }),
+    ...(obj.resultConfiguration && {
+        resultConfiguration: ProtectedQueryResultConfigurationFilterSensitiveLog(obj.resultConfiguration),
+    }),
+});
+export const StartProtectedQueryOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.protectedQuery && { protectedQuery: ProtectedQueryFilterSensitiveLog(obj.protectedQuery) }),
+});
+export const UpdateMembershipInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateMembershipOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateProtectedQueryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateProtectedQueryOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.protectedQuery && { protectedQuery: ProtectedQueryFilterSensitiveLog(obj.protectedQuery) }),
+});

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListCollaborationsPaginator.js

@@ -0,0 +1,32 @@
+import { CleanRooms } from "../CleanRooms";
+import { CleanRoomsClient } from "../CleanRoomsClient";
+import { ListCollaborationsCommand, } from "../commands/ListCollaborationsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListCollaborationsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listCollaborations(input, ...args);
+};
+export async function* paginateListCollaborations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof CleanRooms) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof CleanRoomsClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected CleanRooms | CleanRoomsClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}