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

package/dist/conditions/rating.d.ts

@@ -1,19 +1,159 @@
 import * as z from "zod/v4";
 export declare const JSONRatingConditionTypeSchema: z.ZodLiteral<"rating">;
 export type JSONRatingConditionTypeSchemaType = z.infer<typeof JSONRatingConditionTypeSchema>;
-export declare const JSONRatingConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "lessThan" | "lessThanOrEquals" | "greaterThan" | "greaterThanOrEquals" | "inRange" | "notInRange">;
-export type JSONRatingConditionModifierSchemaType = z.infer<typeof JSONRatingConditionModifierSchema>;
-export declare const JSONRatingConditionSchema: z.ZodObject<{
+export declare const JSONRatingConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONRatingConditionEqualsModifierSchemaType = z.infer<typeof JSONRatingConditionEqualsModifierSchema>;
+export declare const JSONRatingEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONRatingEqualsConditionSchemaType = z.infer<typeof JSONRatingEqualsConditionSchema>;
+export declare const JSONRatingConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONRatingConditionNotEqualsModifierSchemaType = z.infer<typeof JSONRatingConditionNotEqualsModifierSchema>;
+export declare const JSONRatingNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONRatingNotEqualsConditionSchemaType = z.infer<typeof JSONRatingNotEqualsConditionSchema>;
+export declare const JSONRatingConditionLessThanModifierSchema: z.ZodLiteral<"lessThan">;
+export type JSONRatingConditionLessThanModifierSchemaType = z.infer<typeof JSONRatingConditionLessThanModifierSchema>;
+export declare const JSONRatingLessThanConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"lessThan">;
+}, z.core.$strip>;
+export type JSONRatingLessThanConditionSchemaType = z.infer<typeof JSONRatingLessThanConditionSchema>;
+export declare const JSONRatingConditionLessThanOrEqualsModifierSchema: z.ZodLiteral<"lessThanOrEquals">;
+export type JSONRatingConditionLessThanOrEqualsModifierSchemaType = z.infer<typeof JSONRatingConditionLessThanOrEqualsModifierSchema>;
+export declare const JSONRatingLessThanOrEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"lessThanOrEquals">;
+}, z.core.$strip>;
+export type JSONRatingLessThanOrEqualsConditionSchemaType = z.infer<typeof JSONRatingLessThanOrEqualsConditionSchema>;
+export declare const JSONRatingConditionGreaterThanModifierSchema: z.ZodLiteral<"greaterThan">;
+export type JSONRatingConditionGreaterThanModifierSchemaType = z.infer<typeof JSONRatingConditionGreaterThanModifierSchema>;
+export declare const JSONRatingGreaterThanConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"greaterThan">;
+}, z.core.$strip>;
+export type JSONRatingGreaterThanConditionSchemaType = z.infer<typeof JSONRatingGreaterThanConditionSchema>;
+export declare const JSONRatingConditionGreaterThanOrEqualsModifierSchema: z.ZodLiteral<"greaterThanOrEquals">;
+export type JSONRatingConditionGreaterThanOrEqualsModifierSchemaType = z.infer<typeof JSONRatingConditionGreaterThanOrEqualsModifierSchema>;
+export declare const JSONRatingGreaterThanOrEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    field: z.ZodString;
+    value: z.ZodType<number, unknown, z.core.$ZodTypeInternals<number, unknown>>;
+    modifier: z.ZodLiteral<"greaterThanOrEquals">;
+}, z.core.$strip>;
+export type JSONRatingGreaterThanOrEqualsConditionSchemaType = z.infer<typeof JSONRatingGreaterThanOrEqualsConditionSchema>;
+export declare const JSONRatingConditionInRangeModifierSchema: z.ZodLiteral<"inRange">;
+export type JSONRatingConditionInRangeModifierSchemaType = z.infer<typeof JSONRatingConditionInRangeModifierSchema>;
+export declare const JSONRatingInRangeConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    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 JSONRatingInRangeConditionSchemaType = z.infer<typeof JSONRatingInRangeConditionSchema>;
+export declare const JSONRatingConditionNotInRangeModifierSchema: z.ZodLiteral<"notInRange">;
+export type JSONRatingConditionNotInRangeModifierSchemaType = z.infer<typeof JSONRatingConditionNotInRangeModifierSchema>;
+export declare const JSONRatingNotInRangeConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"rating">;
-    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 JSONRatingNotInRangeConditionSchemaType = z.infer<typeof JSONRatingNotInRangeConditionSchema>;
+export declare const JSONRatingConditionModifierSchema: 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 JSONRatingConditionModifierSchemaType = z.infer<typeof JSONRatingConditionModifierSchema>;
+export declare const JSONRatingConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    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<"rating">;
+    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<"rating">;
+    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<"rating">;
+    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<"rating">;
+    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<"rating">;
+    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<"rating">;
+    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<"rating">;
+    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 JSONRatingConditionSchemaType = z.infer<typeof JSONRatingConditionSchema>;

package/dist/conditions/scan.d.ts

@@ -1,13 +1,71 @@
 import * as z from "zod/v4";
 export declare const JSONScanConditionTypeSchema: z.ZodLiteral<"qr">;
 export type JSONScanConditionTypeSchemaType = z.infer<typeof JSONScanConditionTypeSchema>;
-export declare const JSONScanConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
-export type JSONScanConditionModifierSchemaType = z.infer<typeof JSONScanConditionModifierSchema>;
-export declare const JSONScanConditionSchema: z.ZodObject<{
+export declare const JSONScanConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONScanConditionEqualsModifierSchemaType = z.infer<typeof JSONScanConditionEqualsModifierSchema>;
+export declare const JSONScanEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"qr">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONScanEqualsConditionSchemaType = z.infer<typeof JSONScanEqualsConditionSchema>;
+export declare const JSONScanConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONScanConditionNotEqualsModifierSchemaType = z.infer<typeof JSONScanConditionNotEqualsModifierSchema>;
+export declare const JSONScanNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"qr">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONScanNotEqualsConditionSchemaType = z.infer<typeof JSONScanNotEqualsConditionSchema>;
+export declare const JSONScanConditionIncludesModifierSchema: z.ZodLiteral<"includes">;
+export type JSONScanConditionIncludesModifierSchemaType = z.infer<typeof JSONScanConditionIncludesModifierSchema>;
+export declare const JSONScanIncludesConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"qr">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>;
+export type JSONScanIncludesConditionSchemaType = z.infer<typeof JSONScanIncludesConditionSchema>;
+export declare const JSONScanConditionExcludesModifierSchema: z.ZodLiteral<"excludes">;
+export type JSONScanConditionExcludesModifierSchemaType = z.infer<typeof JSONScanConditionExcludesModifierSchema>;
+export declare const JSONScanExcludesConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"qr">;
-    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 JSONScanExcludesConditionSchemaType = z.infer<typeof JSONScanExcludesConditionSchema>;
+export declare const JSONScanConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"includes">, z.ZodLiteral<"excludes">]>;
+export type JSONScanConditionModifierSchemaType = z.infer<typeof JSONScanConditionModifierSchema>;
+export declare const JSONScanConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"qr">;
+    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<"qr">;
+    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<"qr">;
+    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<"qr">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
+}, z.core.$strip>], "modifier">;
 export type JSONScanConditionSchemaType = z.infer<typeof JSONScanConditionSchema>;

package/dist/conditions/select.d.ts

@@ -1,13 +1,71 @@
 import * as z from "zod/v4";
 export declare const JSONSelectConditionTypeSchema: z.ZodLiteral<"select">;
 export type JSONSelectConditionTypeSchemaType = z.infer<typeof JSONSelectConditionTypeSchema>;
-export declare const JSONSelectConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
-export type JSONSelectConditionModifierSchemaType = z.infer<typeof JSONSelectConditionModifierSchema>;
-export declare const JSONSelectConditionSchema: z.ZodObject<{
+export declare const JSONSelectConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONSelectConditionEqualsModifierSchemaType = z.infer<typeof JSONSelectConditionEqualsModifierSchema>;
+export declare const JSONSelectEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"select">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONSelectEqualsConditionSchemaType = z.infer<typeof JSONSelectEqualsConditionSchema>;
+export declare const JSONSelectConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONSelectConditionNotEqualsModifierSchemaType = z.infer<typeof JSONSelectConditionNotEqualsModifierSchema>;
+export declare const JSONSelectNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"select">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONSelectNotEqualsConditionSchemaType = z.infer<typeof JSONSelectNotEqualsConditionSchema>;
+export declare const JSONSelectConditionIncludesModifierSchema: z.ZodLiteral<"includes">;
+export type JSONSelectConditionIncludesModifierSchemaType = z.infer<typeof JSONSelectConditionIncludesModifierSchema>;
+export declare const JSONSelectIncludesConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>;
+export type JSONSelectIncludesConditionSchemaType = z.infer<typeof JSONSelectIncludesConditionSchema>;
+export declare const JSONSelectConditionExcludesModifierSchema: z.ZodLiteral<"excludes">;
+export type JSONSelectConditionExcludesModifierSchemaType = z.infer<typeof JSONSelectConditionExcludesModifierSchema>;
+export declare const JSONSelectExcludesConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"select">;
-    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 JSONSelectExcludesConditionSchemaType = z.infer<typeof JSONSelectExcludesConditionSchema>;
+export declare const JSONSelectConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"includes">, z.ZodLiteral<"excludes">]>;
+export type JSONSelectConditionModifierSchemaType = z.infer<typeof JSONSelectConditionModifierSchema>;
+export declare const JSONSelectConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"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<"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<"select">;
+    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<"select">;
+    field: z.ZodString;
+    value: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
+}, z.core.$strip>], "modifier">;
 export type JSONSelectConditionSchemaType = z.infer<typeof JSONSelectConditionSchema>;

package/dist/conditions/string.d.ts

@@ -1,13 +1,71 @@
 import * as z from "zod/v4";
 export declare const JSONStringConditionTypeSchema: z.ZodLiteral<"string">;
 export type JSONStringConditionTypeSchemaType = z.infer<typeof JSONStringConditionTypeSchema>;
-export declare const JSONStringConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
-export type JSONStringConditionModifierSchemaType = z.infer<typeof JSONStringConditionModifierSchema>;
-export declare const JSONStringConditionSchema: z.ZodObject<{
+export declare const JSONStringConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONStringConditionEqualsModifierSchemaType = z.infer<typeof JSONStringConditionEqualsModifierSchema>;
+export declare const JSONStringEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"string">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONStringEqualsConditionSchemaType = z.infer<typeof JSONStringEqualsConditionSchema>;
+export declare const JSONStringConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONStringConditionNotEqualsModifierSchemaType = z.infer<typeof JSONStringConditionNotEqualsModifierSchema>;
+export declare const JSONStringNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"string">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONStringNotEqualsConditionSchemaType = z.infer<typeof JSONStringNotEqualsConditionSchema>;
+export declare const JSONStringConditionIncludesModifierSchema: z.ZodLiteral<"includes">;
+export type JSONStringConditionIncludesModifierSchemaType = z.infer<typeof JSONStringConditionIncludesModifierSchema>;
+export declare const JSONStringIncludesConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"string">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>;
+export type JSONStringIncludesConditionSchemaType = z.infer<typeof JSONStringIncludesConditionSchema>;
+export declare const JSONStringConditionExcludesModifierSchema: z.ZodLiteral<"excludes">;
+export type JSONStringConditionExcludesModifierSchemaType = z.infer<typeof JSONStringConditionExcludesModifierSchema>;
+export declare const JSONStringExcludesConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"string">;
-    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 JSONStringExcludesConditionSchemaType = z.infer<typeof JSONStringExcludesConditionSchema>;
+export declare const JSONStringConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"includes">, z.ZodLiteral<"excludes">]>;
+export type JSONStringConditionModifierSchemaType = z.infer<typeof JSONStringConditionModifierSchema>;
+export declare const JSONStringConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"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<"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<"string">;
+    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<"string">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
+}, z.core.$strip>], "modifier">;
 export type JSONStringConditionSchemaType = z.infer<typeof JSONStringConditionSchema>;

package/dist/conditions/text.d.ts

@@ -1,13 +1,71 @@
 import * as z from "zod/v4";
 export declare const JSONTextConditionTypeSchema: z.ZodLiteral<"text">;
 export type JSONTextConditionTypeSchemaType = z.infer<typeof JSONTextConditionTypeSchema>;
-export declare const JSONTextConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
-export type JSONTextConditionModifierSchemaType = z.infer<typeof JSONTextConditionModifierSchema>;
-export declare const JSONTextConditionSchema: z.ZodObject<{
+export declare const JSONTextConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONTextConditionEqualsModifierSchemaType = z.infer<typeof JSONTextConditionEqualsModifierSchema>;
+export declare const JSONTextEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"text">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONTextEqualsConditionSchemaType = z.infer<typeof JSONTextEqualsConditionSchema>;
+export declare const JSONTextConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONTextConditionNotEqualsModifierSchemaType = z.infer<typeof JSONTextConditionNotEqualsModifierSchema>;
+export declare const JSONTextNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"text">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONTextNotEqualsConditionSchemaType = z.infer<typeof JSONTextNotEqualsConditionSchema>;
+export declare const JSONTextConditionIncludesModifierSchema: z.ZodLiteral<"includes">;
+export type JSONTextConditionIncludesModifierSchemaType = z.infer<typeof JSONTextConditionIncludesModifierSchema>;
+export declare const JSONTextIncludesConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"text">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"includes">;
+}, z.core.$strip>;
+export type JSONTextIncludesConditionSchemaType = z.infer<typeof JSONTextIncludesConditionSchema>;
+export declare const JSONTextConditionExcludesModifierSchema: z.ZodLiteral<"excludes">;
+export type JSONTextConditionExcludesModifierSchemaType = z.infer<typeof JSONTextConditionExcludesModifierSchema>;
+export declare const JSONTextExcludesConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"text">;
-    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 JSONTextExcludesConditionSchemaType = z.infer<typeof JSONTextExcludesConditionSchema>;
+export declare const JSONTextConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"includes">, z.ZodLiteral<"excludes">]>;
+export type JSONTextConditionModifierSchemaType = z.infer<typeof JSONTextConditionModifierSchema>;
+export declare const JSONTextConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"text">;
+    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<"text">;
+    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<"text">;
+    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<"text">;
+    field: z.ZodString;
+    value: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    modifier: z.ZodLiteral<"excludes">;
+}, z.core.$strip>], "modifier">;
 export type JSONTextConditionSchemaType = z.infer<typeof JSONTextConditionSchema>;

package/dist/conditions/time.d.ts

@@ -1,19 +1,127 @@
 import * as z from "zod/v4";
 export declare const JSONTimeConditionTypeSchema: z.ZodLiteral<"time">;
 export type JSONTimeConditionTypeSchemaType = z.infer<typeof JSONTimeConditionTypeSchema>;
-export declare const JSONTimeConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "in" | "before" | "after" | "notIn">;
-export type JSONTimeConditionModifierSchemaType = z.infer<typeof JSONTimeConditionModifierSchema>;
-export declare const JSONTimeConditionSchema: z.ZodObject<{
+export declare const JSONTimeConditionEqualsModifierSchema: z.ZodLiteral<"equals">;
+export type JSONTimeConditionEqualsModifierSchemaType = z.infer<typeof JSONTimeConditionEqualsModifierSchema>;
+export declare const JSONTimeEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown, z.core.$ZodTypeInternals<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>;
+export type JSONTimeEqualsConditionSchemaType = z.infer<typeof JSONTimeEqualsConditionSchema>;
+export declare const JSONTimeConditionNotEqualsModifierSchema: z.ZodLiteral<"notEquals">;
+export type JSONTimeConditionNotEqualsModifierSchemaType = z.infer<typeof JSONTimeConditionNotEqualsModifierSchema>;
+export declare const JSONTimeNotEqualsConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown, z.core.$ZodTypeInternals<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>;
+export type JSONTimeNotEqualsConditionSchemaType = z.infer<typeof JSONTimeNotEqualsConditionSchema>;
+export declare const JSONTimeConditionBeforeModifierSchema: z.ZodLiteral<"before">;
+export type JSONTimeConditionBeforeModifierSchemaType = z.infer<typeof JSONTimeConditionBeforeModifierSchema>;
+export declare const JSONTimeBeforeConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown, z.core.$ZodTypeInternals<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown>>;
+    modifier: z.ZodLiteral<"before">;
+}, z.core.$strip>;
+export type JSONTimeBeforeConditionSchemaType = z.infer<typeof JSONTimeBeforeConditionSchema>;
+export declare const JSONTimeConditionAfterModifierSchema: z.ZodLiteral<"after">;
+export type JSONTimeConditionAfterModifierSchemaType = z.infer<typeof JSONTimeConditionAfterModifierSchema>;
+export declare const JSONTimeAfterConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown, z.core.$ZodTypeInternals<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown>>;
+    modifier: z.ZodLiteral<"after">;
+}, z.core.$strip>;
+export type JSONTimeAfterConditionSchemaType = z.infer<typeof JSONTimeAfterConditionSchema>;
+export declare const JSONTimeConditionInModifierSchema: z.ZodLiteral<"in">;
+export type JSONTimeConditionInModifierSchemaType = z.infer<typeof JSONTimeConditionInModifierSchema>;
+export declare const JSONTimeInConditionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"time">;
-    fieldId: z.ZodString;
-    conditionValue: z.ZodType<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | {
+    field: z.ZodString;
+    value: z.ZodType<{
         from: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
         to: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
-    }, unknown, z.core.$ZodTypeInternals<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | {
+    }, unknown, z.core.$ZodTypeInternals<{
         from: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
         to: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
     }, unknown>>;
-    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "in" | "before" | "after" | "notIn">;
+    modifier: z.ZodLiteral<"in">;
 }, z.core.$strip>;
+export type JSONTimeInConditionSchemaType = z.infer<typeof JSONTimeInConditionSchema>;
+export declare const JSONTimeConditionNotInModifierSchema: z.ZodLiteral<"notIn">;
+export type JSONTimeConditionNotInModifierSchemaType = z.infer<typeof JSONTimeConditionNotInModifierSchema>;
+export declare const JSONTimeNotInConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<{
+        from: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+        to: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+    }, unknown, z.core.$ZodTypeInternals<{
+        from: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+        to: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+    }, unknown>>;
+    modifier: z.ZodLiteral<"notIn">;
+}, z.core.$strip>;
+export type JSONTimeNotInConditionSchemaType = z.infer<typeof JSONTimeNotInConditionSchema>;
+export declare const JSONTimeConditionModifierSchema: z.ZodUnion<readonly [z.ZodLiteral<"equals">, z.ZodLiteral<"notEquals">, z.ZodLiteral<"before">, z.ZodLiteral<"after">, z.ZodLiteral<"in">, z.ZodLiteral<"notIn">]>;
+export type JSONTimeConditionModifierSchemaType = z.infer<typeof JSONTimeConditionModifierSchema>;
+export declare const JSONTimeConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown, z.core.$ZodTypeInternals<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown>>;
+    modifier: z.ZodLiteral<"equals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown, z.core.$ZodTypeInternals<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown>>;
+    modifier: z.ZodLiteral<"notEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown, z.core.$ZodTypeInternals<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown>>;
+    modifier: z.ZodLiteral<"before">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown, z.core.$ZodTypeInternals<`T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}`, unknown>>;
+    modifier: z.ZodLiteral<"after">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<{
+        from: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+        to: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+    }, unknown, z.core.$ZodTypeInternals<{
+        from: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+        to: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+    }, unknown>>;
+    modifier: z.ZodLiteral<"in">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"time">;
+    field: z.ZodString;
+    value: z.ZodType<{
+        from: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+        to: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+    }, unknown, z.core.$ZodTypeInternals<{
+        from: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+        to: `T${string}:${string}:00+${string}:${string}` | `T${string}:${string}:00-${string}:${string}` | null;
+    }, unknown>>;
+    modifier: z.ZodLiteral<"notIn">;
+}, z.core.$strip>], "modifier">;
 export type JSONTimeConditionSchemaType = z.infer<typeof JSONTimeConditionSchema>;