@aws-sdk/client-bedrock 3.859.0 → 3.862.0

package/dist-es/models/models_0.js

@@ -78,18 +78,6 @@ export class ConflictException extends __BaseException {
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
 }
-export var EndpointConfig;
-(function (EndpointConfig) {
-    EndpointConfig.visit = (value, visitor) => {
-        if (value.sageMaker !== undefined)
-            return visitor.sageMaker(value.sageMaker);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(EndpointConfig || (EndpointConfig = {}));
-export const Status = {
-    INCOMPATIBLE_ENDPOINT: "INCOMPATIBLE_ENDPOINT",
-    REGISTERED: "REGISTERED",
-};
 export class ServiceQuotaExceededException extends __BaseException {
     name = "ServiceQuotaExceededException";
     $fault = "client";
@@ -102,18 +90,6 @@ export class ServiceQuotaExceededException extends __BaseException {
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
     }
 }
-export class ServiceUnavailableException extends __BaseException {
-    name = "ServiceUnavailableException";
-    $fault = "server";
-    constructor(opts) {
-        super({
-            name: "ServiceUnavailableException",
-            $fault: "server",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
-    }
-}
 export class TooManyTagsException extends __BaseException {
     name = "TooManyTagsException";
     $fault = "client";
@@ -128,6 +104,231 @@ export class TooManyTagsException extends __BaseException {
         this.resourceName = opts.resourceName;
     }
 }
+export const AutomatedReasoningCheckResult = {
+    IMPOSSIBLE: "IMPOSSIBLE",
+    INVALID: "INVALID",
+    NO_TRANSLATION: "NO_TRANSLATION",
+    SATISFIABLE: "SATISFIABLE",
+    TOO_COMPLEX: "TOO_COMPLEX",
+    TRANSLATION_AMBIGUOUS: "TRANSLATION_AMBIGUOUS",
+    VALID: "VALID",
+};
+export class ResourceInUseException extends __BaseException {
+    name = "ResourceInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceInUseException.prototype);
+    }
+}
+export var AutomatedReasoningPolicyTypeValueAnnotation;
+(function (AutomatedReasoningPolicyTypeValueAnnotation) {
+    AutomatedReasoningPolicyTypeValueAnnotation.visit = (value, visitor) => {
+        if (value.addTypeValue !== undefined)
+            return visitor.addTypeValue(value.addTypeValue);
+        if (value.updateTypeValue !== undefined)
+            return visitor.updateTypeValue(value.updateTypeValue);
+        if (value.deleteTypeValue !== undefined)
+            return visitor.deleteTypeValue(value.deleteTypeValue);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AutomatedReasoningPolicyTypeValueAnnotation || (AutomatedReasoningPolicyTypeValueAnnotation = {}));
+export var AutomatedReasoningPolicyAnnotation;
+(function (AutomatedReasoningPolicyAnnotation) {
+    AutomatedReasoningPolicyAnnotation.visit = (value, visitor) => {
+        if (value.addType !== undefined)
+            return visitor.addType(value.addType);
+        if (value.updateType !== undefined)
+            return visitor.updateType(value.updateType);
+        if (value.deleteType !== undefined)
+            return visitor.deleteType(value.deleteType);
+        if (value.addVariable !== undefined)
+            return visitor.addVariable(value.addVariable);
+        if (value.updateVariable !== undefined)
+            return visitor.updateVariable(value.updateVariable);
+        if (value.deleteVariable !== undefined)
+            return visitor.deleteVariable(value.deleteVariable);
+        if (value.addRule !== undefined)
+            return visitor.addRule(value.addRule);
+        if (value.updateRule !== undefined)
+            return visitor.updateRule(value.updateRule);
+        if (value.deleteRule !== undefined)
+            return visitor.deleteRule(value.deleteRule);
+        if (value.addRuleFromNaturalLanguage !== undefined)
+            return visitor.addRuleFromNaturalLanguage(value.addRuleFromNaturalLanguage);
+        if (value.updateFromRulesFeedback !== undefined)
+            return visitor.updateFromRulesFeedback(value.updateFromRulesFeedback);
+        if (value.updateFromScenarioFeedback !== undefined)
+            return visitor.updateFromScenarioFeedback(value.updateFromScenarioFeedback);
+        if (value.ingestContent !== undefined)
+            return visitor.ingestContent(value.ingestContent);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AutomatedReasoningPolicyAnnotation || (AutomatedReasoningPolicyAnnotation = {}));
+export const AutomatedReasoningPolicyBuildWorkflowType = {
+    IMPORT_POLICY: "IMPORT_POLICY",
+    INGEST_CONTENT: "INGEST_CONTENT",
+    REFINE_POLICY: "REFINE_POLICY",
+};
+export const AutomatedReasoningPolicyBuildDocumentContentType = {
+    PDF: "pdf",
+    TEXT: "txt",
+};
+export const AutomatedReasoningPolicyBuildWorkflowStatus = {
+    BUILDING: "BUILDING",
+    CANCELLED: "CANCELLED",
+    CANCEL_REQUESTED: "CANCEL_REQUESTED",
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    PREPROCESSING: "PREPROCESSING",
+    SCHEDULED: "SCHEDULED",
+    TESTING: "TESTING",
+};
+export const AutomatedReasoningPolicyBuildResultAssetType = {
+    BUILD_LOG: "BUILD_LOG",
+    POLICY_DEFINITION: "POLICY_DEFINITION",
+    QUALITY_REPORT: "QUALITY_REPORT",
+};
+export var AutomatedReasoningPolicyMutation;
+(function (AutomatedReasoningPolicyMutation) {
+    AutomatedReasoningPolicyMutation.visit = (value, visitor) => {
+        if (value.addType !== undefined)
+            return visitor.addType(value.addType);
+        if (value.updateType !== undefined)
+            return visitor.updateType(value.updateType);
+        if (value.deleteType !== undefined)
+            return visitor.deleteType(value.deleteType);
+        if (value.addVariable !== undefined)
+            return visitor.addVariable(value.addVariable);
+        if (value.updateVariable !== undefined)
+            return visitor.updateVariable(value.updateVariable);
+        if (value.deleteVariable !== undefined)
+            return visitor.deleteVariable(value.deleteVariable);
+        if (value.addRule !== undefined)
+            return visitor.addRule(value.addRule);
+        if (value.updateRule !== undefined)
+            return visitor.updateRule(value.updateRule);
+        if (value.deleteRule !== undefined)
+            return visitor.deleteRule(value.deleteRule);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AutomatedReasoningPolicyMutation || (AutomatedReasoningPolicyMutation = {}));
+export var AutomatedReasoningPolicyBuildStepContext;
+(function (AutomatedReasoningPolicyBuildStepContext) {
+    AutomatedReasoningPolicyBuildStepContext.visit = (value, visitor) => {
+        if (value.planning !== undefined)
+            return visitor.planning(value.planning);
+        if (value.mutation !== undefined)
+            return visitor.mutation(value.mutation);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AutomatedReasoningPolicyBuildStepContext || (AutomatedReasoningPolicyBuildStepContext = {}));
+export const AutomatedReasoningPolicyBuildMessageType = {
+    ERROR: "ERROR",
+    INFO: "INFO",
+    WARNING: "WARNING",
+};
+export var AutomatedReasoningPolicyDefinitionElement;
+(function (AutomatedReasoningPolicyDefinitionElement) {
+    AutomatedReasoningPolicyDefinitionElement.visit = (value, visitor) => {
+        if (value.policyDefinitionVariable !== undefined)
+            return visitor.policyDefinitionVariable(value.policyDefinitionVariable);
+        if (value.policyDefinitionType !== undefined)
+            return visitor.policyDefinitionType(value.policyDefinitionType);
+        if (value.policyDefinitionRule !== undefined)
+            return visitor.policyDefinitionRule(value.policyDefinitionRule);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AutomatedReasoningPolicyDefinitionElement || (AutomatedReasoningPolicyDefinitionElement = {}));
+export const AutomatedReasoningPolicyAnnotationStatus = {
+    APPLIED: "APPLIED",
+    FAILED: "FAILED",
+};
+export var AutomatedReasoningPolicyBuildResultAssets;
+(function (AutomatedReasoningPolicyBuildResultAssets) {
+    AutomatedReasoningPolicyBuildResultAssets.visit = (value, visitor) => {
+        if (value.policyDefinition !== undefined)
+            return visitor.policyDefinition(value.policyDefinition);
+        if (value.qualityReport !== undefined)
+            return visitor.qualityReport(value.qualityReport);
+        if (value.buildLog !== undefined)
+            return visitor.buildLog(value.buildLog);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AutomatedReasoningPolicyBuildResultAssets || (AutomatedReasoningPolicyBuildResultAssets = {}));
+export const AutomatedReasoningCheckLogicWarningType = {
+    ALWAYS_FALSE: "ALWAYS_FALSE",
+    ALWAYS_TRUE: "ALWAYS_TRUE",
+};
+export var AutomatedReasoningCheckFinding;
+(function (AutomatedReasoningCheckFinding) {
+    AutomatedReasoningCheckFinding.visit = (value, visitor) => {
+        if (value.valid !== undefined)
+            return visitor.valid(value.valid);
+        if (value.invalid !== undefined)
+            return visitor.invalid(value.invalid);
+        if (value.satisfiable !== undefined)
+            return visitor.satisfiable(value.satisfiable);
+        if (value.impossible !== undefined)
+            return visitor.impossible(value.impossible);
+        if (value.translationAmbiguous !== undefined)
+            return visitor.translationAmbiguous(value.translationAmbiguous);
+        if (value.tooComplex !== undefined)
+            return visitor.tooComplex(value.tooComplex);
+        if (value.noTranslations !== undefined)
+            return visitor.noTranslations(value.noTranslations);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AutomatedReasoningCheckFinding || (AutomatedReasoningCheckFinding = {}));
+export const AutomatedReasoningPolicyTestRunResult = {
+    FAILED: "FAILED",
+    PASSED: "PASSED",
+};
+export const AutomatedReasoningPolicyTestRunStatus = {
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+    NOT_STARTED: "NOT_STARTED",
+    SCHEDULED: "SCHEDULED",
+};
+export var AutomatedReasoningPolicyWorkflowTypeContent;
+(function (AutomatedReasoningPolicyWorkflowTypeContent) {
+    AutomatedReasoningPolicyWorkflowTypeContent.visit = (value, visitor) => {
+        if (value.documents !== undefined)
+            return visitor.documents(value.documents);
+        if (value.policyRepairAssets !== undefined)
+            return visitor.policyRepairAssets(value.policyRepairAssets);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AutomatedReasoningPolicyWorkflowTypeContent || (AutomatedReasoningPolicyWorkflowTypeContent = {}));
+export var EndpointConfig;
+(function (EndpointConfig) {
+    EndpointConfig.visit = (value, visitor) => {
+        if (value.sageMaker !== undefined)
+            return visitor.sageMaker(value.sageMaker);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(EndpointConfig || (EndpointConfig = {}));
+export const Status = {
+    INCOMPATIBLE_ENDPOINT: "INCOMPATIBLE_ENDPOINT",
+    REGISTERED: "REGISTERED",
+};
+export class ServiceUnavailableException extends __BaseException {
+    name = "ServiceUnavailableException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "ServiceUnavailableException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
+    }
+}
 export const CustomModelDeploymentStatus = {
     ACTIVE: "Active",
     CREATING: "Creating",
@@ -408,111 +609,531 @@ export const GuardrailWordAction = {
     BLOCK: "BLOCK",
     NONE: "NONE",
 };
-export const GuardrailManagedWordsType = {
-    PROFANITY: "PROFANITY",
-};
-export const GuardrailStatus = {
-    CREATING: "CREATING",
-    DELETING: "DELETING",
-    FAILED: "FAILED",
-    READY: "READY",
-    UPDATING: "UPDATING",
-    VERSIONING: "VERSIONING",
-};
-export var InferenceProfileModelSource;
-(function (InferenceProfileModelSource) {
-    InferenceProfileModelSource.visit = (value, visitor) => {
-        if (value.copyFrom !== undefined)
-            return visitor.copyFrom(value.copyFrom);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(InferenceProfileModelSource || (InferenceProfileModelSource = {}));
-export const InferenceProfileStatus = {
-    ACTIVE: "ACTIVE",
-};
-export const InferenceProfileType = {
-    APPLICATION: "APPLICATION",
-    SYSTEM_DEFINED: "SYSTEM_DEFINED",
-};
-export const ModelCopyJobStatus = {
-    COMPLETED: "Completed",
-    FAILED: "Failed",
-    IN_PROGRESS: "InProgress",
-};
-export const ModelImportJobStatus = {
-    COMPLETED: "Completed",
-    FAILED: "Failed",
-    IN_PROGRESS: "InProgress",
-};
-export const S3InputFormat = {
-    JSONL: "JSONL",
-};
-export var ModelInvocationJobInputDataConfig;
-(function (ModelInvocationJobInputDataConfig) {
-    ModelInvocationJobInputDataConfig.visit = (value, visitor) => {
-        if (value.s3InputDataConfig !== undefined)
-            return visitor.s3InputDataConfig(value.s3InputDataConfig);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(ModelInvocationJobInputDataConfig || (ModelInvocationJobInputDataConfig = {}));
-export var ModelInvocationJobOutputDataConfig;
-(function (ModelInvocationJobOutputDataConfig) {
-    ModelInvocationJobOutputDataConfig.visit = (value, visitor) => {
-        if (value.s3OutputDataConfig !== undefined)
-            return visitor.s3OutputDataConfig(value.s3OutputDataConfig);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(ModelInvocationJobOutputDataConfig || (ModelInvocationJobOutputDataConfig = {}));
-export const ModelInvocationJobStatus = {
-    COMPLETED: "Completed",
-    EXPIRED: "Expired",
-    FAILED: "Failed",
-    IN_PROGRESS: "InProgress",
-    PARTIALLY_COMPLETED: "PartiallyCompleted",
-    SCHEDULED: "Scheduled",
-    STOPPED: "Stopped",
-    STOPPING: "Stopping",
-    SUBMITTED: "Submitted",
-    VALIDATING: "Validating",
-};
-export const ModelCustomization = {
-    CONTINUED_PRE_TRAINING: "CONTINUED_PRE_TRAINING",
-    DISTILLATION: "DISTILLATION",
-    FINE_TUNING: "FINE_TUNING",
-};
-export const InferenceType = {
-    ON_DEMAND: "ON_DEMAND",
-    PROVISIONED: "PROVISIONED",
+export const AutomatedReasoningPolicyDefinitionRuleFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.expression && { expression: SENSITIVE_STRING }),
+    ...(obj.alternateExpression && { alternateExpression: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyDefinitionTypeValueFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyDefinitionTypeFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.values && {
+        values: obj.values.map((item) => AutomatedReasoningPolicyDefinitionTypeValueFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningPolicyDefinitionVariableFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.type && { type: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyDefinitionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.types && { types: obj.types.map((item) => AutomatedReasoningPolicyDefinitionTypeFilterSensitiveLog(item)) }),
+    ...(obj.rules && { rules: obj.rules.map((item) => AutomatedReasoningPolicyDefinitionRuleFilterSensitiveLog(item)) }),
+    ...(obj.variables && {
+        variables: obj.variables.map((item) => AutomatedReasoningPolicyDefinitionVariableFilterSensitiveLog(item)),
+    }),
+});
+export const CreateAutomatedReasoningPolicyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.policyDefinition && {
+        policyDefinition: AutomatedReasoningPolicyDefinitionFilterSensitiveLog(obj.policyDefinition),
+    }),
+});
+export const CreateAutomatedReasoningPolicyResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const CreateAutomatedReasoningPolicyTestCaseRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.guardContent && { guardContent: SENSITIVE_STRING }),
+    ...(obj.queryContent && { queryContent: SENSITIVE_STRING }),
+});
+export const CreateAutomatedReasoningPolicyVersionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const ExportAutomatedReasoningPolicyVersionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.policyDefinition && {
+        policyDefinition: AutomatedReasoningPolicyDefinitionFilterSensitiveLog(obj.policyDefinition),
+    }),
+});
+export const GetAutomatedReasoningPolicyResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyAddRuleAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.expression && { expression: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyAddRuleFromNaturalLanguageAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.naturalLanguage && { naturalLanguage: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyAddTypeAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.values && {
+        values: obj.values.map((item) => AutomatedReasoningPolicyDefinitionTypeValueFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningPolicyAddVariableAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.type && { type: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyDeleteTypeAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyDeleteVariableAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyIngestContentAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.content && { content: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyUpdateFromRuleFeedbackAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.feedback && { feedback: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyUpdateFromScenarioFeedbackAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.scenarioExpression && { scenarioExpression: SENSITIVE_STRING }),
+    ...(obj.feedback && { feedback: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyUpdateRuleAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.expression && { expression: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyAddTypeValueFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyUpdateTypeValueFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyTypeValueAnnotationFilterSensitiveLog = (obj) => {
+    if (obj.addTypeValue !== undefined)
+        return { addTypeValue: AutomatedReasoningPolicyAddTypeValueFilterSensitiveLog(obj.addTypeValue) };
+    if (obj.updateTypeValue !== undefined)
+        return { updateTypeValue: AutomatedReasoningPolicyUpdateTypeValueFilterSensitiveLog(obj.updateTypeValue) };
+    if (obj.deleteTypeValue !== undefined)
+        return { deleteTypeValue: obj.deleteTypeValue };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
 };
-export const ModelModality = {
-    EMBEDDING: "EMBEDDING",
-    IMAGE: "IMAGE",
-    TEXT: "TEXT",
+export const AutomatedReasoningPolicyUpdateTypeAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.newName && { newName: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+    ...(obj.values && {
+        values: obj.values.map((item) => AutomatedReasoningPolicyTypeValueAnnotationFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningPolicyUpdateVariableAnnotationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.newName && { newName: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyAnnotationFilterSensitiveLog = (obj) => {
+    if (obj.addType !== undefined)
+        return { addType: AutomatedReasoningPolicyAddTypeAnnotationFilterSensitiveLog(obj.addType) };
+    if (obj.updateType !== undefined)
+        return { updateType: AutomatedReasoningPolicyUpdateTypeAnnotationFilterSensitiveLog(obj.updateType) };
+    if (obj.deleteType !== undefined)
+        return { deleteType: AutomatedReasoningPolicyDeleteTypeAnnotationFilterSensitiveLog(obj.deleteType) };
+    if (obj.addVariable !== undefined)
+        return { addVariable: AutomatedReasoningPolicyAddVariableAnnotationFilterSensitiveLog(obj.addVariable) };
+    if (obj.updateVariable !== undefined)
+        return { updateVariable: AutomatedReasoningPolicyUpdateVariableAnnotationFilterSensitiveLog(obj.updateVariable) };
+    if (obj.deleteVariable !== undefined)
+        return { deleteVariable: AutomatedReasoningPolicyDeleteVariableAnnotationFilterSensitiveLog(obj.deleteVariable) };
+    if (obj.addRule !== undefined)
+        return { addRule: AutomatedReasoningPolicyAddRuleAnnotationFilterSensitiveLog(obj.addRule) };
+    if (obj.updateRule !== undefined)
+        return { updateRule: AutomatedReasoningPolicyUpdateRuleAnnotationFilterSensitiveLog(obj.updateRule) };
+    if (obj.deleteRule !== undefined)
+        return { deleteRule: obj.deleteRule };
+    if (obj.addRuleFromNaturalLanguage !== undefined)
+        return {
+            addRuleFromNaturalLanguage: AutomatedReasoningPolicyAddRuleFromNaturalLanguageAnnotationFilterSensitiveLog(obj.addRuleFromNaturalLanguage),
+        };
+    if (obj.updateFromRulesFeedback !== undefined)
+        return {
+            updateFromRulesFeedback: AutomatedReasoningPolicyUpdateFromRuleFeedbackAnnotationFilterSensitiveLog(obj.updateFromRulesFeedback),
+        };
+    if (obj.updateFromScenarioFeedback !== undefined)
+        return {
+            updateFromScenarioFeedback: AutomatedReasoningPolicyUpdateFromScenarioFeedbackAnnotationFilterSensitiveLog(obj.updateFromScenarioFeedback),
+        };
+    if (obj.ingestContent !== undefined)
+        return { ingestContent: AutomatedReasoningPolicyIngestContentAnnotationFilterSensitiveLog(obj.ingestContent) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
 };
-export const FoundationModelLifecycleStatus = {
-    ACTIVE: "ACTIVE",
-    LEGACY: "LEGACY",
+export const GetAutomatedReasoningPolicyAnnotationsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.annotations && {
+        annotations: obj.annotations.map((item) => AutomatedReasoningPolicyAnnotationFilterSensitiveLog(item)),
+    }),
+});
+export const GetAutomatedReasoningPolicyBuildWorkflowResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.documentName && { documentName: SENSITIVE_STRING }),
+    ...(obj.documentDescription && { documentDescription: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyAddRuleMutationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.rule && { rule: AutomatedReasoningPolicyDefinitionRuleFilterSensitiveLog(obj.rule) }),
+});
+export const AutomatedReasoningPolicyAddTypeMutationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.type && { type: AutomatedReasoningPolicyDefinitionTypeFilterSensitiveLog(obj.type) }),
+});
+export const AutomatedReasoningPolicyAddVariableMutationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.variable && { variable: AutomatedReasoningPolicyDefinitionVariableFilterSensitiveLog(obj.variable) }),
+});
+export const AutomatedReasoningPolicyDeleteTypeMutationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyDeleteVariableMutationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyUpdateRuleMutationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.rule && { rule: AutomatedReasoningPolicyDefinitionRuleFilterSensitiveLog(obj.rule) }),
+});
+export const AutomatedReasoningPolicyUpdateTypeMutationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.type && { type: AutomatedReasoningPolicyDefinitionTypeFilterSensitiveLog(obj.type) }),
+});
+export const AutomatedReasoningPolicyUpdateVariableMutationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.variable && { variable: AutomatedReasoningPolicyDefinitionVariableFilterSensitiveLog(obj.variable) }),
+});
+export const AutomatedReasoningPolicyMutationFilterSensitiveLog = (obj) => {
+    if (obj.addType !== undefined)
+        return { addType: AutomatedReasoningPolicyAddTypeMutationFilterSensitiveLog(obj.addType) };
+    if (obj.updateType !== undefined)
+        return { updateType: AutomatedReasoningPolicyUpdateTypeMutationFilterSensitiveLog(obj.updateType) };
+    if (obj.deleteType !== undefined)
+        return { deleteType: AutomatedReasoningPolicyDeleteTypeMutationFilterSensitiveLog(obj.deleteType) };
+    if (obj.addVariable !== undefined)
+        return { addVariable: AutomatedReasoningPolicyAddVariableMutationFilterSensitiveLog(obj.addVariable) };
+    if (obj.updateVariable !== undefined)
+        return { updateVariable: AutomatedReasoningPolicyUpdateVariableMutationFilterSensitiveLog(obj.updateVariable) };
+    if (obj.deleteVariable !== undefined)
+        return { deleteVariable: AutomatedReasoningPolicyDeleteVariableMutationFilterSensitiveLog(obj.deleteVariable) };
+    if (obj.addRule !== undefined)
+        return { addRule: AutomatedReasoningPolicyAddRuleMutationFilterSensitiveLog(obj.addRule) };
+    if (obj.updateRule !== undefined)
+        return { updateRule: AutomatedReasoningPolicyUpdateRuleMutationFilterSensitiveLog(obj.updateRule) };
+    if (obj.deleteRule !== undefined)
+        return { deleteRule: obj.deleteRule };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
 };
-export const PromptRouterStatus = {
-    AVAILABLE: "AVAILABLE",
+export const AutomatedReasoningPolicyBuildStepContextFilterSensitiveLog = (obj) => {
+    if (obj.planning !== undefined)
+        return { planning: obj.planning };
+    if (obj.mutation !== undefined)
+        return { mutation: AutomatedReasoningPolicyMutationFilterSensitiveLog(obj.mutation) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
 };
-export const PromptRouterType = {
-    CUSTOM: "custom",
-    DEFAULT: "default",
+export const AutomatedReasoningPolicyDefinitionElementFilterSensitiveLog = (obj) => {
+    if (obj.policyDefinitionVariable !== undefined)
+        return {
+            policyDefinitionVariable: AutomatedReasoningPolicyDefinitionVariableFilterSensitiveLog(obj.policyDefinitionVariable),
+        };
+    if (obj.policyDefinitionType !== undefined)
+        return { policyDefinitionType: AutomatedReasoningPolicyDefinitionTypeFilterSensitiveLog(obj.policyDefinitionType) };
+    if (obj.policyDefinitionRule !== undefined)
+        return { policyDefinitionRule: AutomatedReasoningPolicyDefinitionRuleFilterSensitiveLog(obj.policyDefinitionRule) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
 };
-export const CommitmentDuration = {
-    ONE_MONTH: "OneMonth",
-    SIX_MONTHS: "SixMonths",
+export const AutomatedReasoningPolicyBuildStepFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.context && { context: AutomatedReasoningPolicyBuildStepContextFilterSensitiveLog(obj.context) }),
+    ...(obj.priorElement && {
+        priorElement: AutomatedReasoningPolicyDefinitionElementFilterSensitiveLog(obj.priorElement),
+    }),
+});
+export const AutomatedReasoningPolicyBuildLogEntryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.annotation && { annotation: AutomatedReasoningPolicyAnnotationFilterSensitiveLog(obj.annotation) }),
+    ...(obj.buildSteps && {
+        buildSteps: obj.buildSteps.map((item) => AutomatedReasoningPolicyBuildStepFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningPolicyBuildLogFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.entries && {
+        entries: obj.entries.map((item) => AutomatedReasoningPolicyBuildLogEntryFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningPolicyDisjointRuleSetFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.variables && { variables: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyDefinitionTypeValuePairFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.typeName && { typeName: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyDefinitionQualityReportFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.unusedTypes && { unusedTypes: SENSITIVE_STRING }),
+    ...(obj.unusedTypeValues && {
+        unusedTypeValues: obj.unusedTypeValues.map((item) => AutomatedReasoningPolicyDefinitionTypeValuePairFilterSensitiveLog(item)),
+    }),
+    ...(obj.unusedVariables && { unusedVariables: SENSITIVE_STRING }),
+    ...(obj.disjointRuleSets && {
+        disjointRuleSets: obj.disjointRuleSets.map((item) => AutomatedReasoningPolicyDisjointRuleSetFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningPolicyBuildResultAssetsFilterSensitiveLog = (obj) => {
+    if (obj.policyDefinition !== undefined)
+        return { policyDefinition: AutomatedReasoningPolicyDefinitionFilterSensitiveLog(obj.policyDefinition) };
+    if (obj.qualityReport !== undefined)
+        return { qualityReport: AutomatedReasoningPolicyDefinitionQualityReportFilterSensitiveLog(obj.qualityReport) };
+    if (obj.buildLog !== undefined)
+        return { buildLog: AutomatedReasoningPolicyBuildLogFilterSensitiveLog(obj.buildLog) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
 };
-export const ProvisionedModelStatus = {
-    CREATING: "Creating",
-    FAILED: "Failed",
-    IN_SERVICE: "InService",
-    UPDATING: "Updating",
+export const GetAutomatedReasoningPolicyBuildWorkflowResultAssetsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.buildWorkflowAssets && {
+        buildWorkflowAssets: AutomatedReasoningPolicyBuildResultAssetsFilterSensitiveLog(obj.buildWorkflowAssets),
+    }),
+});
+export const AutomatedReasoningPolicyScenarioFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.expression && { expression: SENSITIVE_STRING }),
+    ...(obj.alternateExpression && { alternateExpression: SENSITIVE_STRING }),
+});
+export const GetAutomatedReasoningPolicyNextScenarioResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.scenario && { scenario: AutomatedReasoningPolicyScenarioFilterSensitiveLog(obj.scenario) }),
+});
+export const AutomatedReasoningPolicyTestCaseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.guardContent && { guardContent: SENSITIVE_STRING }),
+    ...(obj.queryContent && { queryContent: SENSITIVE_STRING }),
+});
+export const GetAutomatedReasoningPolicyTestCaseResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.testCase && { testCase: AutomatedReasoningPolicyTestCaseFilterSensitiveLog(obj.testCase) }),
+});
+export const AutomatedReasoningLogicStatementFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.logic && { logic: SENSITIVE_STRING }),
+    ...(obj.naturalLanguage && { naturalLanguage: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningCheckLogicWarningFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.premises && {
+        premises: obj.premises.map((item) => AutomatedReasoningLogicStatementFilterSensitiveLog(item)),
+    }),
+    ...(obj.claims && { claims: obj.claims.map((item) => AutomatedReasoningLogicStatementFilterSensitiveLog(item)) }),
+});
+export const AutomatedReasoningCheckInputTextReferenceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.text && { text: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningCheckTranslationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.premises && {
+        premises: obj.premises.map((item) => AutomatedReasoningLogicStatementFilterSensitiveLog(item)),
+    }),
+    ...(obj.claims && { claims: obj.claims.map((item) => AutomatedReasoningLogicStatementFilterSensitiveLog(item)) }),
+    ...(obj.untranslatedPremises && {
+        untranslatedPremises: obj.untranslatedPremises.map((item) => AutomatedReasoningCheckInputTextReferenceFilterSensitiveLog(item)),
+    }),
+    ...(obj.untranslatedClaims && {
+        untranslatedClaims: obj.untranslatedClaims.map((item) => AutomatedReasoningCheckInputTextReferenceFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningCheckImpossibleFindingFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.translation && { translation: AutomatedReasoningCheckTranslationFilterSensitiveLog(obj.translation) }),
+    ...(obj.logicWarning && { logicWarning: AutomatedReasoningCheckLogicWarningFilterSensitiveLog(obj.logicWarning) }),
+});
+export const AutomatedReasoningCheckInvalidFindingFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.translation && { translation: AutomatedReasoningCheckTranslationFilterSensitiveLog(obj.translation) }),
+    ...(obj.logicWarning && { logicWarning: AutomatedReasoningCheckLogicWarningFilterSensitiveLog(obj.logicWarning) }),
+});
+export const AutomatedReasoningCheckScenarioFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.statements && {
+        statements: obj.statements.map((item) => AutomatedReasoningLogicStatementFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningCheckSatisfiableFindingFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.translation && { translation: AutomatedReasoningCheckTranslationFilterSensitiveLog(obj.translation) }),
+    ...(obj.claimsTrueScenario && {
+        claimsTrueScenario: AutomatedReasoningCheckScenarioFilterSensitiveLog(obj.claimsTrueScenario),
+    }),
+    ...(obj.claimsFalseScenario && {
+        claimsFalseScenario: AutomatedReasoningCheckScenarioFilterSensitiveLog(obj.claimsFalseScenario),
+    }),
+    ...(obj.logicWarning && { logicWarning: AutomatedReasoningCheckLogicWarningFilterSensitiveLog(obj.logicWarning) }),
+});
+export const AutomatedReasoningCheckTranslationOptionFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AutomatedReasoningCheckTranslationAmbiguousFindingFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AutomatedReasoningCheckValidFindingFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.translation && { translation: AutomatedReasoningCheckTranslationFilterSensitiveLog(obj.translation) }),
+    ...(obj.claimsTrueScenario && {
+        claimsTrueScenario: AutomatedReasoningCheckScenarioFilterSensitiveLog(obj.claimsTrueScenario),
+    }),
+    ...(obj.logicWarning && { logicWarning: AutomatedReasoningCheckLogicWarningFilterSensitiveLog(obj.logicWarning) }),
+});
+export const AutomatedReasoningCheckFindingFilterSensitiveLog = (obj) => {
+    if (obj.valid !== undefined)
+        return { valid: AutomatedReasoningCheckValidFindingFilterSensitiveLog(obj.valid) };
+    if (obj.invalid !== undefined)
+        return { invalid: AutomatedReasoningCheckInvalidFindingFilterSensitiveLog(obj.invalid) };
+    if (obj.satisfiable !== undefined)
+        return { satisfiable: AutomatedReasoningCheckSatisfiableFindingFilterSensitiveLog(obj.satisfiable) };
+    if (obj.impossible !== undefined)
+        return { impossible: AutomatedReasoningCheckImpossibleFindingFilterSensitiveLog(obj.impossible) };
+    if (obj.translationAmbiguous !== undefined)
+        return {
+            translationAmbiguous: AutomatedReasoningCheckTranslationAmbiguousFindingFilterSensitiveLog(obj.translationAmbiguous),
+        };
+    if (obj.tooComplex !== undefined)
+        return { tooComplex: obj.tooComplex };
+    if (obj.noTranslations !== undefined)
+        return { noTranslations: obj.noTranslations };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
 };
-export const SortByProvisionedModels = {
-    CREATION_TIME: "CreationTime",
+export const AutomatedReasoningPolicyTestResultFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.testCase && { testCase: AutomatedReasoningPolicyTestCaseFilterSensitiveLog(obj.testCase) }),
+    ...(obj.testFindings && {
+        testFindings: obj.testFindings.map((item) => AutomatedReasoningCheckFindingFilterSensitiveLog(item)),
+    }),
+});
+export const GetAutomatedReasoningPolicyTestResultResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.testResult && { testResult: AutomatedReasoningPolicyTestResultFilterSensitiveLog(obj.testResult) }),
+});
+export const AutomatedReasoningPolicySummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const ListAutomatedReasoningPoliciesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.automatedReasoningPolicySummaries && {
+        automatedReasoningPolicySummaries: obj.automatedReasoningPolicySummaries.map((item) => AutomatedReasoningPolicySummaryFilterSensitiveLog(item)),
+    }),
+});
+export const ListAutomatedReasoningPolicyTestCasesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.testCases && {
+        testCases: obj.testCases.map((item) => AutomatedReasoningPolicyTestCaseFilterSensitiveLog(item)),
+    }),
+});
+export const ListAutomatedReasoningPolicyTestResultsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.testResults && {
+        testResults: obj.testResults.map((item) => AutomatedReasoningPolicyTestResultFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningPolicyBuildWorkflowDocumentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.documentName && { documentName: SENSITIVE_STRING }),
+    ...(obj.documentDescription && { documentDescription: SENSITIVE_STRING }),
+});
+export const AutomatedReasoningPolicyBuildWorkflowRepairContentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.annotations && {
+        annotations: obj.annotations.map((item) => AutomatedReasoningPolicyAnnotationFilterSensitiveLog(item)),
+    }),
+});
+export const AutomatedReasoningPolicyWorkflowTypeContentFilterSensitiveLog = (obj) => {
+    if (obj.documents !== undefined)
+        return {
+            documents: obj.documents.map((item) => AutomatedReasoningPolicyBuildWorkflowDocumentFilterSensitiveLog(item)),
+        };
+    if (obj.policyRepairAssets !== undefined)
+        return {
+            policyRepairAssets: AutomatedReasoningPolicyBuildWorkflowRepairContentFilterSensitiveLog(obj.policyRepairAssets),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
 };
+export const AutomatedReasoningPolicyBuildWorkflowSourceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.policyDefinition && {
+        policyDefinition: AutomatedReasoningPolicyDefinitionFilterSensitiveLog(obj.policyDefinition),
+    }),
+    ...(obj.workflowContent && {
+        workflowContent: AutomatedReasoningPolicyWorkflowTypeContentFilterSensitiveLog(obj.workflowContent),
+    }),
+});
+export const StartAutomatedReasoningPolicyBuildWorkflowRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.sourceContent && {
+        sourceContent: AutomatedReasoningPolicyBuildWorkflowSourceFilterSensitiveLog(obj.sourceContent),
+    }),
+});
+export const UpdateAutomatedReasoningPolicyRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.policyDefinition && {
+        policyDefinition: AutomatedReasoningPolicyDefinitionFilterSensitiveLog(obj.policyDefinition),
+    }),
+    ...(obj.name && { name: SENSITIVE_STRING }),
+    ...(obj.description && { description: SENSITIVE_STRING }),
+});
+export const UpdateAutomatedReasoningPolicyResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.name && { name: SENSITIVE_STRING }),
+});
+export const UpdateAutomatedReasoningPolicyAnnotationsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.annotations && {
+        annotations: obj.annotations.map((item) => AutomatedReasoningPolicyAnnotationFilterSensitiveLog(item)),
+    }),
+});
+export const UpdateAutomatedReasoningPolicyTestCaseRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.guardContent && { guardContent: SENSITIVE_STRING }),
+    ...(obj.queryContent && { queryContent: SENSITIVE_STRING }),
+});
 export const RequestMetadataBaseFiltersFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.equals && { equals: SENSITIVE_STRING }),
@@ -761,197 +1382,3 @@ export const GuardrailTopicPolicyConfigFilterSensitiveLog = (obj) => ({
     }),
     ...(obj.tierConfig && { tierConfig: GuardrailTopicsTierConfigFilterSensitiveLog(obj.tierConfig) }),
 });
-export const GuardrailManagedWordsConfigFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.inputAction && { inputAction: SENSITIVE_STRING }),
-    ...(obj.outputAction && { outputAction: SENSITIVE_STRING }),
-});
-export const GuardrailWordConfigFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.inputAction && { inputAction: SENSITIVE_STRING }),
-    ...(obj.outputAction && { outputAction: SENSITIVE_STRING }),
-});
-export const GuardrailWordPolicyConfigFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.wordsConfig && { wordsConfig: obj.wordsConfig.map((item) => GuardrailWordConfigFilterSensitiveLog(item)) }),
-    ...(obj.managedWordListsConfig && {
-        managedWordListsConfig: obj.managedWordListsConfig.map((item) => GuardrailManagedWordsConfigFilterSensitiveLog(item)),
-    }),
-});
-export const CreateGuardrailRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.name && { name: SENSITIVE_STRING }),
-    ...(obj.description && { description: SENSITIVE_STRING }),
-    ...(obj.topicPolicyConfig && {
-        topicPolicyConfig: GuardrailTopicPolicyConfigFilterSensitiveLog(obj.topicPolicyConfig),
-    }),
-    ...(obj.contentPolicyConfig && {
-        contentPolicyConfig: GuardrailContentPolicyConfigFilterSensitiveLog(obj.contentPolicyConfig),
-    }),
-    ...(obj.wordPolicyConfig && { wordPolicyConfig: GuardrailWordPolicyConfigFilterSensitiveLog(obj.wordPolicyConfig) }),
-    ...(obj.contextualGroundingPolicyConfig && {
-        contextualGroundingPolicyConfig: GuardrailContextualGroundingPolicyConfigFilterSensitiveLog(obj.contextualGroundingPolicyConfig),
-    }),
-    ...(obj.blockedInputMessaging && { blockedInputMessaging: SENSITIVE_STRING }),
-    ...(obj.blockedOutputsMessaging && { blockedOutputsMessaging: SENSITIVE_STRING }),
-});
-export const CreateGuardrailVersionRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: SENSITIVE_STRING }),
-});
-export const GuardrailContentFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.inputModalities && { inputModalities: SENSITIVE_STRING }),
-    ...(obj.outputModalities && { outputModalities: SENSITIVE_STRING }),
-    ...(obj.inputAction && { inputAction: SENSITIVE_STRING }),
-    ...(obj.outputAction && { outputAction: SENSITIVE_STRING }),
-});
-export const GuardrailContentFiltersTierFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.tierName && { tierName: SENSITIVE_STRING }),
-});
-export const GuardrailContentPolicyFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.filters && { filters: obj.filters.map((item) => GuardrailContentFilterFilterSensitiveLog(item)) }),
-    ...(obj.tier && { tier: GuardrailContentFiltersTierFilterSensitiveLog(obj.tier) }),
-});
-export const GuardrailContextualGroundingFilterFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.action && { action: SENSITIVE_STRING }),
-});
-export const GuardrailContextualGroundingPolicyFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.filters && {
-        filters: obj.filters.map((item) => GuardrailContextualGroundingFilterFilterSensitiveLog(item)),
-    }),
-});
-export const GuardrailTopicsTierFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.tierName && { tierName: SENSITIVE_STRING }),
-});
-export const GuardrailTopicFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.name && { name: SENSITIVE_STRING }),
-    ...(obj.definition && { definition: SENSITIVE_STRING }),
-    ...(obj.examples && { examples: SENSITIVE_STRING }),
-    ...(obj.inputAction && { inputAction: SENSITIVE_STRING }),
-    ...(obj.outputAction && { outputAction: SENSITIVE_STRING }),
-});
-export const GuardrailTopicPolicyFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.topics && { topics: obj.topics.map((item) => GuardrailTopicFilterSensitiveLog(item)) }),
-    ...(obj.tier && { tier: GuardrailTopicsTierFilterSensitiveLog(obj.tier) }),
-});
-export const GuardrailManagedWordsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.inputAction && { inputAction: SENSITIVE_STRING }),
-    ...(obj.outputAction && { outputAction: SENSITIVE_STRING }),
-});
-export const GuardrailWordFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.inputAction && { inputAction: SENSITIVE_STRING }),
-    ...(obj.outputAction && { outputAction: SENSITIVE_STRING }),
-});
-export const GuardrailWordPolicyFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.words && { words: obj.words.map((item) => GuardrailWordFilterSensitiveLog(item)) }),
-    ...(obj.managedWordLists && {
-        managedWordLists: obj.managedWordLists.map((item) => GuardrailManagedWordsFilterSensitiveLog(item)),
-    }),
-});
-export const GetGuardrailResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.name && { name: SENSITIVE_STRING }),
-    ...(obj.description && { description: SENSITIVE_STRING }),
-    ...(obj.topicPolicy && { topicPolicy: GuardrailTopicPolicyFilterSensitiveLog(obj.topicPolicy) }),
-    ...(obj.contentPolicy && { contentPolicy: GuardrailContentPolicyFilterSensitiveLog(obj.contentPolicy) }),
-    ...(obj.wordPolicy && { wordPolicy: GuardrailWordPolicyFilterSensitiveLog(obj.wordPolicy) }),
-    ...(obj.contextualGroundingPolicy && {
-        contextualGroundingPolicy: GuardrailContextualGroundingPolicyFilterSensitiveLog(obj.contextualGroundingPolicy),
-    }),
-    ...(obj.statusReasons && { statusReasons: SENSITIVE_STRING }),
-    ...(obj.failureRecommendations && { failureRecommendations: SENSITIVE_STRING }),
-    ...(obj.blockedInputMessaging && { blockedInputMessaging: SENSITIVE_STRING }),
-    ...(obj.blockedOutputsMessaging && { blockedOutputsMessaging: SENSITIVE_STRING }),
-});
-export const GuardrailSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.name && { name: SENSITIVE_STRING }),
-    ...(obj.description && { description: SENSITIVE_STRING }),
-});
-export const ListGuardrailsResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.guardrails && { guardrails: obj.guardrails.map((item) => GuardrailSummaryFilterSensitiveLog(item)) }),
-});
-export const UpdateGuardrailRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.name && { name: SENSITIVE_STRING }),
-    ...(obj.description && { description: SENSITIVE_STRING }),
-    ...(obj.topicPolicyConfig && {
-        topicPolicyConfig: GuardrailTopicPolicyConfigFilterSensitiveLog(obj.topicPolicyConfig),
-    }),
-    ...(obj.contentPolicyConfig && {
-        contentPolicyConfig: GuardrailContentPolicyConfigFilterSensitiveLog(obj.contentPolicyConfig),
-    }),
-    ...(obj.wordPolicyConfig && { wordPolicyConfig: GuardrailWordPolicyConfigFilterSensitiveLog(obj.wordPolicyConfig) }),
-    ...(obj.contextualGroundingPolicyConfig && {
-        contextualGroundingPolicyConfig: GuardrailContextualGroundingPolicyConfigFilterSensitiveLog(obj.contextualGroundingPolicyConfig),
-    }),
-    ...(obj.blockedInputMessaging && { blockedInputMessaging: SENSITIVE_STRING }),
-    ...(obj.blockedOutputsMessaging && { blockedOutputsMessaging: SENSITIVE_STRING }),
-});
-export const CreateInferenceProfileRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: SENSITIVE_STRING }),
-    ...(obj.modelSource && { modelSource: obj.modelSource }),
-});
-export const GetInferenceProfileResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: SENSITIVE_STRING }),
-});
-export const InferenceProfileSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: SENSITIVE_STRING }),
-});
-export const ListInferenceProfilesResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.inferenceProfileSummaries && {
-        inferenceProfileSummaries: obj.inferenceProfileSummaries.map((item) => InferenceProfileSummaryFilterSensitiveLog(item)),
-    }),
-});
-export const GetModelInvocationJobResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.message && { message: SENSITIVE_STRING }),
-    ...(obj.inputDataConfig && { inputDataConfig: obj.inputDataConfig }),
-    ...(obj.outputDataConfig && { outputDataConfig: obj.outputDataConfig }),
-});
-export const ModelInvocationJobSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.message && { message: SENSITIVE_STRING }),
-    ...(obj.inputDataConfig && { inputDataConfig: obj.inputDataConfig }),
-    ...(obj.outputDataConfig && { outputDataConfig: obj.outputDataConfig }),
-});
-export const ListModelInvocationJobsResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.invocationJobSummaries && {
-        invocationJobSummaries: obj.invocationJobSummaries.map((item) => ModelInvocationJobSummaryFilterSensitiveLog(item)),
-    }),
-});
-export const CreatePromptRouterRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: SENSITIVE_STRING }),
-});
-export const GetPromptRouterResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: SENSITIVE_STRING }),
-});
-export const PromptRouterSummaryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: SENSITIVE_STRING }),
-});
-export const ListPromptRoutersResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.promptRouterSummaries && {
-        promptRouterSummaries: obj.promptRouterSummaries.map((item) => PromptRouterSummaryFilterSensitiveLog(item)),
-    }),
-});