@degenerate/endpoints 0.0.9 → 0.0.11

package/dist/schema/rules/rules-conditions.schema.d.ts

@@ -0,0 +1,402 @@
+import { ConditionTypeSpecial, ConditionTypeSingle } from '@degenerate/generic';
+import { z } from 'zod';
+/**
+ * This is the base schema for all conditions.
+ */
+export declare const IConditionBaseSchema: z.ZodObject<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle | import("@degenerate/generic").ConditionTypeRange | import("@degenerate/generic").ConditionTypeStartsEndsWith | import("@degenerate/generic").ConditionTypeBoolean | ConditionTypeSpecial;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}, {
+    conditionType: ConditionTypeSingle | import("@degenerate/generic").ConditionTypeRange | import("@degenerate/generic").ConditionTypeStartsEndsWith | import("@degenerate/generic").ConditionTypeBoolean | ConditionTypeSpecial;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}>;
+/**
+ * This is the schema for the special condition.
+ */
+export declare const IConditionSpecialSchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSpecial>;
+    conditionValue: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSpecial;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string;
+}, {
+    conditionType: ConditionTypeSpecial;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string;
+}>;
+/**
+ * This is the schema for the empty condition.
+ */
+export declare const IConditionEmptySchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.EMPTY>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.EMPTY;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}, {
+    conditionType: ConditionTypeSingle.EMPTY;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}>;
+/**
+ * This is the schema for the boolean condition.
+ */
+export declare const IConditionBooleanSchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: import("@degenerate/generic").ConditionTypeBoolean;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}, {
+    conditionType: import("@degenerate/generic").ConditionTypeBoolean;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}>;
+/**
+ * This is the schema for the null condition.
+ */
+export declare const IConditionNullSchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.NULL>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.NULL;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}, {
+    conditionType: ConditionTypeSingle.NULL;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}>;
+/**
+ * This is the schema for the starts with and ends with condition.
+ */
+export declare const IConditionStartsEndsWithSchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>;
+    conditionValue: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: import("@degenerate/generic").ConditionTypeStartsEndsWith;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string;
+}, {
+    conditionType: import("@degenerate/generic").ConditionTypeStartsEndsWith;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string;
+}>;
+/**
+ * This is the schema for the contains condition.
+ */
+export declare const IConditionContainsSchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.CONTAINS>;
+    conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.CONTAINS;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | string[] | number[];
+}, {
+    conditionType: ConditionTypeSingle.CONTAINS;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | string[] | number[];
+}>;
+/**
+ * This is the schema for the range condition.
+ */
+export declare const IConditionRangeSchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>;
+    conditionValue: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: import("@degenerate/generic").ConditionTypeRange;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | number;
+}, {
+    conditionType: import("@degenerate/generic").ConditionTypeRange;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | number;
+}>;
+/**
+ * This is the schema for the equality condition.
+ */
+export declare const IConditionEqualitySchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.EQUAL>;
+    conditionValue: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.EQUAL;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | number;
+}, {
+    conditionType: ConditionTypeSingle.EQUAL;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | number;
+}>;
+/**
+ * This is the schema for the type of condition.
+ */
+export declare const IConditionTypeOfSchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.TYPEOF>;
+    conditionValue: z.ZodEnum<[import("@degenerate/generic").ConditionTypeOf.STRING, import("@degenerate/generic").ConditionTypeOf.NUMBER, import("@degenerate/generic").ConditionTypeOf.INTEGER, import("@degenerate/generic").ConditionTypeOf.BOOLEAN, import("@degenerate/generic").ConditionTypeOf.OBJECT, import("@degenerate/generic").ConditionTypeOf.ARRAY, import("@degenerate/generic").ConditionTypeOf.NULL, import("@degenerate/generic").ConditionTypeOf.UNDEFINED, import("@degenerate/generic").ConditionTypeOf.FUNCTION, import("@degenerate/generic").ConditionTypeOf.BIGINT]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.TYPEOF;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: import("@degenerate/generic").ConditionTypeOf;
+}, {
+    conditionType: ConditionTypeSingle.TYPEOF;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: import("@degenerate/generic").ConditionTypeOf;
+}>;
+/**
+ * This is the schema for the share rule condition.
+ */
+export declare const IConditionShareRuleSchema: z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.SHARE_RULE>;
+    conditionValue: z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.SHARE_RULE;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue?: any;
+}, {
+    conditionType: ConditionTypeSingle.SHARE_RULE;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue?: any;
+}>;
+/**
+ * This is the interface for the condition.
+ */
+export type IConditionTypeOf = z.infer<typeof IConditionTypeOfSchema>;
+export type IConditionEquality = z.infer<typeof IConditionEqualitySchema>;
+export type IConditionRange = z.infer<typeof IConditionRangeSchema>;
+export type IConditionContains = z.infer<typeof IConditionContainsSchema>;
+export type IConditionStartsEndsWith = z.infer<typeof IConditionStartsEndsWithSchema>;
+export type IConditionNull = z.infer<typeof IConditionNullSchema>;
+export type IConditionBoolean = z.infer<typeof IConditionBooleanSchema>;
+export type IConditionEmpty = z.infer<typeof IConditionEmptySchema>;
+export type IConditionShareRule = z.infer<typeof IConditionShareRuleSchema>;
+export type IConditionSpecial = z.infer<typeof IConditionSpecialSchema>;
+/**
+ * This is the union of all the conditions.
+ */
+export declare const IConditionSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.TYPEOF>;
+    conditionValue: z.ZodEnum<[import("@degenerate/generic").ConditionTypeOf.STRING, import("@degenerate/generic").ConditionTypeOf.NUMBER, import("@degenerate/generic").ConditionTypeOf.INTEGER, import("@degenerate/generic").ConditionTypeOf.BOOLEAN, import("@degenerate/generic").ConditionTypeOf.OBJECT, import("@degenerate/generic").ConditionTypeOf.ARRAY, import("@degenerate/generic").ConditionTypeOf.NULL, import("@degenerate/generic").ConditionTypeOf.UNDEFINED, import("@degenerate/generic").ConditionTypeOf.FUNCTION, import("@degenerate/generic").ConditionTypeOf.BIGINT]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.TYPEOF;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: import("@degenerate/generic").ConditionTypeOf;
+}, {
+    conditionType: ConditionTypeSingle.TYPEOF;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: import("@degenerate/generic").ConditionTypeOf;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.EQUAL>;
+    conditionValue: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.EQUAL;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | number;
+}, {
+    conditionType: ConditionTypeSingle.EQUAL;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | number;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>;
+    conditionValue: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: import("@degenerate/generic").ConditionTypeRange;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | number;
+}, {
+    conditionType: import("@degenerate/generic").ConditionTypeRange;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | number;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.CONTAINS>;
+    conditionValue: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.CONTAINS;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | string[] | number[];
+}, {
+    conditionType: ConditionTypeSingle.CONTAINS;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string | string[] | number[];
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>;
+    conditionValue: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: import("@degenerate/generic").ConditionTypeStartsEndsWith;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string;
+}, {
+    conditionType: import("@degenerate/generic").ConditionTypeStartsEndsWith;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.NULL>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.NULL;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}, {
+    conditionType: ConditionTypeSingle.NULL;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: import("@degenerate/generic").ConditionTypeBoolean;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}, {
+    conditionType: import("@degenerate/generic").ConditionTypeBoolean;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.EMPTY>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.EMPTY;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}, {
+    conditionType: ConditionTypeSingle.EMPTY;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSingle.SHARE_RULE>;
+    conditionValue: z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSingle.SHARE_RULE;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue?: any;
+}, {
+    conditionType: ConditionTypeSingle.SHARE_RULE;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue?: any;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    conditionType: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeRange.GREATER_THAN, import("@degenerate/generic").ConditionTypeRange.LESS_THAN, import("@degenerate/generic").ConditionTypeRange.GREATER_THAN_OR_EQUAL, import("@degenerate/generic").ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeStartsEndsWith.STARTS_WITH, import("@degenerate/generic").ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[import("@degenerate/generic").ConditionTypeBoolean.TRUE, import("@degenerate/generic").ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+    conditionTypeQualifier: z.ZodEnum<[import("@degenerate/generic").ConditionTypeQualifier.IS, import("@degenerate/generic").ConditionTypeQualifier.IS_NOT]>;
+    targettedProperty: z.ZodString;
+}, {
+    conditionType: z.ZodLiteral<ConditionTypeSpecial>;
+    conditionValue: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    conditionType: ConditionTypeSpecial;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string;
+}, {
+    conditionType: ConditionTypeSpecial;
+    conditionTypeQualifier: import("@degenerate/generic").ConditionTypeQualifier;
+    targettedProperty: string;
+    conditionValue: string;
+}>]>;
+/**
+ * This is the interface for the conditional information in the checks.
+ */
+export type ICondition = z.infer<typeof IConditionSchema>;
+//# sourceMappingURL=rules-conditions.schema.d.ts.map

package/dist/schema/rules/rules-conditions.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules-conditions.schema.d.ts","sourceRoot":"","sources":["../../../src/schema/rules/rules-conditions.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,oBAAoB,EACpB,mBAAmB,EACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;EAGlC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;EAEhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;EAElC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;EAE/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;EAGzC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;EAGnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;EAGhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;EAGnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;EAGpC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAW3B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schema/rules/rules-conditions.schema.js

@@ -0,0 +1,99 @@
+"use strict";
+//#region Conditions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IConditionSchema = exports.IConditionShareRuleSchema = exports.IConditionTypeOfSchema = exports.IConditionEqualitySchema = exports.IConditionRangeSchema = exports.IConditionContainsSchema = exports.IConditionStartsEndsWithSchema = exports.IConditionNullSchema = exports.IConditionBooleanSchema = exports.IConditionEmptySchema = exports.IConditionSpecialSchema = exports.IConditionBaseSchema = void 0;
+const generic_1 = require("@degenerate/generic");
+const zod_1 = require("zod");
+const rules_enums_schema_1 = require("./rules-enums.schema");
+const rules_schema_1 = require("./rules.schema");
+/**
+ * This is the base schema for all conditions.
+ */
+exports.IConditionBaseSchema = zod_1.z.object({
+    conditionType: rules_enums_schema_1.ConditionTypeSchema,
+    conditionTypeQualifier: rules_enums_schema_1.ConditionTypeQualifierSchema,
+    targettedProperty: zod_1.z.string(),
+});
+/**
+ * This is the schema for the special condition.
+ */
+exports.IConditionSpecialSchema = exports.IConditionBaseSchema.extend({
+    conditionType: zod_1.z.literal(generic_1.ConditionTypeSpecial.PATTERN),
+    conditionValue: zod_1.z.string(),
+});
+/**
+ * This is the schema for the empty condition.
+ */
+exports.IConditionEmptySchema = exports.IConditionBaseSchema.extend({
+    conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.EMPTY),
+});
+/**
+ * This is the schema for the boolean condition.
+ */
+exports.IConditionBooleanSchema = exports.IConditionBaseSchema.extend({
+    conditionType: rules_enums_schema_1.ConditionTypeBooleanSchema,
+});
+/**
+ * This is the schema for the null condition.
+ */
+exports.IConditionNullSchema = exports.IConditionBaseSchema.extend({
+    conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.NULL),
+});
+/**
+ * This is the schema for the starts with and ends with condition.
+ */
+exports.IConditionStartsEndsWithSchema = exports.IConditionBaseSchema.extend({
+    conditionType: rules_enums_schema_1.ConditionTypeStartsEndsWithSchema,
+    conditionValue: zod_1.z.string(),
+});
+/**
+ * This is the schema for the contains condition.
+ */
+exports.IConditionContainsSchema = exports.IConditionBaseSchema.extend({
+    conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.CONTAINS),
+    conditionValue: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string()), zod_1.z.array(zod_1.z.number())]),
+});
+/**
+ * This is the schema for the range condition.
+ */
+exports.IConditionRangeSchema = exports.IConditionBaseSchema.extend({
+    conditionType: rules_enums_schema_1.ConditionTypeRangeSchema,
+    conditionValue: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]),
+});
+/**
+ * This is the schema for the equality condition.
+ */
+exports.IConditionEqualitySchema = exports.IConditionBaseSchema.extend({
+    conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.EQUAL),
+    conditionValue: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]),
+});
+/**
+ * This is the schema for the type of condition.
+ */
+exports.IConditionTypeOfSchema = exports.IConditionBaseSchema.extend({
+    conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.TYPEOF),
+    conditionValue: rules_enums_schema_1.ConditionTypeOfSchema,
+});
+/**
+ * This is the schema for the share rule condition.
+ */
+exports.IConditionShareRuleSchema = exports.IConditionBaseSchema.extend({
+    conditionType: zod_1.z.literal(generic_1.ConditionTypeSingle.SHARE_RULE),
+    conditionValue: zod_1.z.lazy(() => rules_schema_1.IShareRuleSchema),
+});
+/**
+ * This is the union of all the conditions.
+ */
+exports.IConditionSchema = zod_1.z.union([
+    exports.IConditionTypeOfSchema,
+    exports.IConditionEqualitySchema,
+    exports.IConditionRangeSchema,
+    exports.IConditionContainsSchema,
+    exports.IConditionStartsEndsWithSchema,
+    exports.IConditionNullSchema,
+    exports.IConditionBooleanSchema,
+    exports.IConditionEmptySchema,
+    exports.IConditionShareRuleSchema,
+    exports.IConditionSpecialSchema,
+]);
+//#endregion Conditions

package/dist/schema/rules/rules-enums.schema.d.ts

@@ -0,0 +1,39 @@
+import { ConditionTypeBoolean, ConditionTypeOf, ConditionTypeQualifier, ConditionTypeRange, ConditionTypeSingle, ConditionTypeSpecial, ConditionTypeStartsEndsWith, LogicalOperator } from '@degenerate/generic';
+import z from 'zod';
+/**
+ * These are the different choices for the types of data in a condition.
+ */
+export declare const ConditionTypeOfSchema: z.ZodEnum<[ConditionTypeOf.STRING, ConditionTypeOf.NUMBER, ConditionTypeOf.INTEGER, ConditionTypeOf.BOOLEAN, ConditionTypeOf.OBJECT, ConditionTypeOf.ARRAY, ConditionTypeOf.NULL, ConditionTypeOf.UNDEFINED, ConditionTypeOf.FUNCTION, ConditionTypeOf.BIGINT]>;
+/**
+ * This contains the choices for the logical operators.
+ */
+export declare const LogicalOperatorSchema: z.ZodEnum<[LogicalOperator.AND, LogicalOperator.OR]>;
+/**
+ * This contains the choices for the type of qualifier.
+ */
+export declare const ConditionTypeQualifierSchema: z.ZodEnum<[ConditionTypeQualifier.IS, ConditionTypeQualifier.IS_NOT]>;
+/**
+ * This contains the choices for the type of condition.
+ */
+export declare const ConditionTypeSingleSchema: z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>;
+/**
+ * This contains the choices for the range conditions.
+ */
+export declare const ConditionTypeRangeSchema: z.ZodEnum<[ConditionTypeRange.GREATER_THAN, ConditionTypeRange.LESS_THAN, ConditionTypeRange.GREATER_THAN_OR_EQUAL, ConditionTypeRange.LESS_THAN_OR_EQUAL]>;
+/**
+ * This contains the choices for the starts with and ends with conditions.
+ */
+export declare const ConditionTypeStartsEndsWithSchema: z.ZodEnum<[ConditionTypeStartsEndsWith.STARTS_WITH, ConditionTypeStartsEndsWith.ENDS_WITH]>;
+/**
+ * This contains the choices for the boolean conditions.
+ */
+export declare const ConditionTypeBooleanSchema: z.ZodEnum<[ConditionTypeBoolean.TRUE, ConditionTypeBoolean.FALSE]>;
+/**
+ * This contains the choices for the special conditions.
+ */
+export declare const ConditionTypeSpecialSchema: z.ZodEnum<[ConditionTypeSpecial]>;
+/**
+ * Create the union schema for ConditionType
+ */
+export declare const ConditionTypeSchema: z.ZodUnion<[z.ZodEnum<[ConditionTypeSingle.TYPEOF, ConditionTypeSingle.EQUAL, ConditionTypeSingle.CONTAINS, ConditionTypeSingle.NULL, ConditionTypeSingle.EMPTY, ConditionTypeSingle.SHARE_RULE]>, z.ZodEnum<[ConditionTypeRange.GREATER_THAN, ConditionTypeRange.LESS_THAN, ConditionTypeRange.GREATER_THAN_OR_EQUAL, ConditionTypeRange.LESS_THAN_OR_EQUAL]>, z.ZodEnum<[ConditionTypeStartsEndsWith.STARTS_WITH, ConditionTypeStartsEndsWith.ENDS_WITH]>, z.ZodEnum<[ConditionTypeBoolean.TRUE, ConditionTypeBoolean.FALSE]>, z.ZodEnum<[ConditionTypeSpecial]>]>;
+//# sourceMappingURL=rules-enums.schema.d.ts.map

package/dist/schema/rules/rules-enums.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules-enums.schema.d.ts","sourceRoot":"","sources":["../../../src/schema/rules/rules-enums.schema.ts"],"names":[],"mappings":"AACA,OAAO,EACH,oBAAoB,EACpB,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,2BAA2B,EAC3B,eAAe,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB;;GAEG;AACH,eAAO,MAAM,qBAAqB,iQAWhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB,sDAGhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,4BAA4B,uEAGvC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB,uLAOpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB,6JAKnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iCAAiC,6FAG5C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B,oEAGrC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B,mCAErC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB,siBAM9B,CAAC"}