@adrekic/zod-fieldsjson 0.0.1 → 0.0.2-condition-modifier-seperation.0

package/dist/conditions/multi-select.d.ts

@@ -1,13 +1,87 @@
 import * as z from "zod/v4";
 export declare const JSONMultiSelectConditionTypeSchema: z.ZodLiteral<"multi-select">;
 export type JSONMultiSelectConditionTypeSchemaType = z.infer<typeof JSONMultiSelectConditionTypeSchema>;
-export declare const JSONMultiSelectConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "every" | "some" | "none">;
-export type JSONMultiSelectConditionModifierSchemaType = z.infer<typeof JSONMultiSelectConditionModifierSchema>;
-export declare const JSONMultiSelectConditionSchema: z.ZodObject<{
+export declare const JSONMultiSelectConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONMultiSelectConditionEqualsModifierSchemaType = z.infer<typeof JSONMultiSelectConditionEqualsModifierSchema>;
+export declare const JSONMultiSelectEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONMultiSelectEqualsConditionSchemaType = z.infer<typeof JSONMultiSelectEqualsConditionSchema>;
+export declare const JSONMultiSelectConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONMultiSelectConditionNotEqualsModifierSchemaType = z.infer<typeof JSONMultiSelectConditionNotEqualsModifierSchema>;
+export declare const JSONMultiSelectNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONMultiSelectNotEqualsConditionSchemaType = z.infer<typeof JSONMultiSelectNotEqualsConditionSchema>;
+export declare const JSONMultiSelectConditionEveryModifierSchema: z.ZodLiteral<"every">;
+export type JSONMultiSelectConditionEveryModifierSchemaType = z.infer<typeof JSONMultiSelectConditionEveryModifierSchema>;
+export declare const JSONMultiSelectEveryConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"every">;
+}, z.core.$strip>;
+export type JSONMultiSelectEveryConditionSchemaType = z.infer<typeof JSONMultiSelectEveryConditionSchema>;
+export declare const JSONMultiSelectConditionSomeModifierSchema: z.ZodLiteral<"some">;
+export type JSONMultiSelectConditionSomeModifierSchemaType = z.infer<typeof JSONMultiSelectConditionSomeModifierSchema>;
+export declare const JSONMultiSelectSomeConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"some">;
+}, z.core.$strip>;
+export type JSONMultiSelectSomeConditionSchemaType = z.infer<typeof JSONMultiSelectSomeConditionSchema>;
+export declare const JSONMultiSelectConditionNoneModifierSchema: z.ZodLiteral<"none">;
+export type JSONMultiSelectConditionNoneModifierSchemaType = z.infer<typeof JSONMultiSelectConditionNoneModifierSchema>;
+export declare const JSONMultiSelectNoneConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"multi-select">;
-    fieldId: z.ZodString;
-    conditionValue: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
-    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "every" | "some" | "none">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"none">;
 }, z.core.$strip>;
+export type JSONMultiSelectNoneConditionSchemaType = z.infer<typeof JSONMultiSelectNoneConditionSchema>;
+export declare const JSONMultiSelectConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"every">, z.ZodLiteral<"some">, z.ZodLiteral<"none">]>;
+export type JSONMultiSelectConditionModifierSchemaType = z.infer<typeof JSONMultiSelectConditionModifierSchema>;
+export declare const JSONMultiSelectConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"every">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"some">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"none">;
+}, z.core.$strip>], "modifier">;
 export type JSONMultiSelectConditionSchemaType = z.infer<typeof JSONMultiSelectConditionSchema>;

package/dist/conditions/multi-string.d.ts

@@ -1,13 +1,87 @@
 import * as z from "zod/v4";
 export declare const JSONMultiStringConditionTypeSchema: z.ZodLiteral<"multi-string">;
 export type JSONMultiStringConditionTypeSchemaType = z.infer<typeof JSONMultiStringConditionTypeSchema>;
-export declare const JSONMultiStringConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "every" | "some" | "none">;
-export type JSONMultiStringConditionModifierSchemaType = z.infer<typeof JSONMultiStringConditionModifierSchema>;
-export declare const JSONMultiStringConditionSchema: z.ZodObject<{
+export declare const JSONMultiStringConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONMultiStringConditionEqualsModifierSchemaType = z.infer<typeof JSONMultiStringConditionEqualsModifierSchema>;
+export declare const JSONMultiStringEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-string">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONMultiStringEqualsConditionSchemaType = z.infer<typeof JSONMultiStringEqualsConditionSchema>;
+export declare const JSONMultiStringConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONMultiStringConditionNotEqualsModifierSchemaType = z.infer<typeof JSONMultiStringConditionNotEqualsModifierSchema>;
+export declare const JSONMultiStringNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-string">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONMultiStringNotEqualsConditionSchemaType = z.infer<typeof JSONMultiStringNotEqualsConditionSchema>;
+export declare const JSONMultiStringConditionEveryModifierSchema: z.ZodLiteral<"every">;
+export type JSONMultiStringConditionEveryModifierSchemaType = z.infer<typeof JSONMultiStringConditionEveryModifierSchema>;
+export declare const JSONMultiStringEveryConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-string">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"every">;
+}, z.core.$strip>;
+export type JSONMultiStringEveryConditionSchemaType = z.infer<typeof JSONMultiStringEveryConditionSchema>;
+export declare const JSONMultiStringConditionSomeModifierSchema: z.ZodLiteral<"some">;
+export type JSONMultiStringConditionSomeModifierSchemaType = z.infer<typeof JSONMultiStringConditionSomeModifierSchema>;
+export declare const JSONMultiStringSomeConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-string">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"some">;
+}, z.core.$strip>;
+export type JSONMultiStringSomeConditionSchemaType = z.infer<typeof JSONMultiStringSomeConditionSchema>;
+export declare const JSONMultiStringConditionNoneModifierSchema: z.ZodLiteral<"none">;
+export type JSONMultiStringConditionNoneModifierSchemaType = z.infer<typeof JSONMultiStringConditionNoneModifierSchema>;
+export declare const JSONMultiStringNoneConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"multi-string">;
-    fieldId: z.ZodString;
-    conditionValue: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
-    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "every" | "some" | "none">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"none">;
 }, z.core.$strip>;
+export type JSONMultiStringNoneConditionSchemaType = z.infer<typeof JSONMultiStringNoneConditionSchema>;
+export declare const JSONMultiStringConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"every">, z.ZodLiteral<"some">, z.ZodLiteral<"none">]>;
+export type JSONMultiStringConditionModifierSchemaType = z.infer<typeof JSONMultiStringConditionModifierSchema>;
+export declare const JSONMultiStringConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-string">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-string">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-string">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"every">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-string">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"some">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"multi-string">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"none">;
+}, z.core.$strip>], "modifier">;
 export type JSONMultiStringConditionSchemaType = z.infer<typeof JSONMultiStringConditionSchema>;

package/dist/conditions/number.d.ts

@@ -1,19 +1,159 @@
 import * as z from "zod/v4";
 export declare const JSONNumberConditionTypeSchema: z.ZodLiteral<"number">;
 export type JSONNumberConditionTypeSchemaType = z.infer<typeof JSONNumberConditionTypeSchema>;
-export declare const JSONNumberConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "lessThan" | "lessThanOrEquals" | "greaterThan" | "greaterThanOrEquals" | "inRange" | "notInRange">;
-export type JSONNumberConditionModifierSchemaType = z.infer<typeof JSONNumberConditionModifierSchema>;
-export declare const JSONNumberConditionSchema: z.ZodObject<{
+export declare const JSONNumberConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONNumberConditionEqualsModifierSchemaType = z.infer<typeof JSONNumberConditionEqualsModifierSchema>;
+export declare const JSONNumberEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONNumberEqualsConditionSchemaType = z.infer<typeof JSONNumberEqualsConditionSchema>;
+export declare const JSONNumberConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONNumberConditionNotEqualsModifierSchemaType = z.infer<typeof JSONNumberConditionNotEqualsModifierSchema>;
+export declare const JSONNumberNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONNumberNotEqualsConditionSchemaType = z.infer<typeof JSONNumberNotEqualsConditionSchema>;
+export declare const JSONNumberConditionLessThanModifierSchema: z.ZodLiteral<"lessThan">;
+export type JSONNumberConditionLessThanModifierSchemaType = z.infer<typeof JSONNumberConditionLessThanModifierSchema>;
+export declare const JSONNumberLessThanConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"lessThan">;
+}, z.core.$strip>;
+export type JSONNumberLessThanConditionSchemaType = z.infer<typeof JSONNumberLessThanConditionSchema>;
+export declare const JSONNumberConditionLessThanOrEqualsModifierSchema: z.ZodLiteral<"lessThanOrEquals">;
+export type JSONNumberConditionLessThanOrEqualsModifierSchemaType = z.infer<typeof JSONNumberConditionLessThanOrEqualsModifierSchema>;
+export declare const JSONNumberLessThanOrEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"lessThanOrEquals">;
+}, z.core.$strip>;
+export type JSONNumberLessThanOrEqualsConditionSchemaType = z.infer<typeof JSONNumberLessThanOrEqualsConditionSchema>;
+export declare const JSONNumberConditionGreaterThanModifierSchema: z.ZodLiteral<"greaterThan">;
+export type JSONNumberConditionGreaterThanModifierSchemaType = z.infer<typeof JSONNumberConditionGreaterThanModifierSchema>;
+export declare const JSONNumberGreaterThanConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"greaterThan">;
+}, z.core.$strip>;
+export type JSONNumberGreaterThanConditionSchemaType = z.infer<typeof JSONNumberGreaterThanConditionSchema>;
+export declare const JSONNumberConditionGreaterThanOrEqualsModifierSchema: z.ZodLiteral<"greaterThanOrEquals">;
+export type JSONNumberConditionGreaterThanOrEqualsModifierSchemaType = z.infer<typeof JSONNumberConditionGreaterThanOrEqualsModifierSchema>;
+export declare const JSONNumberGreaterThanOrEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"greaterThanOrEquals">;
+}, z.core.$strip>;
+export type JSONNumberGreaterThanOrEqualsConditionSchemaType = z.infer<typeof JSONNumberGreaterThanOrEqualsConditionSchema>;
+export declare const JSONNumberConditionInRangeModifierSchema: z.ZodLiteral<"inRange">;
+export type JSONNumberConditionInRangeModifierSchemaType = z.infer<typeof JSONNumberConditionInRangeModifierSchema>;
+export declare const JSONNumberInRangeConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<{
+        from: number | null;
+        to: number | null;
+    }, unknown, z.core.$ZodTypeInternals<{
+        from: number | null;
+        to: number | null;
+    }, unknown>>;
+    modifier: z.ZodLiteral<"inRange">;
+}, z.core.$strip>;
+export type JSONNumberInRangeConditionSchemaType = z.infer<typeof JSONNumberInRangeConditionSchema>;
+export declare const JSONNumberConditionNotInRangeModifierSchema: z.ZodLiteral<"notInRange">;
+export type JSONNumberConditionNotInRangeModifierSchemaType = z.infer<typeof JSONNumberConditionNotInRangeModifierSchema>;
+export declare const JSONNumberNotInRangeConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"number">;
-    fieldId: z.ZodString;
-    conditionValue: z.ZodType<number | {
+    field: z.ZodString;
+    value: z.ZodType<{
         from: number | null;
         to: number | null;
-    }, unknown, z.core.$ZodTypeInternals<number | {
+    }, unknown, z.core.$ZodTypeInternals<{
         from: number | null;
         to: number | null;
     }, unknown>>;
-    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "lessThan" | "lessThanOrEquals" | "greaterThan" | "greaterThanOrEquals" | "inRange" | "notInRange">;
+    modifier: z.ZodLiteral<"notInRange">;
 }, z.core.$strip>;
+export type JSONNumberNotInRangeConditionSchemaType = z.infer<typeof JSONNumberNotInRangeConditionSchema>;
+export declare const JSONNumberConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"lessThan">, z.ZodLiteral<"lessThanOrEquals">, z.ZodLiteral<"greaterThan">, z.ZodLiteral<"greaterThanOrEquals">, z.ZodLiteral<"inRange">, z.ZodLiteral<"notInRange">]>;
+export type JSONNumberConditionModifierSchemaType = z.infer<typeof JSONNumberConditionModifierSchema>;
+export declare const JSONNumberConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"lessThan">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"lessThanOrEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"greaterThan">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"greaterThanOrEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<{
+        from: number | null;
+        to: number | null;
+    }, unknown, z.core.$ZodTypeInternals<{
+        from: number | null;
+        to: number | null;
+    }, unknown>>;
+    modifier: z.ZodLiteral<"inRange">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    field: z.ZodString;
+    value: z.ZodType<{
+        from: number | null;
+        to: number | null;
+    }, unknown, z.core.$ZodTypeInternals<{
+        from: number | null;
+        to: number | null;
+    }, unknown>>;
+    modifier: z.ZodLiteral<"notInRange">;
+}, z.core.$strip>], "modifier">;
 export type JSONNumberConditionSchemaType = z.infer<typeof JSONNumberConditionSchema>;

package/dist/conditions/otp.d.ts

@@ -1,13 +1,71 @@
 import * as z from "zod/v4";
 export declare const JSONOTPConditionTypeSchema: z.ZodLiteral<"otp">;
 export type JSONOTPConditionTypeSchemaType = z.infer<typeof JSONOTPConditionTypeSchema>;
-export declare const JSONOTPConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
-export type JSONOTPConditionModifierSchemaType = z.infer<typeof JSONOTPConditionModifierSchema>;
-export declare const JSONOTPConditionSchema: z.ZodObject<{
+export declare const JSONOTPConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONOTPConditionEqualsModifierSchemaType = z.infer<typeof JSONOTPConditionEqualsModifierSchema>;
+export declare const JSONOTPEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"otp">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONOTPEqualsConditionSchemaType = z.infer<typeof JSONOTPEqualsConditionSchema>;
+export declare const JSONOTPConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONOTPConditionNotEqualsModifierSchemaType = z.infer<typeof JSONOTPConditionNotEqualsModifierSchema>;
+export declare const JSONOTPNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"otp">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONOTPNotEqualsConditionSchemaType = z.infer<typeof JSONOTPNotEqualsConditionSchema>;
+export declare const JSONOTPConditionIncludesModifierSchema: z.ZodLiteral<"includes">;
+export type JSONOTPConditionIncludesModifierSchemaType = z.infer<typeof JSONOTPConditionIncludesModifierSchema>;
+export declare const JSONOTPIncludesConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"otp">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>;
+export type JSONOTPIncludesConditionSchemaType = z.infer<typeof JSONOTPIncludesConditionSchema>;
+export declare const JSONOTPConditionExcludesModifierSchema: z.ZodLiteral<"excludes">;
+export type JSONOTPConditionExcludesModifierSchemaType = z.infer<typeof JSONOTPConditionExcludesModifierSchema>;
+export declare const JSONOTPExcludesConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"otp">;
-    fieldId: z.ZodString;
-    conditionValue: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
-    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
 }, z.core.$strip>;
+export type JSONOTPExcludesConditionSchemaType = z.infer<typeof JSONOTPExcludesConditionSchema>;
+export declare const JSONOTPConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"includes">, z.ZodLiteral<"excludes">]>;
+export type JSONOTPConditionModifierSchemaType = z.infer<typeof JSONOTPConditionModifierSchema>;
+export declare const JSONOTPConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"otp">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"otp">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"otp">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"otp">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
+}, z.core.$strip>], "modifier">;
 export type JSONOTPConditionSchemaType = z.infer<typeof JSONOTPConditionSchema>;

package/dist/conditions/pass-fail.d.ts

@@ -1,13 +1,71 @@
 import * as z from "zod/v4";
 export declare const JSONPassFailConditionTypeSchema: z.ZodLiteral<"pass-fail">;
 export type JSONPassFailConditionTypeSchemaType = z.infer<typeof JSONPassFailConditionTypeSchema>;
-export declare const JSONPassFailFieldConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
-export type JSONPassFailFieldConditionModifierSchemaType = z.infer<typeof JSONPassFailFieldConditionModifierSchema>;
-export declare const JSONPassFailFieldConditionSchema: z.ZodObject<{
+export declare const JSONPassFailFieldConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONPassFailFieldConditionEqualsModifierSchemaType = z.infer<typeof JSONPassFailFieldConditionEqualsModifierSchema>;
+export declare const JSONPassFailFieldEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pass-fail">;
+    field: z.ZodString;
+    value: z.ZodType<"pass" | "fail" | "na", unknown, z.core.$ZodTypeInternals<"pass" | "fail" | "na", unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONPassFailFieldEqualsConditionSchemaType = z.infer<typeof JSONPassFailFieldEqualsConditionSchema>;
+export declare const JSONPassFailFieldConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONPassFailFieldConditionNotEqualsModifierSchemaType = z.infer<typeof JSONPassFailFieldConditionNotEqualsModifierSchema>;
+export declare const JSONPassFailFieldNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pass-fail">;
+    field: z.ZodString;
+    value: z.ZodType<"pass" | "fail" | "na", unknown, z.core.$ZodTypeInternals<"pass" | "fail" | "na", unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONPassFailFieldNotEqualsConditionSchemaType = z.infer<typeof JSONPassFailFieldNotEqualsConditionSchema>;
+export declare const JSONPassFailFieldConditionIncludesModifierSchema: z.ZodLiteral<"includes">;
+export type JSONPassFailFieldConditionIncludesModifierSchemaType = z.infer<typeof JSONPassFailFieldConditionIncludesModifierSchema>;
+export declare const JSONPassFailFieldIncludesConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pass-fail">;
+    field: z.ZodString;
+    value: z.ZodType<("pass" | "fail" | "na")[], unknown, z.core.$ZodTypeInternals<("pass" | "fail" | "na")[], unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>;
+export type JSONPassFailFieldIncludesConditionSchemaType = z.infer<typeof JSONPassFailFieldIncludesConditionSchema>;
+export declare const JSONPassFailFieldConditionExcludesModifierSchema: z.ZodLiteral<"excludes">;
+export type JSONPassFailFieldConditionExcludesModifierSchemaType = z.infer<typeof JSONPassFailFieldConditionExcludesModifierSchema>;
+export declare const JSONPassFailFieldExcludesConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"pass-fail">;
-    fieldId: z.ZodString;
-    conditionValue: z.ZodType<"pass" | "fail" | "na" | ("pass" | "fail" | "na")[], unknown, z.core.$ZodTypeInternals<"pass" | "fail" | "na" | ("pass" | "fail" | "na")[], unknown>>;
-    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
+    field: z.ZodString;
+    value: z.ZodType<("pass" | "fail" | "na")[], unknown, z.core.$ZodTypeInternals<("pass" | "fail" | "na")[], unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
 }, z.core.$strip>;
+export type JSONPassFailFieldExcludesConditionSchemaType = z.infer<typeof JSONPassFailFieldExcludesConditionSchema>;
+export declare const JSONPassFailFieldConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"includes">, z.ZodLiteral<"excludes">]>;
+export type JSONPassFailFieldConditionModifierSchemaType = z.infer<typeof JSONPassFailFieldConditionModifierSchema>;
+export declare const JSONPassFailFieldConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pass-fail">;
+    field: z.ZodString;
+    value: z.ZodType<"pass" | "fail" | "na", unknown, z.core.$ZodTypeInternals<"pass" | "fail" | "na", unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pass-fail">;
+    field: z.ZodString;
+    value: z.ZodType<"pass" | "fail" | "na", unknown, z.core.$ZodTypeInternals<"pass" | "fail" | "na", unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pass-fail">;
+    field: z.ZodString;
+    value: z.ZodType<("pass" | "fail" | "na")[], unknown, z.core.$ZodTypeInternals<("pass" | "fail" | "na")[], unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"pass-fail">;
+    field: z.ZodString;
+    value: z.ZodType<("pass" | "fail" | "na")[], unknown, z.core.$ZodTypeInternals<("pass" | "fail" | "na")[], unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
+}, z.core.$strip>], "modifier">;
 export type JSONPassFailFieldConditionSchemaType = z.infer<typeof JSONPassFailFieldConditionSchema>;

package/dist/conditions/radio.d.ts

@@ -1,13 +1,71 @@
 import * as z from "zod/v4";
 export declare const JSONRadioConditionTypeSchema: z.ZodLiteral<"radio">;
 export type JSONRadioConditionTypeSchemaType = z.infer<typeof JSONRadioConditionTypeSchema>;
-export declare const JSONRadioConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
-export type JSONRadioConditionModifierSchemaType = z.infer<typeof JSONRadioConditionModifierSchema>;
-export declare const JSONRadioConditionSchema: z.ZodObject<{
+export declare const JSONRadioConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONRadioConditionEqualsModifierSchemaType = z.infer<typeof JSONRadioConditionEqualsModifierSchema>;
+export declare const JSONRadioEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"radio">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONRadioEqualsConditionSchemaType = z.infer<typeof JSONRadioEqualsConditionSchema>;
+export declare const JSONRadioConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONRadioConditionNotEqualsModifierSchemaType = z.infer<typeof JSONRadioConditionNotEqualsModifierSchema>;
+export declare const JSONRadioNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"radio">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONRadioNotEqualsConditionSchemaType = z.infer<typeof JSONRadioNotEqualsConditionSchema>;
+export declare const JSONRadioConditionIncludesModifierSchema: z.ZodLiteral<"includes">;
+export type JSONRadioConditionIncludesModifierSchemaType = z.infer<typeof JSONRadioConditionIncludesModifierSchema>;
+export declare const JSONRadioIncludesConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"radio">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>;
+export type JSONRadioIncludesConditionSchemaType = z.infer<typeof JSONRadioIncludesConditionSchema>;
+export declare const JSONRadioConditionExcludesModifierSchema: z.ZodLiteral<"excludes">;
+export type JSONRadioConditionExcludesModifierSchemaType = z.infer<typeof JSONRadioConditionExcludesModifierSchema>;
+export declare const JSONRadioExcludesConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"radio">;
-    fieldId: z.ZodString;
-    conditionValue: z.ZodType<string | string[], unknown, z.core.$ZodTypeInternals<string | string[], unknown>>;
-    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
 }, z.core.$strip>;
+export type JSONRadioExcludesConditionSchemaType = z.infer<typeof JSONRadioExcludesConditionSchema>;
+export declare const JSONRadioConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"includes">, z.ZodLiteral<"excludes">]>;
+export type JSONRadioConditionModifierSchemaType = z.infer<typeof JSONRadioConditionModifierSchema>;
+export declare const JSONRadioConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"radio">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"radio">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"radio">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"radio">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
+}, z.core.$strip>], "modifier">;
 export type JSONRadioConditionSchemaType = z.infer<typeof JSONRadioConditionSchema>;