@degenerate/generic 0.1.11 → 0.1.12

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

@@ -0,0 +1,1528 @@
+import z from 'zod';
+/**
+ * This file contains the models for the rules used in the share data.
+ */
+/**
+ * This contains the logical operators for combining rules.
+ */
+export declare enum LogicalOperator {
+    AND = "AND",
+    OR = "OR"
+}
+export declare const LogicalOperatorSchema: z.ZodEnum<["AND", "OR"]>;
+/**
+ * This contains the choices for the type of qualifier.
+ */
+export declare enum ConditionTypeQualifier {
+    IS = "IS",
+    IS_NOT = "IS_NOT"
+}
+export declare const ConditionTypeQualifierSchema: z.ZodEnum<["IS", "IS_NOT"]>;
+/**
+ * This contains the choices for the type of condition.
+ */
+export declare enum ConditionTypeSingle {
+    TYPEOF = "TYPEOF",// the type of the property
+    EQUAL = "EQUAL",// the value is equal to the condition value
+    CONTAINS = "CONTAINS",// the value contains the condition value
+    NULL = "NULL",// the value is null
+    EMPTY = "EMPTY",// the value is empty
+    SHARE_RULE = "SHARE_RULE"
+}
+export declare const ConditionTypeSingleSchema: z.ZodEnum<["TYPEOF", "EQUAL", "CONTAINS", "NULL", "EMPTY", "SHARE_RULE"]>;
+/**
+ * This contains the choices for the range conditions.
+ */
+export declare enum ConditionTypeRange {
+    GREATER_THAN = "GREATER_THAN",
+    LESS_THAN = "LESS_THAN",
+    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"]>;
+/**
+ * This contains the choices for the starts with and ends with conditions.
+ */
+export declare enum ConditionTypeStartsEndsWith {
+    STARTS_WITH = "STARTS_WITH",
+    ENDS_WITH = "ENDS_WITH"
+}
+export declare const ConditionTypeStartsEndsWithSchema: z.ZodEnum<["STARTS_WITH", "ENDS_WITH"]>;
+/**
+ * This contains the choices for the boolean conditions.
+ */
+export declare enum ConditionTypeBoolean {
+    TRUE = "TRUE",
+    FALSE = "FALSE"
+}
+export declare const ConditionTypeBooleanSchema: z.ZodEnum<["TRUE", "FALSE"]>;
+/**
+ * This contains the choices for the special conditions.
+ */
+export declare enum ConditionTypeSpecial {
+    PATTERN = "PATTERN"
+}
+export declare const ConditionTypeSpecialSchema: z.ZodEnum<["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"]>]>;
+/**
+ * These are the different choices for the types of data in a condition.
+ */
+export declare enum ConditionTypeOf {
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    INTEGER = "INTEGER",
+    BOOLEAN = "BOOLEAN",
+    OBJECT = "OBJECT",
+    ARRAY = "ARRAY",
+    NULL = "NULL",
+    UNDEFINED = "UNDEFINED",
+    FUNCTION = "FUNCTION",
+    BIGINT = "BIGINT"
+}
+export declare const ConditionTypeOfSchema: z.ZodEnum<["STRING", "NUMBER", "INTEGER", "BOOLEAN", "OBJECT", "ARRAY", "NULL", "UNDEFINED", "FUNCTION", "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"]>;
+    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;
+}>;
+export interface IConditionBase {
+    conditionType: ConditionType;
+    conditionTypeQualifier: ConditionTypeQualifier;
+    targettedProperty: string;
+}
+/**
+ * This is the interface for the type of condition.
+ *
+const exampleConditionTypeOf: IConditionTypeOf = {
+    conditionType: ConditionTypeSingle.TYPEOF,
+    ConditionTypeQualifier: ConditionTypeQualifier.IS,
+    conditionValue: ConditionTypeOf.NUMBER,
+    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"]>;
+    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";
+}>;
+export interface IConditionTypeOf extends IConditionBase {
+    conditionType: ConditionTypeSingle.TYPEOF;
+    conditionValue: ConditionTypeOf;
+}
+/**
+ * This is the interface for the equality condition.
+ *
+const exampleConditionEquality: IConditionEquality = {
+    conditionType: ConditionTypeSingle.EQUAL,
+    ConditionTypeQualifier: ConditionTypeQualifier.IS,
+    conditionValue: 100,
+    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"]>;
+    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;
+}>;
+export interface IConditionEquality extends IConditionBase {
+    conditionType: ConditionTypeSingle.EQUAL;
+    conditionValue: number | string;
+}
+/**
+ * This is the interface for the range condition.
+ *
+const exampleConditionRange: IConditionRange = {
+    conditionType: ConditionTypeRange.GREATER_THAN,
+    ConditionTypeQualifier: ConditionTypeQualifier.IS,
+    conditionValue: 100,
+    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"]>;
+    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;
+}>;
+export interface IConditionRange extends IConditionBase {
+    conditionType: ConditionTypeRange;
+    conditionValue: number | string;
+}
+/**
+ * This is the interface for the contains condition.
+ *
+const exampleConditionContains: IConditionContains = {
+    conditionType: ConditionTypeSingle.CONTAINS,
+    conditionTypeQualifier: ConditionTypeQualifier.IS,
+    conditionValue: ['gar'| 'garison' | 'garage']
+    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"]>;
+    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[];
+}>;
+export interface IConditionContains extends IConditionBase {
+    conditionType: ConditionTypeSingle.CONTAINS;
+    conditionValue: string | string[] | number[];
+}
+/**
+ * This is the interface for the starts with and ends with condition.
+ *
+const exampleConditionStartsEndsWith: IConditionStartsEndsWith = {
+    conditionType: ConditionTypeStartsEndsWith.STARTS_WITH,
+    conditionTypeQualifier: ConditionTypeQualifier.IS,
+    conditionValue: 'cal'
+    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"]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<["STARTS_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;
+}>;
+export interface IConditionStartsEndsWith extends IConditionBase {
+    conditionType: ConditionTypeStartsEndsWith;
+    conditionValue: string;
+}
+/**
+ * This is the interface for the null condition.
+ *
+const exampleConditionNull: IConditionNull = {
+    conditionType: ConditionTypeSingle.NULL
+    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"]>;
+    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;
+}>;
+export interface IConditionNull extends IConditionBase {
+    conditionType: ConditionTypeSingle.NULL;
+}
+/**
+ * This is the interface for the boolean condition.
+ *
+const exampleConditionBoolean: IConditionBoolean = {
+    conditionType: ConditionTypeBoolean.TRUE,
+    conditionTypeQualifier: ConditionTypeQualifier.IS,
+    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"]>;
+    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;
+}>;
+export interface IConditionBoolean extends IConditionBase {
+    conditionType: ConditionTypeBoolean;
+}
+/**
+ * This is the interface for the empty condition.
+ *
+const exampleConditionEmpty: IConditionEmpty = {
+    conditionType: ConditionTypeEmpty.IS_EMPTY,
+    conditionTypeQualifier: ConditionTypeQualifier.IS,
+    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"]>;
+    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;
+}>;
+export interface IConditionEmpty extends IConditionBase {
+    conditionType: ConditionTypeSingle.EMPTY;
+}
+/**
+ * This is the interface for the special condition.
+ *
+const exampleConditionSpecial: IConditionSpecial = {
+    conditionType: ConditionTypeSpecial.PATTERN,
+    conditionTypeQualifier: ConditionTypeQualifier.IS,
+    conditionValue: '^[a-zA-Z0-9]*$'
+    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"]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<["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;
+}>;
+export interface IConditionSpecial extends IConditionBase {
+    conditionType: ConditionTypeSpecial;
+    conditionValue: string;
+}
+export declare const IConditionShareRuleSchema: z.ZodType<unknown>;
+export interface IConditionShareRule extends IConditionBase {
+    conditionType: ConditionTypeSingle.SHARE_RULE;
+    conditionValue: IShareRule;
+}
+/**
+ * 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"]>;
+    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"]>;
+    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"]>;
+    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"]>;
+    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"]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<["STARTS_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"]>;
+    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"]>;
+    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"]>;
+    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"]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<["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>]>;
+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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        targettedProperty: z.ZodString;
+    }, {
+        conditionType: z.ZodEnum<["STARTS_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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        targettedProperty: z.ZodString;
+    }, {
+        conditionType: z.ZodEnum<["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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        targettedProperty: z.ZodString;
+    }, {
+        conditionType: z.ZodEnum<["STARTS_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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        targettedProperty: z.ZodString;
+    }, {
+        conditionType: z.ZodEnum<["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[];
+}>;
+export interface IShareRule {
+    ruleId: string;
+    currentDataConditions: ICondition[];
+    proposedDataConditions: ICondition[];
+}
+/**
+ * This contains the applied rule informaiton in the share data object.
+ */
+export declare const IShareRuleAppliedSchema: z.ZodObject<z.objectUtil.extendShape<{
+    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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        targettedProperty: z.ZodString;
+    }, {
+        conditionType: z.ZodEnum<["STARTS_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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        targettedProperty: z.ZodString;
+    }, {
+        conditionType: z.ZodEnum<["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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        targettedProperty: z.ZodString;
+    }, {
+        conditionType: z.ZodEnum<["STARTS_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"]>;
+        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"]>;
+        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"]>;
+        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"]>;
+        targettedProperty: z.ZodString;
+    }, {
+        conditionType: z.ZodEnum<["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">;
+}, {
+    targettedProperty: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    targettedProperty: string;
+    ruleId: string;
+    currentDataConditions: unknown[];
+    proposedDataConditions: unknown[];
+}, {
+    targettedProperty: string;
+    ruleId: string;
+    currentDataConditions: unknown[];
+    proposedDataConditions: unknown[];
+}>;
+export interface IShareRuleApplied extends IShareRule {
+    targettedProperty: string;
+}
+/**
+ * This contains the interface for the rule evaluation.
+ */
+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"]>;
+        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">;
+    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"]>;
+        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;
+    }[];
+}>;
+export interface IShareRuleEvalutionResult {
+    ruleId: string;
+    currentResult: boolean;
+    currentConditionFailure: IConditionBase[];
+    proposedResult: boolean;
+    proposedConditionFailure: IConditionBase[];
+}
+/**
+ * This contains the interface for the rule evaluation.
+ */
+export declare const IShareRulesEvaluationResultSchema: z.ZodObject<{
+    rootParam: z.ZodString;
+    passedRuleCheck: z.ZodBoolean;
+    passedRuleId: z.ZodString;
+    shareRuleEvalutionResults: z.ZodArray<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"]>;
+            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">;
+        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"]>;
+            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;
+        }[];
+    }[];
+}>;
+export interface IShareRulesEvaluationResult {
+    rootParam: string;
+    passedRuleCheck: boolean;
+    passedRuleId: string;
+    shareRuleEvalutionResults: IShareRuleEvalutionResult[];
+}
+/**
+ * This contains the interface for the rule evaluation results.
+ */
+export declare const IRuleEvaluationResultsSchema: z.ZodObject<{
+    shareDataId: z.ZodString;
+    rulesResults: z.ZodArray<z.ZodObject<{
+        rootParam: z.ZodString;
+        passedRuleCheck: z.ZodBoolean;
+        passedRuleId: z.ZodString;
+        shareRuleEvalutionResults: z.ZodArray<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"]>;
+                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">;
+            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"]>;
+                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">;
+    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;
+}>;
+export interface IRuleEvaluationResults {
+    shareDataId: string;
+    rulesResults: IShareRulesEvaluationResult[];
+    isValidProposal: boolean;
+}
+export declare const IShareRuleGroupSchema: z.ZodType<unknown>;
+export interface IShareRuleGroup {
+    operator: LogicalOperator;
+    rules: (IShareRuleApplied | IShareRuleGroup)[];
+}
+/**
+ * This contains the interface for the rule set in the share data object
+ */
+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">;
+    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;
+}>;
+export interface IShareRuleSet {
+    description?: string;
+    id: string;
+    name: string;
+    ruleGroups: IShareRuleGroup[];
+    version: number;
+}
+//# sourceMappingURL=share-rule-models.d.ts.map