@adrekic/zod-fieldsjson 0.0.1-schemas.0

package/dist/conditions/base.d.ts

@@ -0,0 +1,9 @@
+import * as z from "zod/v4";
+export declare const BaseJSONConditionSchema: <TType extends string, TConditionValue, TModifier extends string>(typeSchema: z.ZodLiteral<TType>, valueSchema: z.ZodType<TConditionValue>, modifierSchema: z.ZodLiteral<TModifier>) => z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<TType>;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<TConditionValue, unknown, z.core.$ZodTypeInternals<TConditionValue, unknown>>;
+    conditionModifier: z.ZodLiteral<TModifier>;
+}, z.core.$strip>;
+export type BaseJSONConditionSchemaType<TType extends string, TConditionValue, TModifier extends string> = z.infer<ReturnType<typeof BaseJSONConditionSchema<TType, TConditionValue, TModifier>>>;

package/dist/conditions/boolean.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+export declare const JSONBooleanConditionTypeSchema: z.ZodLiteral<"boolean">;
+export type JSONBooleanConditionTypeSchemaType = z.infer<typeof JSONBooleanConditionTypeSchema>;
+export declare const JSONBooleanConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals">;
+export type JSONBooleanConditionModifierSchemaType = z.infer<typeof JSONBooleanConditionModifierSchema>;
+export declare const JSONBooleanConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"boolean">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals">;
+}, z.core.$strip>;
+export type JSONBooleanConditionSchemaType = z.infer<typeof JSONBooleanConditionSchema>;

package/dist/conditions/checkbox-list.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+export declare const JSONCheckboxListConditionTypeSchema: z.ZodLiteral<"checkbox-list">;
+export type JSONCheckboxListConditionTypeSchemaType = z.infer<typeof JSONCheckboxListConditionTypeSchema>;
+export declare const JSONCheckboxListConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "every" | "some" | "none">;
+export type JSONCheckboxListConditionModifierSchemaType = z.infer<typeof JSONCheckboxListConditionModifierSchema>;
+export declare const JSONCheckboxListConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"checkbox-list">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "every" | "some" | "none">;
+}, z.core.$strip>;
+export type JSONCheckboxListConditionSchemaType = z.infer<typeof JSONCheckboxListConditionSchema>;

package/dist/conditions/date.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+export declare const JSONDateConditionTypeSchema: z.ZodLiteral<"date">;
+export type JSONDateConditionTypeSchemaType = z.infer<typeof JSONDateConditionTypeSchema>;
+export declare const JSONDateConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "in" | "before" | "after" | "notIn">;
+export type JSONDateConditionModifierSchemaType = z.infer<typeof JSONDateConditionModifierSchema>;
+export declare const JSONDateConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"date">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<string | {
+        from: string | null;
+        to: string | null;
+    }, unknown, z.core.$ZodTypeInternals<string | {
+        from: string | null;
+        to: string | null;
+    }, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "in" | "before" | "after" | "notIn">;
+}, z.core.$strip>;
+export type JSONDateConditionSchemaType = z.infer<typeof JSONDateConditionSchema>;

package/dist/conditions/index.d.ts

@@ -0,0 +1,149 @@
+import * as z from "zod/v4";
+export * from './base';
+export * from './boolean';
+export * from './checkbox-list';
+export * from './date';
+export * from './multi-select';
+export * from './multi-string';
+export * from './number';
+export * from './otp';
+export * from './pass-fail';
+export * from './radio';
+export * from './rating';
+export * from './scan';
+export * from './select';
+export * from './string';
+export * from './text';
+export * from './time';
+export * from './upload';
+export * from './url';
+export declare const JSONConditionTypeSchema: z.ZodUnion<readonly [z.ZodLiteral<"boolean">, z.ZodLiteral<"checkbox-list">, z.ZodLiteral<"date">, z.ZodLiteral<"multi-select">, z.ZodLiteral<"multi-string">, z.ZodLiteral<"number">, z.ZodLiteral<"otp">, z.ZodLiteral<"pass-fail">, z.ZodLiteral<"radio">, z.ZodLiteral<"rating">, z.ZodLiteral<"qr">, z.ZodLiteral<"select">, z.ZodLiteral<"string">, z.ZodLiteral<"text">, z.ZodLiteral<"time">, z.ZodLiteral<"upload">, z.ZodLiteral<"url">]>;
+export type JSONConditionTypeSchemaType = z.infer<typeof JSONConditionTypeSchema>;
+export declare const JSONConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"boolean">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"checkbox-list">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "every" | "some" | "none">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"date">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<string | {
+        from: string | null;
+        to: string | null;
+    }, unknown, z.core.$ZodTypeInternals<string | {
+        from: string | null;
+        to: string | null;
+    }, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "in" | "before" | "after" | "notIn">;
+}, z.core.$strip>, 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">;
+}, z.core.$strip>, 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">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<number | {
+        from: number | null;
+        to: number | null;
+    }, unknown, z.core.$ZodTypeInternals<number | {
+        from: number | null;
+        to: number | null;
+    }, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "lessThan" | "lessThanOrEquals" | "greaterThan" | "greaterThanOrEquals" | "inRange" | "notInRange">;
+}, z.core.$strip>, 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">;
+}, z.core.$strip>, 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">;
+}, z.core.$strip>, 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">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<number | {
+        from: number | null;
+        to: number | null;
+    }, unknown, z.core.$ZodTypeInternals<number | {
+        from: number | null;
+        to: number | null;
+    }, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "lessThan" | "lessThanOrEquals" | "greaterThan" | "greaterThanOrEquals" | "inRange" | "notInRange">;
+}, z.core.$strip>, 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">;
+}, z.core.$strip>, 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">;
+}, z.core.$strip>, 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">;
+}, z.core.$strip>, 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">;
+}, z.core.$strip>, 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}` | {
+        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}` | {
+        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">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"upload">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"url">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
+}, z.core.$strip>], "type">;
+export type JSONConditionSchemaType = z.infer<typeof JSONConditionSchema>;

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

@@ -0,0 +1,13 @@
+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<{
+    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">;
+}, z.core.$strip>;
+export type JSONMultiSelectConditionSchemaType = z.infer<typeof JSONMultiSelectConditionSchema>;

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

@@ -0,0 +1,13 @@
+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<{
+    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">;
+}, z.core.$strip>;
+export type JSONMultiStringConditionSchemaType = z.infer<typeof JSONMultiStringConditionSchema>;

package/dist/conditions/number.d.ts

@@ -0,0 +1,19 @@
+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<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"number">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<number | {
+        from: number | null;
+        to: number | null;
+    }, unknown, z.core.$ZodTypeInternals<number | {
+        from: number | null;
+        to: number | null;
+    }, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "lessThan" | "lessThanOrEquals" | "greaterThan" | "greaterThanOrEquals" | "inRange" | "notInRange">;
+}, z.core.$strip>;
+export type JSONNumberConditionSchemaType = z.infer<typeof JSONNumberConditionSchema>;

package/dist/conditions/otp.d.ts

@@ -0,0 +1,13 @@
+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<{
+    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">;
+}, z.core.$strip>;
+export type JSONOTPConditionSchemaType = z.infer<typeof JSONOTPConditionSchema>;

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

@@ -0,0 +1,13 @@
+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<{
+    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">;
+}, z.core.$strip>;
+export type JSONPassFailFieldConditionSchemaType = z.infer<typeof JSONPassFailFieldConditionSchema>;

package/dist/conditions/radio.d.ts

@@ -0,0 +1,13 @@
+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<{
+    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">;
+}, z.core.$strip>;
+export type JSONRadioConditionSchemaType = z.infer<typeof JSONRadioConditionSchema>;

package/dist/conditions/rating.d.ts

@@ -0,0 +1,19 @@
+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<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"rating">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<number | {
+        from: number | null;
+        to: number | null;
+    }, unknown, z.core.$ZodTypeInternals<number | {
+        from: number | null;
+        to: number | null;
+    }, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "lessThan" | "lessThanOrEquals" | "greaterThan" | "greaterThanOrEquals" | "inRange" | "notInRange">;
+}, z.core.$strip>;
+export type JSONRatingConditionSchemaType = z.infer<typeof JSONRatingConditionSchema>;

package/dist/conditions/scan.d.ts

@@ -0,0 +1,13 @@
+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<{
+    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">;
+}, z.core.$strip>;
+export type JSONScanConditionSchemaType = z.infer<typeof JSONScanConditionSchema>;

package/dist/conditions/select.d.ts

@@ -0,0 +1,13 @@
+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<{
+    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">;
+}, z.core.$strip>;
+export type JSONSelectConditionSchemaType = z.infer<typeof JSONSelectConditionSchema>;

package/dist/conditions/string.d.ts

@@ -0,0 +1,13 @@
+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<{
+    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">;
+}, z.core.$strip>;
+export type JSONStringConditionSchemaType = z.infer<typeof JSONStringConditionSchema>;

package/dist/conditions/text.d.ts

@@ -0,0 +1,13 @@
+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<{
+    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">;
+}, z.core.$strip>;
+export type JSONTextConditionSchemaType = z.infer<typeof JSONTextConditionSchema>;

package/dist/conditions/time.d.ts

@@ -0,0 +1,19 @@
+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<{
+    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}` | {
+        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}` | {
+        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">;
+}, z.core.$strip>;
+export type JSONTimeConditionSchemaType = z.infer<typeof JSONTimeConditionSchema>;

package/dist/conditions/upload.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+export declare const JSONUploadConditionTypeSchema: z.ZodLiteral<"upload">;
+export type JSONUploadConditionTypeSchemaType = z.infer<typeof JSONUploadConditionTypeSchema>;
+export declare const JSONUploadConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals">;
+export type JSONUploadConditionModifierSchemaType = z.infer<typeof JSONUploadConditionModifierSchema>;
+export declare const JSONUploadConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"upload">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals">;
+}, z.core.$strip>;
+export type JSONUploadConditionSchemaType = z.infer<typeof JSONUploadConditionSchema>;

package/dist/conditions/url.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+export declare const JSONURLConditionTypeSchema: z.ZodLiteral<"url">;
+export type JSONURLConditionTypeSchemaType = z.infer<typeof JSONURLConditionTypeSchema>;
+export declare const JSONURLConditionModifierSchema: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
+export type JSONURLConditionModifierSchemaType = z.infer<typeof JSONURLConditionModifierSchema>;
+export declare const JSONURLConditionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"url">;
+    fieldId: z.ZodString;
+    conditionValue: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    conditionModifier: z.ZodLiteral<"equals" | "notEquals" | "includes" | "excludes">;
+}, z.core.$strip>;
+export type JSONURLConditionSchemaType = z.infer<typeof JSONURLConditionSchema>;

package/dist/elements/base.d.ts

@@ -0,0 +1,6 @@
+import * as z from "zod/v4";
+export declare const BaseJSONFieldElementSchema: <TType extends string>(typeSchema: z.ZodLiteral<TType>) => z.ZodObject<{
+    identifier: z.ZodString;
+    type: z.ZodLiteral<TType>;
+}, z.core.$strip>;
+export type BaseJSONFieldElementSchemaType<TType extends string> = z.infer<ReturnType<typeof BaseJSONFieldElementSchema<TType>>>;