@degenerate/generic 0.2.7 → 0.4.0

package/dist/models/rules/share-rule-models.d.ts

@@ -9,7 +9,10 @@ export declare enum LogicalOperator {
     AND = "AND",
     OR = "OR"
 }
-export declare const LogicalOperatorSchema: z.ZodEnum<["AND", "OR"]>;
+export declare const LogicalOperatorSchema: z.ZodEnum<{
+    AND: "AND";
+    OR: "OR";
+}>;
 /**
  * This contains the choices for the type of qualifier.
  */
@@ -17,7 +20,10 @@ export declare enum ConditionTypeQualifier {
     IS = "IS",
     IS_NOT = "IS_NOT"
 }
-export declare const ConditionTypeQualifierSchema: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const ConditionTypeQualifierSchema: z.ZodEnum<{
+    IS: "IS";
+    IS_NOT: "IS_NOT";
+}>;
 /**
  * This contains the choices for the type of condition.
  */
@@ -29,7 +35,14 @@ export declare enum ConditionTypeSingle {
     EMPTY = "EMPTY",// the value is empty
     SHARE_RULE = "SHARE_RULE"
 }
-export declare const ConditionTypeSingleSchema: z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>;
+export declare const ConditionTypeSingleSchema: z.ZodEnum<{
+    TYPEOF: "TYPEOF";
+    EQUAL: "EQUAL";
+    CONTAINS: "CONTAINS";
+    NULL: "NULL";
+    EMPTY: "EMPTY";
+    SHARE_RULE: "SHARE_RULE";
+}>;
 /**
  * This contains the choices for the range conditions.
  */
@@ -39,7 +52,12 @@ export declare enum ConditionTypeRange {
     GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL",
     LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL"
 }
-export declare const ConditionTypeRangeSchema: z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>;
+export declare const ConditionTypeRangeSchema: z.ZodEnum<{
+    GREATER_THAN: "GREATER_THAN";
+    LESS_THAN: "LESS_THAN";
+    GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+    LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+}>;
 /**
  * This contains the choices for the starts with and ends with conditions.
  */
@@ -47,7 +65,10 @@ export declare enum ConditionTypeStartsEndsWith {
     STARTS_WITH = "STARTS_WITH",
     ENDS_WITH = "ENDS_WITH"
 }
-export declare const ConditionTypeStartsEndsWithSchema: z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>;
+export declare const ConditionTypeStartsEndsWithSchema: z.ZodEnum<{
+    STARTS_WITH: "STARTS_WITH";
+    ENDS_WITH: "ENDS_WITH";
+}>;
 /**
  * This contains the choices for the boolean conditions.
  */
@@ -55,19 +76,44 @@ export declare enum ConditionTypeBoolean {
     TRUE = "TRUE",
     FALSE = "FALSE"
 }
-export declare const ConditionTypeBooleanSchema: z.ZodEnum<["TRUE", "FALSE"]>;
+export declare const ConditionTypeBooleanSchema: z.ZodEnum<{
+    TRUE: "TRUE";
+    FALSE: "FALSE";
+}>;
 /**
  * This contains the choices for the special conditions.
  */
 export declare enum ConditionTypeSpecial {
     PATTERN = "PATTERN"
 }
-export declare const ConditionTypeSpecialSchema: z.ZodEnum<["PATTERN"]>;
+export declare const ConditionTypeSpecialSchema: z.ZodEnum<{
+    PATTERN: "PATTERN";
+}>;
 /**
  * This contains the different types of conditions that can be evaluated.
  */
 export type ConditionType = ConditionTypeSingle | ConditionTypeRange | ConditionTypeStartsEndsWith | ConditionTypeBoolean | ConditionTypeSpecial;
-export declare const ConditionTypeSchema: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
+export declare const ConditionTypeSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    TYPEOF: "TYPEOF";
+    EQUAL: "EQUAL";
+    CONTAINS: "CONTAINS";
+    NULL: "NULL";
+    EMPTY: "EMPTY";
+    SHARE_RULE: "SHARE_RULE";
+}>, z.ZodEnum<{
+    GREATER_THAN: "GREATER_THAN";
+    LESS_THAN: "LESS_THAN";
+    GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+    LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+}>, z.ZodEnum<{
+    STARTS_WITH: "STARTS_WITH";
+    ENDS_WITH: "ENDS_WITH";
+}>, z.ZodEnum<{
+    TRUE: "TRUE";
+    FALSE: "FALSE";
+}>, z.ZodEnum<{
+    PATTERN: "PATTERN";
+}>]>;
 /**
  * These are the different choices for the types of data in a condition.
  */
@@ -83,23 +129,49 @@ export declare enum ConditionTypeOf {
     FUNCTION = "FUNCTION",
     BIGINT = "BIGINT"
 }
-export declare const ConditionTypeOfSchema: z.ZodEnum<["STRING", "NUMBER", "INTEGER", "BOOLEAN", "OBJECT", "ARRAY", "NULL", "UNDEFINED", "FUNCTION", "BIGINT"]>;
+export declare const ConditionTypeOfSchema: z.ZodEnum<{
+    NULL: "NULL";
+    STRING: "STRING";
+    NUMBER: "NUMBER";
+    INTEGER: "INTEGER";
+    BOOLEAN: "BOOLEAN";
+    OBJECT: "OBJECT";
+    ARRAY: "ARRAY";
+    UNDEFINED: "UNDEFINED";
+    FUNCTION: "FUNCTION";
+    BIGINT: "BIGINT";
+}>;
 /**
  * This is the interface for the base condition.
  */
 export declare const IConditionBaseSchema: z.ZodObject<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    conditionType: z.ZodUnion<readonly [z.ZodEnum<{
+        TYPEOF: "TYPEOF";
+        EQUAL: "EQUAL";
+        CONTAINS: "CONTAINS";
+        NULL: "NULL";
+        EMPTY: "EMPTY";
+        SHARE_RULE: "SHARE_RULE";
+    }>, z.ZodEnum<{
+        GREATER_THAN: "GREATER_THAN";
+        LESS_THAN: "LESS_THAN";
+        GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+        LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+    }>, z.ZodEnum<{
+        STARTS_WITH: "STARTS_WITH";
+        ENDS_WITH: "ENDS_WITH";
+    }>, z.ZodEnum<{
+        TRUE: "TRUE";
+        FALSE: "FALSE";
+    }>, z.ZodEnum<{
+        PATTERN: "PATTERN";
+    }>]>;
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}, {
-    conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}>;
+}, z.core.$strip>;
 export interface IConditionBase {
     conditionType: ConditionType;
     conditionTypeQualifier: ConditionTypeQualifier;
@@ -115,24 +187,26 @@ const exampleConditionTypeOf: IConditionTypeOf = {
     targettedProperty: 'address.city.total',
 };
  */
-export declare const IConditionTypeOfSchema: z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionTypeOfSchema: z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"TYPEOF">;
-    conditionValue: z.ZodEnum<["STRING", "NUMBER", "INTEGER", "BOOLEAN", "OBJECT", "ARRAY", "NULL", "UNDEFINED", "FUNCTION", "BIGINT"]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "TYPEOF";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-}, {
-    conditionType: "TYPEOF";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-}>;
+    conditionValue: z.ZodEnum<{
+        NULL: "NULL";
+        STRING: "STRING";
+        NUMBER: "NUMBER";
+        INTEGER: "INTEGER";
+        BOOLEAN: "BOOLEAN";
+        OBJECT: "OBJECT";
+        ARRAY: "ARRAY";
+        UNDEFINED: "UNDEFINED";
+        FUNCTION: "FUNCTION";
+        BIGINT: "BIGINT";
+    }>;
+}, z.core.$strip>;
 export interface IConditionTypeOf extends IConditionBase {
     conditionType: ConditionTypeSingle.TYPEOF;
     conditionValue: ConditionTypeOf;
@@ -147,24 +221,15 @@ const exampleConditionEquality: IConditionEquality = {
     targettedProperty: 'address.city.total',
 };
  */
-export declare const IConditionEqualitySchema: z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionEqualitySchema: z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"EQUAL">;
-    conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "EQUAL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | number;
-}, {
-    conditionType: "EQUAL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | number;
-}>;
+    conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+}, z.core.$strip>;
 export interface IConditionEquality extends IConditionBase {
     conditionType: ConditionTypeSingle.EQUAL;
     conditionValue: number | string;
@@ -179,24 +244,20 @@ const exampleConditionRange: IConditionRange = {
     targettedProperty: 'address.city.total',
 };
  */
-export declare const IConditionRangeSchema: z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionRangeSchema: z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
-    conditionType: z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>;
-    conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | number;
-}, {
-    conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | number;
-}>;
+    conditionType: z.ZodEnum<{
+        GREATER_THAN: "GREATER_THAN";
+        LESS_THAN: "LESS_THAN";
+        GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+        LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+    }>;
+    conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+}, z.core.$strip>;
 export interface IConditionRange extends IConditionBase {
     conditionType: ConditionTypeRange;
     conditionValue: number | string;
@@ -211,24 +272,15 @@ const exampleConditionContains: IConditionContains = {
     targettedProperty: 'address.city.name',
  * };
  */
-export declare const IConditionContainsSchema: z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionContainsSchema: z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"CONTAINS">;
-    conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "CONTAINS";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | string[] | number[];
-}, {
-    conditionType: "CONTAINS";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | string[] | number[];
-}>;
+    conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+}, z.core.$strip>;
 export interface IConditionContains extends IConditionBase {
     conditionType: ConditionTypeSingle.CONTAINS;
     conditionValue: string | string[] | number[];
@@ -243,24 +295,18 @@ const exampleConditionStartsEndsWith: IConditionStartsEndsWith = {
     targettedProperty: 'address.city.name',
 };
  */
-export declare const IConditionStartsEndsWithSchema: z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionStartsEndsWithSchema: z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
-    conditionType: z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>;
+    conditionType: z.ZodEnum<{
+        STARTS_WITH: "STARTS_WITH";
+        ENDS_WITH: "ENDS_WITH";
+    }>;
     conditionValue: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "STARTS_WITH" | "ENDS_WITH";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string;
-}, {
-    conditionType: "STARTS_WITH" | "ENDS_WITH";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string;
-}>;
+}, z.core.$strip>;
 export interface IConditionStartsEndsWith extends IConditionBase {
     conditionType: ConditionTypeStartsEndsWith;
     conditionValue: string;
@@ -273,21 +319,14 @@ const exampleConditionNull: IConditionNull = {
     targettedProperty: 'address.city.name',
 };
  */
-export declare const IConditionNullSchema: z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionNullSchema: z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"NULL">;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "NULL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}, {
-    conditionType: "NULL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}>;
+}, z.core.$strip>;
 export interface IConditionNull extends IConditionBase {
     conditionType: ConditionTypeSingle.NULL;
 }
@@ -300,21 +339,17 @@ const exampleConditionBoolean: IConditionBoolean = {
     targettedProperty: 'address.city.name',
 };
  */
-export declare const IConditionBooleanSchema: z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionBooleanSchema: z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
-    conditionType: z.ZodEnum<["TRUE", "FALSE"]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "TRUE" | "FALSE";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}, {
-    conditionType: "TRUE" | "FALSE";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}>;
+    conditionType: z.ZodEnum<{
+        TRUE: "TRUE";
+        FALSE: "FALSE";
+    }>;
+}, z.core.$strip>;
 export interface IConditionBoolean extends IConditionBase {
     conditionType: ConditionTypeBoolean;
 }
@@ -327,21 +362,14 @@ const exampleConditionEmpty: IConditionEmpty = {
     targettedProperty: 'address.city.name',
 };
  */
-export declare const IConditionEmptySchema: z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionEmptySchema: z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"EMPTY">;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "EMPTY";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}, {
-    conditionType: "EMPTY";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}>;
+}, z.core.$strip>;
 export interface IConditionEmpty extends IConditionBase {
     conditionType: ConditionTypeSingle.EMPTY;
 }
@@ -355,24 +383,17 @@ const exampleConditionSpecial: IConditionSpecial = {
     targettedProperty: 'address.city.name',
 };
  */
-export declare const IConditionSpecialSchema: z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionSpecialSchema: z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
-    conditionType: z.ZodEnum<["PATTERN"]>;
+    conditionType: z.ZodEnum<{
+        PATTERN: "PATTERN";
+    }>;
     conditionValue: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "PATTERN";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string;
-}, {
-    conditionType: "PATTERN";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string;
-}>;
+}, z.core.$strip>;
 export interface IConditionSpecial extends IConditionBase {
     conditionType: ConditionTypeSpecial;
     conditionValue: string;
@@ -385,456 +406,295 @@ export interface IConditionShareRule extends IConditionBase {
 /**
  * This is the interface for the conditional information in the checks.
  */
-export declare const IConditionSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+export declare const IConditionSchema: z.ZodUnion<readonly [z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"TYPEOF">;
-    conditionValue: z.ZodEnum<["STRING", "NUMBER", "INTEGER", "BOOLEAN", "OBJECT", "ARRAY", "NULL", "UNDEFINED", "FUNCTION", "BIGINT"]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "TYPEOF";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-}, {
-    conditionType: "TYPEOF";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    conditionValue: z.ZodEnum<{
+        NULL: "NULL";
+        STRING: "STRING";
+        NUMBER: "NUMBER";
+        INTEGER: "INTEGER";
+        BOOLEAN: "BOOLEAN";
+        OBJECT: "OBJECT";
+        ARRAY: "ARRAY";
+        UNDEFINED: "UNDEFINED";
+        FUNCTION: "FUNCTION";
+        BIGINT: "BIGINT";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"EQUAL">;
-    conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "EQUAL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | number;
-}, {
-    conditionType: "EQUAL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | number;
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+}, z.core.$strip>, z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
-    conditionType: z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>;
-    conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | number;
-}, {
-    conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | number;
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    conditionType: z.ZodEnum<{
+        GREATER_THAN: "GREATER_THAN";
+        LESS_THAN: "LESS_THAN";
+        GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+        LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+    }>;
+    conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+}, z.core.$strip>, z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"CONTAINS">;
-    conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "CONTAINS";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | string[] | number[];
-}, {
-    conditionType: "CONTAINS";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string | string[] | number[];
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+}, z.core.$strip>, z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
-    conditionType: z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>;
+    conditionType: z.ZodEnum<{
+        STARTS_WITH: "STARTS_WITH";
+        ENDS_WITH: "ENDS_WITH";
+    }>;
     conditionValue: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "STARTS_WITH" | "ENDS_WITH";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string;
-}, {
-    conditionType: "STARTS_WITH" | "ENDS_WITH";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string;
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+}, z.core.$strip>, z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"NULL">;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "NULL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}, {
-    conditionType: "NULL";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+}, z.core.$strip>, z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
-    conditionType: z.ZodEnum<["TRUE", "FALSE"]>;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "TRUE" | "FALSE";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}, {
-    conditionType: "TRUE" | "FALSE";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    conditionType: z.ZodEnum<{
+        TRUE: "TRUE";
+        FALSE: "FALSE";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
     conditionType: z.ZodLiteral<"EMPTY">;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "EMPTY";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}, {
-    conditionType: "EMPTY";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-    conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+}, z.core.$strip>, z.ZodObject<{
+    conditionTypeQualifier: z.ZodEnum<{
+        IS: "IS";
+        IS_NOT: "IS_NOT";
+    }>;
     targettedProperty: z.ZodString;
-}, {
-    conditionType: z.ZodEnum<["PATTERN"]>;
+    conditionType: z.ZodEnum<{
+        PATTERN: "PATTERN";
+    }>;
     conditionValue: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
-    conditionType: "PATTERN";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string;
-}, {
-    conditionType: "PATTERN";
-    conditionTypeQualifier: "IS" | "IS_NOT";
-    targettedProperty: string;
-    conditionValue: string;
-}>, z.ZodType<unknown, z.ZodTypeDef, unknown>]>;
+}, z.core.$strip>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
 export type ICondition = IConditionTypeOf | IConditionEquality | IConditionRange | IConditionContains | IConditionStartsEndsWith | IConditionNull | IConditionBoolean | IConditionEmpty | IConditionShareRule | IConditionSpecial;
 /**
  * This contains the interface for a share rule in the share data object
  */
 export declare const IShareRuleSchema: z.ZodObject<{
     ruleId: z.ZodString;
-    currentDataConditions: z.ZodArray<z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    currentDataConditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"TYPEOF">;
-        conditionValue: z.ZodEnum<["STRING", "NUMBER", "INTEGER", "BOOLEAN", "OBJECT", "ARRAY", "NULL", "UNDEFINED", "FUNCTION", "BIGINT"]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "TYPEOF";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-    }, {
-        conditionType: "TYPEOF";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodEnum<{
+            NULL: "NULL";
+            STRING: "STRING";
+            NUMBER: "NUMBER";
+            INTEGER: "INTEGER";
+            BOOLEAN: "BOOLEAN";
+            OBJECT: "OBJECT";
+            ARRAY: "ARRAY";
+            UNDEFINED: "UNDEFINED";
+            FUNCTION: "FUNCTION";
+            BIGINT: "BIGINT";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"EQUAL">;
-        conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }, {
-        conditionType: "EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>;
-        conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }, {
-        conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodEnum<{
+            GREATER_THAN: "GREATER_THAN";
+            LESS_THAN: "LESS_THAN";
+            GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+            LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+        }>;
+        conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"CONTAINS">;
-        conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "CONTAINS";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | string[] | number[];
-    }, {
-        conditionType: "CONTAINS";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | string[] | number[];
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>;
+        conditionType: z.ZodEnum<{
+            STARTS_WITH: "STARTS_WITH";
+            ENDS_WITH: "ENDS_WITH";
+        }>;
         conditionValue: z.ZodString;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "STARTS_WITH" | "ENDS_WITH";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }, {
-        conditionType: "STARTS_WITH" | "ENDS_WITH";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"NULL">;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "NULL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "NULL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["TRUE", "FALSE"]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "TRUE" | "FALSE";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "TRUE" | "FALSE";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodEnum<{
+            TRUE: "TRUE";
+            FALSE: "FALSE";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"EMPTY">;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "EMPTY";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "EMPTY";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["PATTERN"]>;
+        conditionType: z.ZodEnum<{
+            PATTERN: "PATTERN";
+        }>;
         conditionValue: z.ZodString;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }, {
-        conditionType: "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }>, z.ZodType<unknown, z.ZodTypeDef, unknown>]>, "many">;
-    proposedDataConditions: z.ZodArray<z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+    proposedDataConditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"TYPEOF">;
-        conditionValue: z.ZodEnum<["STRING", "NUMBER", "INTEGER", "BOOLEAN", "OBJECT", "ARRAY", "NULL", "UNDEFINED", "FUNCTION", "BIGINT"]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "TYPEOF";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-    }, {
-        conditionType: "TYPEOF";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodEnum<{
+            NULL: "NULL";
+            STRING: "STRING";
+            NUMBER: "NUMBER";
+            INTEGER: "INTEGER";
+            BOOLEAN: "BOOLEAN";
+            OBJECT: "OBJECT";
+            ARRAY: "ARRAY";
+            UNDEFINED: "UNDEFINED";
+            FUNCTION: "FUNCTION";
+            BIGINT: "BIGINT";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"EQUAL">;
-        conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }, {
-        conditionType: "EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>;
-        conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }, {
-        conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodEnum<{
+            GREATER_THAN: "GREATER_THAN";
+            LESS_THAN: "LESS_THAN";
+            GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+            LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+        }>;
+        conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"CONTAINS">;
-        conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "CONTAINS";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | string[] | number[];
-    }, {
-        conditionType: "CONTAINS";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | string[] | number[];
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>;
+        conditionType: z.ZodEnum<{
+            STARTS_WITH: "STARTS_WITH";
+            ENDS_WITH: "ENDS_WITH";
+        }>;
         conditionValue: z.ZodString;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "STARTS_WITH" | "ENDS_WITH";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }, {
-        conditionType: "STARTS_WITH" | "ENDS_WITH";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"NULL">;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "NULL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "NULL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["TRUE", "FALSE"]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "TRUE" | "FALSE";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "TRUE" | "FALSE";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodEnum<{
+            TRUE: "TRUE";
+            FALSE: "FALSE";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"EMPTY">;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "EMPTY";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "EMPTY";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["PATTERN"]>;
+        conditionType: z.ZodEnum<{
+            PATTERN: "PATTERN";
+        }>;
         conditionValue: z.ZodString;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }, {
-        conditionType: "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }>, z.ZodType<unknown, z.ZodTypeDef, unknown>]>, "many">;
-}, "strip", z.ZodTypeAny, {
-    ruleId: string;
-    currentDataConditions: unknown[];
-    proposedDataConditions: unknown[];
-}, {
-    ruleId: string;
-    currentDataConditions: unknown[];
-    proposedDataConditions: unknown[];
-}>;
+    }, z.core.$strip>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+}, z.core.$strip>;
 export interface IShareRule {
     ruleId: string;
     currentDataConditions: ICondition[];
@@ -843,311 +703,222 @@ export interface IShareRule {
 /**
  * This contains the applied rule informaiton in the share data object.
  */
-export declare const IShareRuleAppliedSchema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const IShareRuleAppliedSchema: z.ZodObject<{
     ruleId: z.ZodString;
-    currentDataConditions: z.ZodArray<z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    currentDataConditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"TYPEOF">;
-        conditionValue: z.ZodEnum<["STRING", "NUMBER", "INTEGER", "BOOLEAN", "OBJECT", "ARRAY", "NULL", "UNDEFINED", "FUNCTION", "BIGINT"]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "TYPEOF";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-    }, {
-        conditionType: "TYPEOF";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodEnum<{
+            NULL: "NULL";
+            STRING: "STRING";
+            NUMBER: "NUMBER";
+            INTEGER: "INTEGER";
+            BOOLEAN: "BOOLEAN";
+            OBJECT: "OBJECT";
+            ARRAY: "ARRAY";
+            UNDEFINED: "UNDEFINED";
+            FUNCTION: "FUNCTION";
+            BIGINT: "BIGINT";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"EQUAL">;
-        conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }, {
-        conditionType: "EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>;
-        conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }, {
-        conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodEnum<{
+            GREATER_THAN: "GREATER_THAN";
+            LESS_THAN: "LESS_THAN";
+            GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+            LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+        }>;
+        conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"CONTAINS">;
-        conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "CONTAINS";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | string[] | number[];
-    }, {
-        conditionType: "CONTAINS";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | string[] | number[];
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>;
+        conditionType: z.ZodEnum<{
+            STARTS_WITH: "STARTS_WITH";
+            ENDS_WITH: "ENDS_WITH";
+        }>;
         conditionValue: z.ZodString;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "STARTS_WITH" | "ENDS_WITH";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }, {
-        conditionType: "STARTS_WITH" | "ENDS_WITH";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"NULL">;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "NULL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "NULL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["TRUE", "FALSE"]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "TRUE" | "FALSE";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "TRUE" | "FALSE";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodEnum<{
+            TRUE: "TRUE";
+            FALSE: "FALSE";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"EMPTY">;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "EMPTY";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "EMPTY";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["PATTERN"]>;
+        conditionType: z.ZodEnum<{
+            PATTERN: "PATTERN";
+        }>;
         conditionValue: z.ZodString;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }, {
-        conditionType: "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }>, z.ZodType<unknown, z.ZodTypeDef, unknown>]>, "many">;
-    proposedDataConditions: z.ZodArray<z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+    proposedDataConditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"TYPEOF">;
-        conditionValue: z.ZodEnum<["STRING", "NUMBER", "INTEGER", "BOOLEAN", "OBJECT", "ARRAY", "NULL", "UNDEFINED", "FUNCTION", "BIGINT"]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "TYPEOF";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-    }, {
-        conditionType: "TYPEOF";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: "NULL" | "STRING" | "NUMBER" | "INTEGER" | "BOOLEAN" | "OBJECT" | "ARRAY" | "UNDEFINED" | "FUNCTION" | "BIGINT";
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodEnum<{
+            NULL: "NULL";
+            STRING: "STRING";
+            NUMBER: "NUMBER";
+            INTEGER: "INTEGER";
+            BOOLEAN: "BOOLEAN";
+            OBJECT: "OBJECT";
+            ARRAY: "ARRAY";
+            UNDEFINED: "UNDEFINED";
+            FUNCTION: "FUNCTION";
+            BIGINT: "BIGINT";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"EQUAL">;
-        conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }, {
-        conditionType: "EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>;
-        conditionValue: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }, {
-        conditionType: "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | number;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodEnum<{
+            GREATER_THAN: "GREATER_THAN";
+            LESS_THAN: "LESS_THAN";
+            GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+            LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+        }>;
+        conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"CONTAINS">;
-        conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "CONTAINS";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | string[] | number[];
-    }, {
-        conditionType: "CONTAINS";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string | string[] | number[];
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>;
+        conditionType: z.ZodEnum<{
+            STARTS_WITH: "STARTS_WITH";
+            ENDS_WITH: "ENDS_WITH";
+        }>;
         conditionValue: z.ZodString;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "STARTS_WITH" | "ENDS_WITH";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }, {
-        conditionType: "STARTS_WITH" | "ENDS_WITH";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"NULL">;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "NULL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "NULL";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["TRUE", "FALSE"]>;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "TRUE" | "FALSE";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "TRUE" | "FALSE";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodEnum<{
+            TRUE: "TRUE";
+            FALSE: "FALSE";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
         conditionType: z.ZodLiteral<"EMPTY">;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "EMPTY";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "EMPTY";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, z.ZodObject<z.objectUtil.extendShape<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+    }, z.core.$strip>, z.ZodObject<{
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, {
-        conditionType: z.ZodEnum<["PATTERN"]>;
+        conditionType: z.ZodEnum<{
+            PATTERN: "PATTERN";
+        }>;
         conditionValue: z.ZodString;
-    }>, "strip", z.ZodTypeAny, {
-        conditionType: "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }, {
-        conditionType: "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-        conditionValue: string;
-    }>, z.ZodType<unknown, z.ZodTypeDef, unknown>]>, "many">;
-}, {
+    }, z.core.$strip>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     targettedProperty: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
-    targettedProperty: string;
-    ruleId: string;
-    currentDataConditions: unknown[];
-    proposedDataConditions: unknown[];
-}, {
-    targettedProperty: string;
-    ruleId: string;
-    currentDataConditions: unknown[];
-    proposedDataConditions: unknown[];
-}>;
+}, z.core.$strip>;
+/**
+ * Example of IShareRuleAppliedSchema:
+ *
+const exampleShareRuleApplied: IShareRuleApplied = {
+    ruleId: 'rule1',
+    currentDataConditions: [
+        {
+            conditionType: ConditionTypeSingle.EQUAL,
+            conditionTypeQualifier: ConditionTypeQualifier.IS,
+            targettedProperty: 'property1',
+            conditionValue: 'value1'
+        }
+    ],
+    proposedDataConditions: [
+        {
+            conditionType: ConditionTypeSingle.EQUAL,
+            conditionTypeQualifier: ConditionTypeQualifier.IS,
+            targettedProperty: 'property2',
+            conditionValue: 'value2'
+        }
+    ],
+    targettedProperty: 'property3'
+};
+ */
 export interface IShareRuleApplied extends IShareRule {
     targettedProperty: string;
 }
@@ -1158,61 +929,63 @@ export declare const IShareRuleEvalutionResultSchema: z.ZodObject<{
     ruleId: z.ZodString;
     currentResult: z.ZodBoolean;
     currentConditionFailure: z.ZodArray<z.ZodObject<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodUnion<readonly [z.ZodEnum<{
+            TYPEOF: "TYPEOF";
+            EQUAL: "EQUAL";
+            CONTAINS: "CONTAINS";
+            NULL: "NULL";
+            EMPTY: "EMPTY";
+            SHARE_RULE: "SHARE_RULE";
+        }>, z.ZodEnum<{
+            GREATER_THAN: "GREATER_THAN";
+            LESS_THAN: "LESS_THAN";
+            GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+            LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+        }>, z.ZodEnum<{
+            STARTS_WITH: "STARTS_WITH";
+            ENDS_WITH: "ENDS_WITH";
+        }>, z.ZodEnum<{
+            TRUE: "TRUE";
+            FALSE: "FALSE";
+        }>, z.ZodEnum<{
+            PATTERN: "PATTERN";
+        }>]>;
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, "many">;
+    }, z.core.$strip>>;
     proposedResult: z.ZodBoolean;
     proposedConditionFailure: z.ZodArray<z.ZodObject<{
-        conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-        conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+        conditionType: z.ZodUnion<readonly [z.ZodEnum<{
+            TYPEOF: "TYPEOF";
+            EQUAL: "EQUAL";
+            CONTAINS: "CONTAINS";
+            NULL: "NULL";
+            EMPTY: "EMPTY";
+            SHARE_RULE: "SHARE_RULE";
+        }>, z.ZodEnum<{
+            GREATER_THAN: "GREATER_THAN";
+            LESS_THAN: "LESS_THAN";
+            GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+            LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+        }>, z.ZodEnum<{
+            STARTS_WITH: "STARTS_WITH";
+            ENDS_WITH: "ENDS_WITH";
+        }>, z.ZodEnum<{
+            TRUE: "TRUE";
+            FALSE: "FALSE";
+        }>, z.ZodEnum<{
+            PATTERN: "PATTERN";
+        }>]>;
+        conditionTypeQualifier: z.ZodEnum<{
+            IS: "IS";
+            IS_NOT: "IS_NOT";
+        }>;
         targettedProperty: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }, {
-        conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    ruleId: string;
-    currentResult: boolean;
-    currentConditionFailure: {
-        conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }[];
-    proposedResult: boolean;
-    proposedConditionFailure: {
-        conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }[];
-}, {
-    ruleId: string;
-    currentResult: boolean;
-    currentConditionFailure: {
-        conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }[];
-    proposedResult: boolean;
-    proposedConditionFailure: {
-        conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-        conditionTypeQualifier: "IS" | "IS_NOT";
-        targettedProperty: string;
-    }[];
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export interface IShareRuleEvalutionResult {
     ruleId: string;
     currentResult: boolean;
@@ -1231,100 +1004,64 @@ export declare const IShareRulesEvaluationResultSchema: z.ZodObject<{
         ruleId: z.ZodString;
         currentResult: z.ZodBoolean;
         currentConditionFailure: z.ZodArray<z.ZodObject<{
-            conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-            conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+            conditionType: z.ZodUnion<readonly [z.ZodEnum<{
+                TYPEOF: "TYPEOF";
+                EQUAL: "EQUAL";
+                CONTAINS: "CONTAINS";
+                NULL: "NULL";
+                EMPTY: "EMPTY";
+                SHARE_RULE: "SHARE_RULE";
+            }>, z.ZodEnum<{
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+                GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+                LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+            }>, z.ZodEnum<{
+                STARTS_WITH: "STARTS_WITH";
+                ENDS_WITH: "ENDS_WITH";
+            }>, z.ZodEnum<{
+                TRUE: "TRUE";
+                FALSE: "FALSE";
+            }>, z.ZodEnum<{
+                PATTERN: "PATTERN";
+            }>]>;
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
             targettedProperty: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }, {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }>, "many">;
+        }, z.core.$strip>>;
         proposedResult: z.ZodBoolean;
         proposedConditionFailure: z.ZodArray<z.ZodObject<{
-            conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-            conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+            conditionType: z.ZodUnion<readonly [z.ZodEnum<{
+                TYPEOF: "TYPEOF";
+                EQUAL: "EQUAL";
+                CONTAINS: "CONTAINS";
+                NULL: "NULL";
+                EMPTY: "EMPTY";
+                SHARE_RULE: "SHARE_RULE";
+            }>, z.ZodEnum<{
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+                GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+                LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+            }>, z.ZodEnum<{
+                STARTS_WITH: "STARTS_WITH";
+                ENDS_WITH: "ENDS_WITH";
+            }>, z.ZodEnum<{
+                TRUE: "TRUE";
+                FALSE: "FALSE";
+            }>, z.ZodEnum<{
+                PATTERN: "PATTERN";
+            }>]>;
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
             targettedProperty: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }, {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        ruleId: string;
-        currentResult: boolean;
-        currentConditionFailure: {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }[];
-        proposedResult: boolean;
-        proposedConditionFailure: {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }[];
-    }, {
-        ruleId: string;
-        currentResult: boolean;
-        currentConditionFailure: {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }[];
-        proposedResult: boolean;
-        proposedConditionFailure: {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }[];
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    rootParam: string;
-    passedRuleCheck: boolean;
-    passedRuleId: string;
-    shareRuleEvalutionResults: {
-        ruleId: string;
-        currentResult: boolean;
-        currentConditionFailure: {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }[];
-        proposedResult: boolean;
-        proposedConditionFailure: {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }[];
-    }[];
-}, {
-    rootParam: string;
-    passedRuleCheck: boolean;
-    passedRuleId: string;
-    shareRuleEvalutionResults: {
-        ruleId: string;
-        currentResult: boolean;
-        currentConditionFailure: {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }[];
-        proposedResult: boolean;
-        proposedConditionFailure: {
-            conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-            conditionTypeQualifier: "IS" | "IS_NOT";
-            targettedProperty: string;
-        }[];
-    }[];
-}>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export interface IShareRulesEvaluationResult {
     rootParam: string;
     passedRuleCheck: boolean;
@@ -1344,148 +1081,66 @@ export declare const IRuleEvaluationResultsSchema: z.ZodObject<{
             ruleId: z.ZodString;
             currentResult: z.ZodBoolean;
             currentConditionFailure: z.ZodArray<z.ZodObject<{
-                conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-                conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+                conditionType: z.ZodUnion<readonly [z.ZodEnum<{
+                    TYPEOF: "TYPEOF";
+                    EQUAL: "EQUAL";
+                    CONTAINS: "CONTAINS";
+                    NULL: "NULL";
+                    EMPTY: "EMPTY";
+                    SHARE_RULE: "SHARE_RULE";
+                }>, z.ZodEnum<{
+                    GREATER_THAN: "GREATER_THAN";
+                    LESS_THAN: "LESS_THAN";
+                    GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+                    LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+                }>, z.ZodEnum<{
+                    STARTS_WITH: "STARTS_WITH";
+                    ENDS_WITH: "ENDS_WITH";
+                }>, z.ZodEnum<{
+                    TRUE: "TRUE";
+                    FALSE: "FALSE";
+                }>, z.ZodEnum<{
+                    PATTERN: "PATTERN";
+                }>]>;
+                conditionTypeQualifier: z.ZodEnum<{
+                    IS: "IS";
+                    IS_NOT: "IS_NOT";
+                }>;
                 targettedProperty: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }, {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }>, "many">;
+            }, z.core.$strip>>;
             proposedResult: z.ZodBoolean;
             proposedConditionFailure: z.ZodArray<z.ZodObject<{
-                conditionType: z.ZodUnion<[z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>, z.ZodEnum<["GREATER_THAN", "LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL"]>, z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>, z.ZodEnum<["TRUE", "FALSE"]>, z.ZodEnum<["PATTERN"]>]>;
-                conditionTypeQualifier: z.ZodEnum<["IS", "IS_NOT"]>;
+                conditionType: z.ZodUnion<readonly [z.ZodEnum<{
+                    TYPEOF: "TYPEOF";
+                    EQUAL: "EQUAL";
+                    CONTAINS: "CONTAINS";
+                    NULL: "NULL";
+                    EMPTY: "EMPTY";
+                    SHARE_RULE: "SHARE_RULE";
+                }>, z.ZodEnum<{
+                    GREATER_THAN: "GREATER_THAN";
+                    LESS_THAN: "LESS_THAN";
+                    GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+                    LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+                }>, z.ZodEnum<{
+                    STARTS_WITH: "STARTS_WITH";
+                    ENDS_WITH: "ENDS_WITH";
+                }>, z.ZodEnum<{
+                    TRUE: "TRUE";
+                    FALSE: "FALSE";
+                }>, z.ZodEnum<{
+                    PATTERN: "PATTERN";
+                }>]>;
+                conditionTypeQualifier: z.ZodEnum<{
+                    IS: "IS";
+                    IS_NOT: "IS_NOT";
+                }>;
                 targettedProperty: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }, {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            ruleId: string;
-            currentResult: boolean;
-            currentConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-            proposedResult: boolean;
-            proposedConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-        }, {
-            ruleId: string;
-            currentResult: boolean;
-            currentConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-            proposedResult: boolean;
-            proposedConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        rootParam: string;
-        passedRuleCheck: boolean;
-        passedRuleId: string;
-        shareRuleEvalutionResults: {
-            ruleId: string;
-            currentResult: boolean;
-            currentConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-            proposedResult: boolean;
-            proposedConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-        }[];
-    }, {
-        rootParam: string;
-        passedRuleCheck: boolean;
-        passedRuleId: string;
-        shareRuleEvalutionResults: {
-            ruleId: string;
-            currentResult: boolean;
-            currentConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-            proposedResult: boolean;
-            proposedConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-        }[];
-    }>, "many">;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     isValidProposal: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    shareDataId: string;
-    rulesResults: {
-        rootParam: string;
-        passedRuleCheck: boolean;
-        passedRuleId: string;
-        shareRuleEvalutionResults: {
-            ruleId: string;
-            currentResult: boolean;
-            currentConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-            proposedResult: boolean;
-            proposedConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-        }[];
-    }[];
-    isValidProposal: boolean;
-}, {
-    shareDataId: string;
-    rulesResults: {
-        rootParam: string;
-        passedRuleCheck: boolean;
-        passedRuleId: string;
-        shareRuleEvalutionResults: {
-            ruleId: string;
-            currentResult: boolean;
-            currentConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-            proposedResult: boolean;
-            proposedConditionFailure: {
-                conditionType: "TYPEOF" | "EQUAL" | "CONTAINS" | "NULL" | "EMPTY" | "SHARE_RULE" | "GREATER_THAN" | "LESS_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN_OR_EQUAL" | "STARTS_WITH" | "ENDS_WITH" | "TRUE" | "FALSE" | "PATTERN";
-                conditionTypeQualifier: "IS" | "IS_NOT";
-                targettedProperty: string;
-            }[];
-        }[];
-    }[];
-    isValidProposal: boolean;
-}>;
+}, z.core.$strip>;
 export interface IRuleEvaluationResults {
     shareDataId: string;
     rulesResults: IShareRulesEvaluationResult[];
@@ -1503,21 +1158,9 @@ export declare const IShareRuleSetSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
     name: z.ZodString;
-    ruleGroups: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+    ruleGroups: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
     version: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    name: string;
-    ruleGroups: unknown[];
-    version: number;
-    description?: string | undefined;
-}, {
-    id: string;
-    name: string;
-    ruleGroups: unknown[];
-    version: number;
-    description?: string | undefined;
-}>;
+}, z.core.$strip>;
 export interface IShareRuleSet {
     description?: string;
     id: string;