@quba/sensitive-data-protection 0.0.5 → 0.0.6

package/dist/index.cjs

@@ -264,96 +264,96 @@ var TextApiResponse = class {
 };
 
 //#endregion
-//#region src/models/Targets.ts
+//#region src/models/Entities.ts
 /**
-* Check if a given object implements the Targets interface.
+* Check if a given object implements the Entities interface.
 */
-function instanceOfTargets(value) {
+function instanceOfEntities(value) {
 	return true;
 }
-function TargetsFromJSON(json) {
-	return TargetsFromJSONTyped(json, false);
+function EntitiesFromJSON(json) {
+	return EntitiesFromJSONTyped(json, false);
 }
-function TargetsFromJSONTyped(json, ignoreDiscriminator) {
+function EntitiesFromJSONTyped(json, ignoreDiscriminator) {
 	return json;
 }
-function TargetsToJSON(json) {
-	return TargetsToJSONTyped(json, false);
+function EntitiesToJSON(json) {
+	return EntitiesToJSONTyped(json, false);
 }
-function TargetsToJSONTyped(value, ignoreDiscriminator = false) {
+function EntitiesToJSONTyped(value, ignoreDiscriminator = false) {
 	return value;
 }
 
 //#endregion
-//#region src/models/EncryptTransformation.ts
+//#region src/models/EncryptRule.ts
 /**
 * @export
 */
-const EncryptTransformationIdEnum = { encrypt: "encrypt" };
+const EncryptRuleTypeEnum = { encrypt: "encrypt" };
 /**
-* Check if a given object implements the EncryptTransformation interface.
+* Check if a given object implements the EncryptRule interface.
 */
-function instanceOfEncryptTransformation(value) {
-	if (!("targets" in value) || value["targets"] === void 0) return false;
+function instanceOfEncryptRule(value) {
+	if (!("entities" in value) || value["entities"] === void 0) return false;
 	return true;
 }
-function EncryptTransformationFromJSON(json) {
-	return EncryptTransformationFromJSONTyped(json, false);
+function EncryptRuleFromJSON(json) {
+	return EncryptRuleFromJSONTyped(json, false);
 }
-function EncryptTransformationFromJSONTyped(json, ignoreDiscriminator) {
+function EncryptRuleFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
-		"id": json["id"] == null ? void 0 : json["id"],
-		"targets": TargetsFromJSON(json["targets"]),
+		"type": json["type"] == null ? void 0 : json["type"],
+		"entities": EntitiesFromJSON(json["entities"]),
 		"key": json["key"] == null ? void 0 : json["key"]
 	};
 }
-function EncryptTransformationToJSON(json) {
-	return EncryptTransformationToJSONTyped(json, false);
+function EncryptRuleToJSON(json) {
+	return EncryptRuleToJSONTyped(json, false);
 }
-function EncryptTransformationToJSONTyped(value, ignoreDiscriminator = false) {
+function EncryptRuleToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
-		"id": value["id"],
-		"targets": TargetsToJSON(value["targets"]),
+		"type": value["type"],
+		"entities": EntitiesToJSON(value["entities"]),
 		"key": value["key"]
 	};
 }
 
 //#endregion
-//#region src/models/MaskTransformation.ts
+//#region src/models/MaskRule.ts
 /**
 * @export
 */
-const MaskTransformationIdEnum = { mask: "mask" };
+const MaskRuleTypeEnum = { mask: "mask" };
 /**
-* Check if a given object implements the MaskTransformation interface.
+* Check if a given object implements the MaskRule interface.
 */
-function instanceOfMaskTransformation(value) {
-	if (!("targets" in value) || value["targets"] === void 0) return false;
+function instanceOfMaskRule(value) {
+	if (!("entities" in value) || value["entities"] === void 0) return false;
 	return true;
 }
-function MaskTransformationFromJSON(json) {
-	return MaskTransformationFromJSONTyped(json, false);
+function MaskRuleFromJSON(json) {
+	return MaskRuleFromJSONTyped(json, false);
 }
-function MaskTransformationFromJSONTyped(json, ignoreDiscriminator) {
+function MaskRuleFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
-		"id": json["id"] == null ? void 0 : json["id"],
-		"targets": TargetsFromJSON(json["targets"]),
+		"type": json["type"] == null ? void 0 : json["type"],
+		"entities": EntitiesFromJSON(json["entities"]),
 		"masking_char": json["masking_char"] == null ? void 0 : json["masking_char"],
 		"chars_to_mask": json["chars_to_mask"] == null ? void 0 : json["chars_to_mask"],
 		"from_end": json["from_end"] == null ? void 0 : json["from_end"]
 	};
 }
-function MaskTransformationToJSON(json) {
-	return MaskTransformationToJSONTyped(json, false);
+function MaskRuleToJSON(json) {
+	return MaskRuleToJSONTyped(json, false);
 }
-function MaskTransformationToJSONTyped(value, ignoreDiscriminator = false) {
+function MaskRuleToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
-		"id": value["id"],
-		"targets": TargetsToJSON(value["targets"]),
+		"type": value["type"],
+		"entities": EntitiesToJSON(value["entities"]),
 		"masking_char": value["masking_char"],
 		"chars_to_mask": value["chars_to_mask"],
 		"from_end": value["from_end"]
@@ -361,172 +361,172 @@ function MaskTransformationToJSONTyped(value, ignoreDiscriminator = false) {
 }
 
 //#endregion
-//#region src/models/RedactTransformation.ts
+//#region src/models/RedactRule.ts
 /**
 * @export
 */
-const RedactTransformationIdEnum = { redact: "redact" };
+const RedactRuleTypeEnum = { redact: "redact" };
 /**
-* Check if a given object implements the RedactTransformation interface.
+* Check if a given object implements the RedactRule interface.
 */
-function instanceOfRedactTransformation(value) {
-	if (!("targets" in value) || value["targets"] === void 0) return false;
+function instanceOfRedactRule(value) {
+	if (!("entities" in value) || value["entities"] === void 0) return false;
 	return true;
 }
-function RedactTransformationFromJSON(json) {
-	return RedactTransformationFromJSONTyped(json, false);
+function RedactRuleFromJSON(json) {
+	return RedactRuleFromJSONTyped(json, false);
 }
-function RedactTransformationFromJSONTyped(json, ignoreDiscriminator) {
+function RedactRuleFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
-		"id": json["id"] == null ? void 0 : json["id"],
-		"targets": TargetsFromJSON(json["targets"])
+		"type": json["type"] == null ? void 0 : json["type"],
+		"entities": EntitiesFromJSON(json["entities"])
 	};
 }
-function RedactTransformationToJSON(json) {
-	return RedactTransformationToJSONTyped(json, false);
+function RedactRuleToJSON(json) {
+	return RedactRuleToJSONTyped(json, false);
 }
-function RedactTransformationToJSONTyped(value, ignoreDiscriminator = false) {
+function RedactRuleToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
-		"id": value["id"],
-		"targets": TargetsToJSON(value["targets"])
+		"type": value["type"],
+		"entities": EntitiesToJSON(value["entities"])
 	};
 }
 
 //#endregion
-//#region src/models/ReplaceTransformation.ts
+//#region src/models/ReplaceRule.ts
 /**
 * @export
 */
-const ReplaceTransformationIdEnum = { replace: "replace" };
+const ReplaceRuleTypeEnum = { replace: "replace" };
 /**
-* Check if a given object implements the ReplaceTransformation interface.
+* Check if a given object implements the ReplaceRule interface.
 */
-function instanceOfReplaceTransformation(value) {
-	if (!("targets" in value) || value["targets"] === void 0) return false;
+function instanceOfReplaceRule(value) {
+	if (!("entities" in value) || value["entities"] === void 0) return false;
 	return true;
 }
-function ReplaceTransformationFromJSON(json) {
-	return ReplaceTransformationFromJSONTyped(json, false);
+function ReplaceRuleFromJSON(json) {
+	return ReplaceRuleFromJSONTyped(json, false);
 }
-function ReplaceTransformationFromJSONTyped(json, ignoreDiscriminator) {
+function ReplaceRuleFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
-		"id": json["id"] == null ? void 0 : json["id"],
-		"targets": TargetsFromJSON(json["targets"]),
+		"type": json["type"] == null ? void 0 : json["type"],
+		"entities": EntitiesFromJSON(json["entities"]),
 		"replacement": json["replacement"] == null ? void 0 : json["replacement"]
 	};
 }
-function ReplaceTransformationToJSON(json) {
-	return ReplaceTransformationToJSONTyped(json, false);
+function ReplaceRuleToJSON(json) {
+	return ReplaceRuleToJSONTyped(json, false);
 }
-function ReplaceTransformationToJSONTyped(value, ignoreDiscriminator = false) {
+function ReplaceRuleToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
-		"id": value["id"],
-		"targets": TargetsToJSON(value["targets"]),
+		"type": value["type"],
+		"entities": EntitiesToJSON(value["entities"]),
 		"replacement": value["replacement"]
 	};
 }
 
 //#endregion
-//#region src/models/SHA256Transformation.ts
+//#region src/models/SHA256Rule.ts
 /**
 * @export
 */
-const SHA256TransformationIdEnum = { sha256: "sha256" };
+const SHA256RuleTypeEnum = { sha256: "sha256" };
 /**
-* Check if a given object implements the SHA256Transformation interface.
+* Check if a given object implements the SHA256Rule interface.
 */
-function instanceOfSHA256Transformation(value) {
-	if (!("targets" in value) || value["targets"] === void 0) return false;
+function instanceOfSHA256Rule(value) {
+	if (!("entities" in value) || value["entities"] === void 0) return false;
 	return true;
 }
-function SHA256TransformationFromJSON(json) {
-	return SHA256TransformationFromJSONTyped(json, false);
+function SHA256RuleFromJSON(json) {
+	return SHA256RuleFromJSONTyped(json, false);
 }
-function SHA256TransformationFromJSONTyped(json, ignoreDiscriminator) {
+function SHA256RuleFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
-		"id": json["id"] == null ? void 0 : json["id"],
-		"targets": TargetsFromJSON(json["targets"])
+		"type": json["type"] == null ? void 0 : json["type"],
+		"entities": EntitiesFromJSON(json["entities"])
 	};
 }
-function SHA256TransformationToJSON(json) {
-	return SHA256TransformationToJSONTyped(json, false);
+function SHA256RuleToJSON(json) {
+	return SHA256RuleToJSONTyped(json, false);
 }
-function SHA256TransformationToJSONTyped(value, ignoreDiscriminator = false) {
+function SHA256RuleToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
-		"id": value["id"],
-		"targets": TargetsToJSON(value["targets"])
+		"type": value["type"],
+		"entities": EntitiesToJSON(value["entities"])
 	};
 }
 
 //#endregion
-//#region src/models/SHA512Transformation.ts
+//#region src/models/SHA512Rule.ts
 /**
 * @export
 */
-const SHA512TransformationIdEnum = { sha512: "sha512" };
+const SHA512RuleTypeEnum = { sha512: "sha512" };
 /**
-* Check if a given object implements the SHA512Transformation interface.
+* Check if a given object implements the SHA512Rule interface.
 */
-function instanceOfSHA512Transformation(value) {
-	if (!("targets" in value) || value["targets"] === void 0) return false;
+function instanceOfSHA512Rule(value) {
+	if (!("entities" in value) || value["entities"] === void 0) return false;
 	return true;
 }
-function SHA512TransformationFromJSON(json) {
-	return SHA512TransformationFromJSONTyped(json, false);
+function SHA512RuleFromJSON(json) {
+	return SHA512RuleFromJSONTyped(json, false);
 }
-function SHA512TransformationFromJSONTyped(json, ignoreDiscriminator) {
+function SHA512RuleFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
-		"id": json["id"] == null ? void 0 : json["id"],
-		"targets": TargetsFromJSON(json["targets"])
+		"type": json["type"] == null ? void 0 : json["type"],
+		"entities": EntitiesFromJSON(json["entities"])
 	};
 }
-function SHA512TransformationToJSON(json) {
-	return SHA512TransformationToJSONTyped(json, false);
+function SHA512RuleToJSON(json) {
+	return SHA512RuleToJSONTyped(json, false);
 }
-function SHA512TransformationToJSONTyped(value, ignoreDiscriminator = false) {
+function SHA512RuleToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
-		"id": value["id"],
-		"targets": TargetsToJSON(value["targets"])
+		"type": value["type"],
+		"entities": EntitiesToJSON(value["entities"])
 	};
 }
 
 //#endregion
-//#region src/models/AnonymizeRequestBodyTransformationsInner.ts
-function AnonymizeRequestBodyTransformationsInnerFromJSON(json) {
-	return AnonymizeRequestBodyTransformationsInnerFromJSONTyped(json, false);
+//#region src/models/AnonymizeRequestBodyRulesInner.ts
+function AnonymizeRequestBodyRulesInnerFromJSON(json) {
+	return AnonymizeRequestBodyRulesInnerFromJSONTyped(json, false);
 }
-function AnonymizeRequestBodyTransformationsInnerFromJSONTyped(json, ignoreDiscriminator) {
+function AnonymizeRequestBodyRulesInnerFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
-	switch (json["id"]) {
-		case "encrypt": return Object.assign({}, EncryptTransformationFromJSONTyped(json, true), { id: "encrypt" });
-		case "mask": return Object.assign({}, MaskTransformationFromJSONTyped(json, true), { id: "mask" });
-		case "redact": return Object.assign({}, RedactTransformationFromJSONTyped(json, true), { id: "redact" });
-		case "replace": return Object.assign({}, ReplaceTransformationFromJSONTyped(json, true), { id: "replace" });
-		case "sha256": return Object.assign({}, SHA256TransformationFromJSONTyped(json, true), { id: "sha256" });
-		case "sha512": return Object.assign({}, SHA512TransformationFromJSONTyped(json, true), { id: "sha512" });
+	switch (json["type"]) {
+		case "encrypt": return Object.assign({}, EncryptRuleFromJSONTyped(json, true), { type: "encrypt" });
+		case "mask": return Object.assign({}, MaskRuleFromJSONTyped(json, true), { type: "mask" });
+		case "redact": return Object.assign({}, RedactRuleFromJSONTyped(json, true), { type: "redact" });
+		case "replace": return Object.assign({}, ReplaceRuleFromJSONTyped(json, true), { type: "replace" });
+		case "sha256": return Object.assign({}, SHA256RuleFromJSONTyped(json, true), { type: "sha256" });
+		case "sha512": return Object.assign({}, SHA512RuleFromJSONTyped(json, true), { type: "sha512" });
 		default: return json;
 	}
 }
-function AnonymizeRequestBodyTransformationsInnerToJSON(json) {
-	return AnonymizeRequestBodyTransformationsInnerToJSONTyped(json, false);
+function AnonymizeRequestBodyRulesInnerToJSON(json) {
+	return AnonymizeRequestBodyRulesInnerToJSONTyped(json, false);
 }
-function AnonymizeRequestBodyTransformationsInnerToJSONTyped(value, ignoreDiscriminator = false) {
+function AnonymizeRequestBodyRulesInnerToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
-	switch (value["id"]) {
-		case "encrypt": return Object.assign({}, EncryptTransformationToJSON(value), { id: "encrypt" });
-		case "mask": return Object.assign({}, MaskTransformationToJSON(value), { id: "mask" });
-		case "redact": return Object.assign({}, RedactTransformationToJSON(value), { id: "redact" });
-		case "replace": return Object.assign({}, ReplaceTransformationToJSON(value), { id: "replace" });
-		case "sha256": return Object.assign({}, SHA256TransformationToJSON(value), { id: "sha256" });
-		case "sha512": return Object.assign({}, SHA512TransformationToJSON(value), { id: "sha512" });
+	switch (value["type"]) {
+		case "encrypt": return Object.assign({}, EncryptRuleToJSON(value), { type: "encrypt" });
+		case "mask": return Object.assign({}, MaskRuleToJSON(value), { type: "mask" });
+		case "redact": return Object.assign({}, RedactRuleToJSON(value), { type: "redact" });
+		case "replace": return Object.assign({}, ReplaceRuleToJSON(value), { type: "replace" });
+		case "sha256": return Object.assign({}, SHA256RuleToJSON(value), { type: "sha256" });
+		case "sha512": return Object.assign({}, SHA512RuleToJSON(value), { type: "sha512" });
 		default: return value;
 	}
 }
@@ -538,7 +538,7 @@ function AnonymizeRequestBodyTransformationsInnerToJSONTyped(value, ignoreDiscri
 */
 function instanceOfAnonymizeRequestBody(value) {
 	if (!("text" in value) || value["text"] === void 0) return false;
-	if (!("transformations" in value) || value["transformations"] === void 0) return false;
+	if (!("rules" in value) || value["rules"] === void 0) return false;
 	return true;
 }
 function AnonymizeRequestBodyFromJSON(json) {
@@ -548,7 +548,7 @@ function AnonymizeRequestBodyFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
 		"text": json["text"],
-		"transformations": json["transformations"].map(AnonymizeRequestBodyTransformationsInnerFromJSON)
+		"rules": json["rules"].map(AnonymizeRequestBodyRulesInnerFromJSON)
 	};
 }
 function AnonymizeRequestBodyToJSON(json) {
@@ -558,7 +558,7 @@ function AnonymizeRequestBodyToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
 		"text": value["text"],
-		"transformations": value["transformations"].map(AnonymizeRequestBodyTransformationsInnerToJSON)
+		"rules": value["rules"].map(AnonymizeRequestBodyRulesInnerToJSON)
 	};
 }
 
@@ -593,84 +593,98 @@ function AnonymizeResponseBodyToJSONTyped(value, ignoreDiscriminator = false) {
 }
 
 //#endregion
-//#region src/models/EntitySpanResult.ts
+//#region src/models/ModelEntity.ts
 /**
 * @export
 */
-const EntitySpanResultTargetEnum = { entity: "entity" };
+const ModelEntityTypeEnum = { model: "model" };
 /**
-* Check if a given object implements the EntitySpanResult interface.
+* Check if a given object implements the ModelEntity interface.
 */
-function instanceOfEntitySpanResult(value) {
-	if (!("start" in value) || value["start"] === void 0) return false;
-	if (!("end" in value) || value["end"] === void 0) return false;
-	if (!("entity_type" in value) || value["entity_type"] === void 0) return false;
-	if (!("text" in value) || value["text"] === void 0) return false;
+function instanceOfModelEntity(value) {
+	if (!("value" in value) || value["value"] === void 0) return false;
 	return true;
 }
-function EntitySpanResultFromJSON(json) {
-	return EntitySpanResultFromJSONTyped(json, false);
+function ModelEntityFromJSON(json) {
+	return ModelEntityFromJSONTyped(json, false);
 }
-function EntitySpanResultFromJSONTyped(json, ignoreDiscriminator) {
+function ModelEntityFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
-		"target": json["target"] == null ? void 0 : json["target"],
-		"start": json["start"],
-		"end": json["end"],
-		"entity_type": json["entity_type"],
-		"text": json["text"],
-		"score": json["score"] == null ? void 0 : json["score"]
+		"type": json["type"] == null ? void 0 : json["type"],
+		"value": json["value"]
 	};
 }
-function EntitySpanResultToJSON(json) {
-	return EntitySpanResultToJSONTyped(json, false);
+function ModelEntityToJSON(json) {
+	return ModelEntityToJSONTyped(json, false);
 }
-function EntitySpanResultToJSONTyped(value, ignoreDiscriminator = false) {
+function ModelEntityToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
-		"target": value["target"],
-		"start": value["start"],
-		"end": value["end"],
-		"entity_type": value["entity_type"],
-		"text": value["text"],
-		"score": value["score"]
+		"type": value["type"],
+		"value": value["value"]
 	};
 }
 
 //#endregion
-//#region src/models/EntityTarget.ts
+//#region src/models/RegexEntity.ts
 /**
 * @export
 */
-const EntityTargetIdEnum = { entity: "entity" };
+const RegexEntityTypeEnum = { regex: "regex" };
 /**
-* Check if a given object implements the EntityTarget interface.
+* Check if a given object implements the RegexEntity interface.
 */
-function instanceOfEntityTarget(value) {
-	if (!("entity_type" in value) || value["entity_type"] === void 0) return false;
+function instanceOfRegexEntity(value) {
+	if (!("value" in value) || value["value"] === void 0) return false;
 	return true;
 }
-function EntityTargetFromJSON(json) {
-	return EntityTargetFromJSONTyped(json, false);
+function RegexEntityFromJSON(json) {
+	return RegexEntityFromJSONTyped(json, false);
 }
-function EntityTargetFromJSONTyped(json, ignoreDiscriminator) {
+function RegexEntityFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
-		"id": json["id"] == null ? void 0 : json["id"],
-		"entity_type": json["entity_type"]
+		"type": json["type"] == null ? void 0 : json["type"],
+		"value": json["value"]
 	};
 }
-function EntityTargetToJSON(json) {
-	return EntityTargetToJSONTyped(json, false);
+function RegexEntityToJSON(json) {
+	return RegexEntityToJSONTyped(json, false);
 }
-function EntityTargetToJSONTyped(value, ignoreDiscriminator = false) {
+function RegexEntityToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
-		"id": value["id"],
-		"entity_type": value["entity_type"]
+		"type": value["type"],
+		"value": value["value"]
 	};
 }
 
+//#endregion
+//#region src/models/EntitiesAnyOfInner.ts
+function EntitiesAnyOfInnerFromJSON(json) {
+	return EntitiesAnyOfInnerFromJSONTyped(json, false);
+}
+function EntitiesAnyOfInnerFromJSONTyped(json, ignoreDiscriminator) {
+	if (json == null) return json;
+	switch (json["type"]) {
+		case "model": return Object.assign({}, ModelEntityFromJSONTyped(json, true), { type: "model" });
+		case "regex": return Object.assign({}, RegexEntityFromJSONTyped(json, true), { type: "regex" });
+		default: return json;
+	}
+}
+function EntitiesAnyOfInnerToJSON(json) {
+	return EntitiesAnyOfInnerToJSONTyped(json, false);
+}
+function EntitiesAnyOfInnerToJSONTyped(value, ignoreDiscriminator = false) {
+	if (value == null) return value;
+	switch (value["type"]) {
+		case "model": return Object.assign({}, ModelEntityToJSON(value), { type: "model" });
+		case "regex": return Object.assign({}, RegexEntityToJSON(value), { type: "regex" });
+		default: return value;
+	}
+}
+
 //#endregion
 //#region src/models/ValidationErrorLocInner.ts
 /**
@@ -750,44 +764,89 @@ function HTTPValidationErrorToJSONTyped(value, ignoreDiscriminator = false) {
 }
 
 //#endregion
-//#region src/models/RegexSpanResult.ts
+//#region src/models/ModelSpan.ts
+/**
+* @export
+*/
+const ModelSpanTypeEnum = { model: "model" };
+/**
+* Check if a given object implements the ModelSpan interface.
+*/
+function instanceOfModelSpan(value) {
+	if (!("start" in value) || value["start"] === void 0) return false;
+	if (!("end" in value) || value["end"] === void 0) return false;
+	if (!("value" in value) || value["value"] === void 0) return false;
+	if (!("text" in value) || value["text"] === void 0) return false;
+	return true;
+}
+function ModelSpanFromJSON(json) {
+	return ModelSpanFromJSONTyped(json, false);
+}
+function ModelSpanFromJSONTyped(json, ignoreDiscriminator) {
+	if (json == null) return json;
+	return {
+		"type": json["type"] == null ? void 0 : json["type"],
+		"start": json["start"],
+		"end": json["end"],
+		"value": json["value"],
+		"text": json["text"],
+		"score": json["score"] == null ? void 0 : json["score"]
+	};
+}
+function ModelSpanToJSON(json) {
+	return ModelSpanToJSONTyped(json, false);
+}
+function ModelSpanToJSONTyped(value, ignoreDiscriminator = false) {
+	if (value == null) return value;
+	return {
+		"type": value["type"],
+		"start": value["start"],
+		"end": value["end"],
+		"value": value["value"],
+		"text": value["text"],
+		"score": value["score"]
+	};
+}
+
+//#endregion
+//#region src/models/RegexSpan.ts
 /**
 * @export
 */
-const RegexSpanResultTargetEnum = { regex: "regex" };
+const RegexSpanTypeEnum = { regex: "regex" };
 /**
-* Check if a given object implements the RegexSpanResult interface.
+* Check if a given object implements the RegexSpan interface.
 */
-function instanceOfRegexSpanResult(value) {
+function instanceOfRegexSpan(value) {
 	if (!("start" in value) || value["start"] === void 0) return false;
 	if (!("end" in value) || value["end"] === void 0) return false;
-	if (!("pattern" in value) || value["pattern"] === void 0) return false;
+	if (!("value" in value) || value["value"] === void 0) return false;
 	if (!("text" in value) || value["text"] === void 0) return false;
 	return true;
 }
-function RegexSpanResultFromJSON(json) {
-	return RegexSpanResultFromJSONTyped(json, false);
+function RegexSpanFromJSON(json) {
+	return RegexSpanFromJSONTyped(json, false);
 }
-function RegexSpanResultFromJSONTyped(json, ignoreDiscriminator) {
+function RegexSpanFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
 	return {
-		"target": json["target"] == null ? void 0 : json["target"],
+		"type": json["type"] == null ? void 0 : json["type"],
 		"start": json["start"],
 		"end": json["end"],
-		"pattern": json["pattern"],
+		"value": json["value"],
 		"text": json["text"]
 	};
 }
-function RegexSpanResultToJSON(json) {
-	return RegexSpanResultToJSONTyped(json, false);
+function RegexSpanToJSON(json) {
+	return RegexSpanToJSONTyped(json, false);
 }
-function RegexSpanResultToJSONTyped(value, ignoreDiscriminator = false) {
+function RegexSpanToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
 	return {
-		"target": value["target"],
+		"type": value["type"],
 		"start": value["start"],
 		"end": value["end"],
-		"pattern": value["pattern"],
+		"value": value["value"],
 		"text": value["text"]
 	};
 }
@@ -799,9 +858,9 @@ function MapValueInnerFromJSON(json) {
 }
 function MapValueInnerFromJSONTyped(json, ignoreDiscriminator) {
 	if (json == null) return json;
-	switch (json["target"]) {
-		case "entity": return Object.assign({}, EntitySpanResultFromJSONTyped(json, true), { target: "entity" });
-		case "regex": return Object.assign({}, RegexSpanResultFromJSONTyped(json, true), { target: "regex" });
+	switch (json["type"]) {
+		case "model": return Object.assign({}, ModelSpanFromJSONTyped(json, true), { type: "model" });
+		case "regex": return Object.assign({}, RegexSpanFromJSONTyped(json, true), { type: "regex" });
 		default: return json;
 	}
 }
@@ -810,47 +869,13 @@ function MapValueInnerToJSON(json) {
 }
 function MapValueInnerToJSONTyped(value, ignoreDiscriminator = false) {
 	if (value == null) return value;
-	switch (value["target"]) {
-		case "entity": return Object.assign({}, EntitySpanResultToJSON(value), { target: "entity" });
-		case "regex": return Object.assign({}, RegexSpanResultToJSON(value), { target: "regex" });
+	switch (value["type"]) {
+		case "model": return Object.assign({}, ModelSpanToJSON(value), { type: "model" });
+		case "regex": return Object.assign({}, RegexSpanToJSON(value), { type: "regex" });
 		default: return value;
 	}
 }
 
-//#endregion
-//#region src/models/RegexTarget.ts
-/**
-* @export
-*/
-const RegexTargetIdEnum = { regex: "regex" };
-/**
-* Check if a given object implements the RegexTarget interface.
-*/
-function instanceOfRegexTarget(value) {
-	if (!("pattern" in value) || value["pattern"] === void 0) return false;
-	return true;
-}
-function RegexTargetFromJSON(json) {
-	return RegexTargetFromJSONTyped(json, false);
-}
-function RegexTargetFromJSONTyped(json, ignoreDiscriminator) {
-	if (json == null) return json;
-	return {
-		"id": json["id"] == null ? void 0 : json["id"],
-		"pattern": json["pattern"]
-	};
-}
-function RegexTargetToJSON(json) {
-	return RegexTargetToJSONTyped(json, false);
-}
-function RegexTargetToJSONTyped(value, ignoreDiscriminator = false) {
-	if (value == null) return value;
-	return {
-		"id": value["id"],
-		"pattern": value["pattern"]
-	};
-}
-
 //#endregion
 //#region src/models/ScanRequestBody.ts
 /**
@@ -946,31 +971,6 @@ function ScanResponseBodyToJSONTyped(value, ignoreDiscriminator = false) {
 	return { "results": value["results"].map(ScanResultToJSON) };
 }
 
-//#endregion
-//#region src/models/TargetsAnyOfInner.ts
-function TargetsAnyOfInnerFromJSON(json) {
-	return TargetsAnyOfInnerFromJSONTyped(json, false);
-}
-function TargetsAnyOfInnerFromJSONTyped(json, ignoreDiscriminator) {
-	if (json == null) return json;
-	switch (json["id"]) {
-		case "entity": return Object.assign({}, EntityTargetFromJSONTyped(json, true), { id: "entity" });
-		case "regex": return Object.assign({}, RegexTargetFromJSONTyped(json, true), { id: "regex" });
-		default: return json;
-	}
-}
-function TargetsAnyOfInnerToJSON(json) {
-	return TargetsAnyOfInnerToJSONTyped(json, false);
-}
-function TargetsAnyOfInnerToJSONTyped(value, ignoreDiscriminator = false) {
-	if (value == null) return value;
-	switch (value["id"]) {
-		case "entity": return Object.assign({}, EntityTargetToJSON(value), { id: "entity" });
-		case "regex": return Object.assign({}, RegexTargetToJSON(value), { id: "regex" });
-		default: return value;
-	}
-}
-
 //#endregion
 //#region src/apis/SensitiveDataProtectionApi.ts
 /**
@@ -1064,12 +1064,12 @@ var SensitiveDataProtectionApi = class extends BaseAPI {
 //#endregion
 exports.AnonymizeRequestBodyFromJSON = AnonymizeRequestBodyFromJSON;
 exports.AnonymizeRequestBodyFromJSONTyped = AnonymizeRequestBodyFromJSONTyped;
+exports.AnonymizeRequestBodyRulesInnerFromJSON = AnonymizeRequestBodyRulesInnerFromJSON;
+exports.AnonymizeRequestBodyRulesInnerFromJSONTyped = AnonymizeRequestBodyRulesInnerFromJSONTyped;
+exports.AnonymizeRequestBodyRulesInnerToJSON = AnonymizeRequestBodyRulesInnerToJSON;
+exports.AnonymizeRequestBodyRulesInnerToJSONTyped = AnonymizeRequestBodyRulesInnerToJSONTyped;
 exports.AnonymizeRequestBodyToJSON = AnonymizeRequestBodyToJSON;
 exports.AnonymizeRequestBodyToJSONTyped = AnonymizeRequestBodyToJSONTyped;
-exports.AnonymizeRequestBodyTransformationsInnerFromJSON = AnonymizeRequestBodyTransformationsInnerFromJSON;
-exports.AnonymizeRequestBodyTransformationsInnerFromJSONTyped = AnonymizeRequestBodyTransformationsInnerFromJSONTyped;
-exports.AnonymizeRequestBodyTransformationsInnerToJSON = AnonymizeRequestBodyTransformationsInnerToJSON;
-exports.AnonymizeRequestBodyTransformationsInnerToJSONTyped = AnonymizeRequestBodyTransformationsInnerToJSONTyped;
 exports.AnonymizeResponseBodyFromJSON = AnonymizeResponseBodyFromJSON;
 exports.AnonymizeResponseBodyFromJSONTyped = AnonymizeResponseBodyFromJSONTyped;
 exports.AnonymizeResponseBodyToJSON = AnonymizeResponseBodyToJSON;
@@ -1080,21 +1080,19 @@ exports.BlobApiResponse = BlobApiResponse;
 exports.COLLECTION_FORMATS = COLLECTION_FORMATS;
 exports.Configuration = Configuration;
 exports.DefaultConfig = DefaultConfig;
-exports.EncryptTransformationFromJSON = EncryptTransformationFromJSON;
-exports.EncryptTransformationFromJSONTyped = EncryptTransformationFromJSONTyped;
-exports.EncryptTransformationIdEnum = EncryptTransformationIdEnum;
-exports.EncryptTransformationToJSON = EncryptTransformationToJSON;
-exports.EncryptTransformationToJSONTyped = EncryptTransformationToJSONTyped;
-exports.EntitySpanResultFromJSON = EntitySpanResultFromJSON;
-exports.EntitySpanResultFromJSONTyped = EntitySpanResultFromJSONTyped;
-exports.EntitySpanResultTargetEnum = EntitySpanResultTargetEnum;
-exports.EntitySpanResultToJSON = EntitySpanResultToJSON;
-exports.EntitySpanResultToJSONTyped = EntitySpanResultToJSONTyped;
-exports.EntityTargetFromJSON = EntityTargetFromJSON;
-exports.EntityTargetFromJSONTyped = EntityTargetFromJSONTyped;
-exports.EntityTargetIdEnum = EntityTargetIdEnum;
-exports.EntityTargetToJSON = EntityTargetToJSON;
-exports.EntityTargetToJSONTyped = EntityTargetToJSONTyped;
+exports.EncryptRuleFromJSON = EncryptRuleFromJSON;
+exports.EncryptRuleFromJSONTyped = EncryptRuleFromJSONTyped;
+exports.EncryptRuleToJSON = EncryptRuleToJSON;
+exports.EncryptRuleToJSONTyped = EncryptRuleToJSONTyped;
+exports.EncryptRuleTypeEnum = EncryptRuleTypeEnum;
+exports.EntitiesAnyOfInnerFromJSON = EntitiesAnyOfInnerFromJSON;
+exports.EntitiesAnyOfInnerFromJSONTyped = EntitiesAnyOfInnerFromJSONTyped;
+exports.EntitiesAnyOfInnerToJSON = EntitiesAnyOfInnerToJSON;
+exports.EntitiesAnyOfInnerToJSONTyped = EntitiesAnyOfInnerToJSONTyped;
+exports.EntitiesFromJSON = EntitiesFromJSON;
+exports.EntitiesFromJSONTyped = EntitiesFromJSONTyped;
+exports.EntitiesToJSON = EntitiesToJSON;
+exports.EntitiesToJSONTyped = EntitiesToJSONTyped;
 exports.FetchError = FetchError;
 exports.HTTPValidationErrorFromJSON = HTTPValidationErrorFromJSON;
 exports.HTTPValidationErrorFromJSONTyped = HTTPValidationErrorFromJSONTyped;
@@ -1105,43 +1103,53 @@ exports.MapValueInnerFromJSON = MapValueInnerFromJSON;
 exports.MapValueInnerFromJSONTyped = MapValueInnerFromJSONTyped;
 exports.MapValueInnerToJSON = MapValueInnerToJSON;
 exports.MapValueInnerToJSONTyped = MapValueInnerToJSONTyped;
-exports.MaskTransformationFromJSON = MaskTransformationFromJSON;
-exports.MaskTransformationFromJSONTyped = MaskTransformationFromJSONTyped;
-exports.MaskTransformationIdEnum = MaskTransformationIdEnum;
-exports.MaskTransformationToJSON = MaskTransformationToJSON;
-exports.MaskTransformationToJSONTyped = MaskTransformationToJSONTyped;
-exports.RedactTransformationFromJSON = RedactTransformationFromJSON;
-exports.RedactTransformationFromJSONTyped = RedactTransformationFromJSONTyped;
-exports.RedactTransformationIdEnum = RedactTransformationIdEnum;
-exports.RedactTransformationToJSON = RedactTransformationToJSON;
-exports.RedactTransformationToJSONTyped = RedactTransformationToJSONTyped;
-exports.RegexSpanResultFromJSON = RegexSpanResultFromJSON;
-exports.RegexSpanResultFromJSONTyped = RegexSpanResultFromJSONTyped;
-exports.RegexSpanResultTargetEnum = RegexSpanResultTargetEnum;
-exports.RegexSpanResultToJSON = RegexSpanResultToJSON;
-exports.RegexSpanResultToJSONTyped = RegexSpanResultToJSONTyped;
-exports.RegexTargetFromJSON = RegexTargetFromJSON;
-exports.RegexTargetFromJSONTyped = RegexTargetFromJSONTyped;
-exports.RegexTargetIdEnum = RegexTargetIdEnum;
-exports.RegexTargetToJSON = RegexTargetToJSON;
-exports.RegexTargetToJSONTyped = RegexTargetToJSONTyped;
-exports.ReplaceTransformationFromJSON = ReplaceTransformationFromJSON;
-exports.ReplaceTransformationFromJSONTyped = ReplaceTransformationFromJSONTyped;
-exports.ReplaceTransformationIdEnum = ReplaceTransformationIdEnum;
-exports.ReplaceTransformationToJSON = ReplaceTransformationToJSON;
-exports.ReplaceTransformationToJSONTyped = ReplaceTransformationToJSONTyped;
+exports.MaskRuleFromJSON = MaskRuleFromJSON;
+exports.MaskRuleFromJSONTyped = MaskRuleFromJSONTyped;
+exports.MaskRuleToJSON = MaskRuleToJSON;
+exports.MaskRuleToJSONTyped = MaskRuleToJSONTyped;
+exports.MaskRuleTypeEnum = MaskRuleTypeEnum;
+exports.ModelEntityFromJSON = ModelEntityFromJSON;
+exports.ModelEntityFromJSONTyped = ModelEntityFromJSONTyped;
+exports.ModelEntityToJSON = ModelEntityToJSON;
+exports.ModelEntityToJSONTyped = ModelEntityToJSONTyped;
+exports.ModelEntityTypeEnum = ModelEntityTypeEnum;
+exports.ModelSpanFromJSON = ModelSpanFromJSON;
+exports.ModelSpanFromJSONTyped = ModelSpanFromJSONTyped;
+exports.ModelSpanToJSON = ModelSpanToJSON;
+exports.ModelSpanToJSONTyped = ModelSpanToJSONTyped;
+exports.ModelSpanTypeEnum = ModelSpanTypeEnum;
+exports.RedactRuleFromJSON = RedactRuleFromJSON;
+exports.RedactRuleFromJSONTyped = RedactRuleFromJSONTyped;
+exports.RedactRuleToJSON = RedactRuleToJSON;
+exports.RedactRuleToJSONTyped = RedactRuleToJSONTyped;
+exports.RedactRuleTypeEnum = RedactRuleTypeEnum;
+exports.RegexEntityFromJSON = RegexEntityFromJSON;
+exports.RegexEntityFromJSONTyped = RegexEntityFromJSONTyped;
+exports.RegexEntityToJSON = RegexEntityToJSON;
+exports.RegexEntityToJSONTyped = RegexEntityToJSONTyped;
+exports.RegexEntityTypeEnum = RegexEntityTypeEnum;
+exports.RegexSpanFromJSON = RegexSpanFromJSON;
+exports.RegexSpanFromJSONTyped = RegexSpanFromJSONTyped;
+exports.RegexSpanToJSON = RegexSpanToJSON;
+exports.RegexSpanToJSONTyped = RegexSpanToJSONTyped;
+exports.RegexSpanTypeEnum = RegexSpanTypeEnum;
+exports.ReplaceRuleFromJSON = ReplaceRuleFromJSON;
+exports.ReplaceRuleFromJSONTyped = ReplaceRuleFromJSONTyped;
+exports.ReplaceRuleToJSON = ReplaceRuleToJSON;
+exports.ReplaceRuleToJSONTyped = ReplaceRuleToJSONTyped;
+exports.ReplaceRuleTypeEnum = ReplaceRuleTypeEnum;
 exports.RequiredError = RequiredError;
 exports.ResponseError = ResponseError;
-exports.SHA256TransformationFromJSON = SHA256TransformationFromJSON;
-exports.SHA256TransformationFromJSONTyped = SHA256TransformationFromJSONTyped;
-exports.SHA256TransformationIdEnum = SHA256TransformationIdEnum;
-exports.SHA256TransformationToJSON = SHA256TransformationToJSON;
-exports.SHA256TransformationToJSONTyped = SHA256TransformationToJSONTyped;
-exports.SHA512TransformationFromJSON = SHA512TransformationFromJSON;
-exports.SHA512TransformationFromJSONTyped = SHA512TransformationFromJSONTyped;
-exports.SHA512TransformationIdEnum = SHA512TransformationIdEnum;
-exports.SHA512TransformationToJSON = SHA512TransformationToJSON;
-exports.SHA512TransformationToJSONTyped = SHA512TransformationToJSONTyped;
+exports.SHA256RuleFromJSON = SHA256RuleFromJSON;
+exports.SHA256RuleFromJSONTyped = SHA256RuleFromJSONTyped;
+exports.SHA256RuleToJSON = SHA256RuleToJSON;
+exports.SHA256RuleToJSONTyped = SHA256RuleToJSONTyped;
+exports.SHA256RuleTypeEnum = SHA256RuleTypeEnum;
+exports.SHA512RuleFromJSON = SHA512RuleFromJSON;
+exports.SHA512RuleFromJSONTyped = SHA512RuleFromJSONTyped;
+exports.SHA512RuleToJSON = SHA512RuleToJSON;
+exports.SHA512RuleToJSONTyped = SHA512RuleToJSONTyped;
+exports.SHA512RuleTypeEnum = SHA512RuleTypeEnum;
 exports.ScanRequestBodyFromJSON = ScanRequestBodyFromJSON;
 exports.ScanRequestBodyFromJSONTyped = ScanRequestBodyFromJSONTyped;
 exports.ScanRequestBodyToJSON = ScanRequestBodyToJSON;
@@ -1155,14 +1163,6 @@ exports.ScanResultFromJSONTyped = ScanResultFromJSONTyped;
 exports.ScanResultToJSON = ScanResultToJSON;
 exports.ScanResultToJSONTyped = ScanResultToJSONTyped;
 exports.SensitiveDataProtectionApi = SensitiveDataProtectionApi;
-exports.TargetsAnyOfInnerFromJSON = TargetsAnyOfInnerFromJSON;
-exports.TargetsAnyOfInnerFromJSONTyped = TargetsAnyOfInnerFromJSONTyped;
-exports.TargetsAnyOfInnerToJSON = TargetsAnyOfInnerToJSON;
-exports.TargetsAnyOfInnerToJSONTyped = TargetsAnyOfInnerToJSONTyped;
-exports.TargetsFromJSON = TargetsFromJSON;
-exports.TargetsFromJSONTyped = TargetsFromJSONTyped;
-exports.TargetsToJSON = TargetsToJSON;
-exports.TargetsToJSONTyped = TargetsToJSONTyped;
 exports.TextApiResponse = TextApiResponse;
 exports.ValidationErrorFromJSON = ValidationErrorFromJSON;
 exports.ValidationErrorFromJSONTyped = ValidationErrorFromJSONTyped;
@@ -1177,21 +1177,21 @@ exports.canConsumeForm = canConsumeForm;
 exports.exists = exists;
 exports.instanceOfAnonymizeRequestBody = instanceOfAnonymizeRequestBody;
 exports.instanceOfAnonymizeResponseBody = instanceOfAnonymizeResponseBody;
-exports.instanceOfEncryptTransformation = instanceOfEncryptTransformation;
-exports.instanceOfEntitySpanResult = instanceOfEntitySpanResult;
-exports.instanceOfEntityTarget = instanceOfEntityTarget;
+exports.instanceOfEncryptRule = instanceOfEncryptRule;
+exports.instanceOfEntities = instanceOfEntities;
 exports.instanceOfHTTPValidationError = instanceOfHTTPValidationError;
-exports.instanceOfMaskTransformation = instanceOfMaskTransformation;
-exports.instanceOfRedactTransformation = instanceOfRedactTransformation;
-exports.instanceOfRegexSpanResult = instanceOfRegexSpanResult;
-exports.instanceOfRegexTarget = instanceOfRegexTarget;
-exports.instanceOfReplaceTransformation = instanceOfReplaceTransformation;
-exports.instanceOfSHA256Transformation = instanceOfSHA256Transformation;
-exports.instanceOfSHA512Transformation = instanceOfSHA512Transformation;
+exports.instanceOfMaskRule = instanceOfMaskRule;
+exports.instanceOfModelEntity = instanceOfModelEntity;
+exports.instanceOfModelSpan = instanceOfModelSpan;
+exports.instanceOfRedactRule = instanceOfRedactRule;
+exports.instanceOfRegexEntity = instanceOfRegexEntity;
+exports.instanceOfRegexSpan = instanceOfRegexSpan;
+exports.instanceOfReplaceRule = instanceOfReplaceRule;
+exports.instanceOfSHA256Rule = instanceOfSHA256Rule;
+exports.instanceOfSHA512Rule = instanceOfSHA512Rule;
 exports.instanceOfScanRequestBody = instanceOfScanRequestBody;
 exports.instanceOfScanResponseBody = instanceOfScanResponseBody;
 exports.instanceOfScanResult = instanceOfScanResult;
-exports.instanceOfTargets = instanceOfTargets;
 exports.instanceOfValidationError = instanceOfValidationError;
 exports.instanceOfValidationErrorLocInner = instanceOfValidationErrorLocInner;
 exports.mapValues = mapValues;