@objectstack/spec 0.1.1 → 0.2.0

package/dist/data/field.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field.zod.d.ts","sourceRoot":"","sources":["../../src/data/field.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,SAAS,qRAmBpB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;EAK7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB,eAAe;;;;;IAMf,2BAA2B;;;;;IAM3B,8BAA8B;;;IAI9B,yBAAyB;;;;;IAMzB,wBAAwB;;;;;;;;;;;;;;;;;IAGxB,0BAA0B;;;;;IAM1B,kBAAkB;;;;;;;;;;;;;;;;IASlB,4BAA4B;;;;IAK5B,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGf,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAChD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"field.zod.d.ts","sourceRoot":"","sources":["../../src/data/field.zod.ts"],"names":[],"mappings":"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"}

package/dist/data/field.zod.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldSchema = exports.SelectOptionSchema = exports.FieldType = void 0;
+exports.Field = exports.FieldSchema = exports.AddressSchema = exports.LocationCoordinatesSchema = exports.SelectOptionSchema = exports.FieldType = void 0;
 const zod_1 = require("zod");
 /**
  * Field Type Enum
@@ -9,7 +9,7 @@ exports.FieldType = zod_1.z.enum([
     // Core Text
     'text', 'textarea', 'email', 'url', 'phone', 'password',
     // Rich Content
-    'markdown', 'html',
+    'markdown', 'html', 'richtext',
     // Numbers
     'number', 'currency', 'percent',
     // Date & Time
@@ -17,13 +17,20 @@ exports.FieldType = zod_1.z.enum([
     // Logic
     'boolean',
     // Selection
-    'select', 'multiselect', // Static options
+    'select', // Static options
     // Relational
     'lookup', 'master_detail', // Dynamic reference to other objects
     // Media
     'image', 'file', 'avatar',
     // Calculated / System
-    'formula', 'summary', 'autonumber'
+    'formula', 'summary', 'autonumber',
+    // Enhanced Types
+    'location', // GPS coordinates
+    'address', // Structured address
+    'code', // Code with syntax highlighting
+    'color', // Color picker
+    'rating', // Star rating
+    'signature' // Digital signature
 ]);
 /**
  * Select Option Schema
@@ -34,17 +41,42 @@ exports.SelectOptionSchema = zod_1.z.object({
     color: zod_1.z.string().optional().describe('Color code for badges/charts'),
     default: zod_1.z.boolean().optional().describe('Is default option'),
 });
+/**
+ * Location Coordinates Schema
+ * GPS coordinates for location field type
+ */
+exports.LocationCoordinatesSchema = zod_1.z.object({
+    latitude: zod_1.z.number().min(-90).max(90).describe('Latitude coordinate'),
+    longitude: zod_1.z.number().min(-180).max(180).describe('Longitude coordinate'),
+    altitude: zod_1.z.number().optional().describe('Altitude in meters'),
+    accuracy: zod_1.z.number().optional().describe('Accuracy in meters'),
+});
+/**
+ * Address Schema
+ * Structured address for address field type
+ */
+exports.AddressSchema = zod_1.z.object({
+    street: zod_1.z.string().optional().describe('Street address'),
+    city: zod_1.z.string().optional().describe('City name'),
+    state: zod_1.z.string().optional().describe('State/Province'),
+    postalCode: zod_1.z.string().optional().describe('Postal/ZIP code'),
+    country: zod_1.z.string().optional().describe('Country name or code'),
+    countryCode: zod_1.z.string().optional().describe('ISO country code (e.g., US, GB)'),
+    formatted: zod_1.z.string().optional().describe('Formatted address string'),
+});
 /**
  * Field Schema - Best Practice Enterprise Pattern
  */
 exports.FieldSchema = zod_1.z.object({
     /** Identity */
-    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Machine name (snake_case)'),
-    label: zod_1.z.string().describe('Human readable label'),
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Machine name (snake_case)').optional(),
+    label: zod_1.z.string().optional().describe('Human readable label'),
     type: exports.FieldType.describe('Field Data Type'),
     description: zod_1.z.string().optional().describe('Tooltip/Help text'),
+    format: zod_1.z.string().optional().describe('Format string (e.g. email, phone)'),
     /** Database Constraints */
     required: zod_1.z.boolean().default(false).describe('Is required'),
+    searchable: zod_1.z.boolean().default(false).describe('Is searchable'),
     multiple: zod_1.z.boolean().default(false).describe('Allow multiple values (Stores as Array/JSON). Applicable for select, lookup, file, image.'),
     unique: zod_1.z.boolean().default(false).describe('Is unique constraint'),
     defaultValue: zod_1.z.any().optional().describe('Default value'),
@@ -64,13 +96,30 @@ exports.FieldSchema = zod_1.z.object({
     writeRequiresMasterRead: zod_1.z.boolean().optional().describe('If true, user needs read access to master record to edit this field'),
     deleteBehavior: zod_1.z.enum(['set_null', 'cascade', 'restrict']).optional().default('set_null').describe('What happens if referenced record is deleted'),
     /** Calculation */
-    expression: zod_1.z.string().optional().describe('Formula expression'), // Changed from formula to expression to match common usage, but keeping one consistent is key. Let's use expression as generic.
-    formula: zod_1.z.string().optional().describe('Deprecated: Use expression'), // Backwards compat or just keep.
+    expression: zod_1.z.string().optional().describe('Formula expression'),
+    formula: zod_1.z.string().optional().describe('Deprecated: Use expression'),
     summaryOperations: zod_1.z.object({
         object: zod_1.z.string(),
         field: zod_1.z.string(),
         function: zod_1.z.enum(['count', 'sum', 'min', 'max', 'avg'])
     }).optional().describe('Roll-up summary definition'),
+    /** Enhanced Field Type Configurations */
+    // Code field config
+    language: zod_1.z.string().optional().describe('Programming language for syntax highlighting (e.g., javascript, python, sql)'),
+    theme: zod_1.z.string().optional().describe('Code editor theme (e.g., dark, light, monokai)'),
+    lineNumbers: zod_1.z.boolean().optional().describe('Show line numbers in code editor'),
+    // Rating field config
+    maxRating: zod_1.z.number().optional().describe('Maximum rating value (default: 5)'),
+    allowHalf: zod_1.z.boolean().optional().describe('Allow half-star ratings'),
+    // Location field config
+    displayMap: zod_1.z.boolean().optional().describe('Display map widget for location field'),
+    allowGeocoding: zod_1.z.boolean().optional().describe('Allow address-to-coordinate conversion'),
+    // Address field config
+    addressFormat: zod_1.z.enum(['us', 'uk', 'international']).optional().describe('Address format template'),
+    // Color field config
+    colorFormat: zod_1.z.enum(['hex', 'rgb', 'rgba', 'hsl']).optional().describe('Color value format'),
+    allowAlpha: zod_1.z.boolean().optional().describe('Allow transparency/alpha channel'),
+    presetColors: zod_1.z.array(zod_1.z.string()).optional().describe('Preset color options'),
     /** Security & Visibility */
     hidden: zod_1.z.boolean().default(false).describe('Hidden from default UI'),
     readonly: zod_1.z.boolean().default(false).describe('Read-only in UI'),
@@ -79,3 +128,95 @@ exports.FieldSchema = zod_1.z.object({
     index: zod_1.z.boolean().default(false).describe('Create standard database index'),
     externalId: zod_1.z.boolean().default(false).describe('Is external ID for upsert operations'),
 });
+exports.Field = {
+    text: (config = {}) => ({ type: 'text', ...config }),
+    textarea: (config = {}) => ({ type: 'textarea', ...config }),
+    number: (config = {}) => ({ type: 'number', ...config }),
+    boolean: (config = {}) => ({ type: 'boolean', ...config }),
+    date: (config = {}) => ({ type: 'date', ...config }),
+    datetime: (config = {}) => ({ type: 'datetime', ...config }),
+    currency: (config = {}) => ({ type: 'currency', ...config }),
+    percent: (config = {}) => ({ type: 'percent', ...config }),
+    url: (config = {}) => ({ type: 'url', ...config }),
+    email: (config = {}) => ({ type: 'email', ...config }),
+    phone: (config = {}) => ({ type: 'phone', ...config }),
+    image: (config = {}) => ({ type: 'image', ...config }),
+    file: (config = {}) => ({ type: 'file', ...config }),
+    avatar: (config = {}) => ({ type: 'avatar', ...config }),
+    formula: (config = {}) => ({ type: 'formula', ...config }),
+    summary: (config = {}) => ({ type: 'summary', ...config }),
+    autonumber: (config = {}) => ({ type: 'autonumber', ...config }),
+    markdown: (config = {}) => ({ type: 'markdown', ...config }),
+    html: (config = {}) => ({ type: 'html', ...config }),
+    password: (config = {}) => ({ type: 'password', ...config }),
+    /**
+     * Select field helper with backward-compatible API
+     *
+     * @example Old API (array first)
+     * Field.select(['High', 'Low'], { label: 'Priority' })
+     *
+     * @example New API (config object)
+     * Field.select({ options: [{label: 'High', value: 'high'}], label: 'Priority' })
+     */
+    select: (optionsOrConfig, config) => {
+        // Support both old and new signatures:
+        // Old: Field.select(['a', 'b'], { label: 'X' })
+        // New: Field.select({ options: [{label: 'A', value: 'a'}], label: 'X' })
+        let options;
+        let finalConfig;
+        if (Array.isArray(optionsOrConfig)) {
+            // Old signature: array as first param
+            options = optionsOrConfig.map(o => typeof o === 'string' ? { label: o, value: o } : o);
+            finalConfig = config || {};
+        }
+        else {
+            // New signature: config object with options
+            options = (optionsOrConfig.options || []).map(o => typeof o === 'string' ? { label: o, value: o } : o);
+            // Remove options from config to avoid confusion
+            const { options: _, ...restConfig } = optionsOrConfig;
+            finalConfig = restConfig;
+        }
+        return { type: 'select', options, ...finalConfig };
+    },
+    lookup: (reference, config = {}) => ({
+        type: 'lookup',
+        reference,
+        ...config
+    }),
+    masterDetail: (reference, config = {}) => ({
+        type: 'master_detail',
+        reference,
+        ...config
+    }),
+    // Enhanced Field Type Helpers
+    location: (config = {}) => ({
+        type: 'location',
+        ...config
+    }),
+    address: (config = {}) => ({
+        type: 'address',
+        ...config
+    }),
+    richtext: (config = {}) => ({
+        type: 'richtext',
+        ...config
+    }),
+    code: (language, config = {}) => ({
+        type: 'code',
+        language,
+        ...config
+    }),
+    color: (config = {}) => ({
+        type: 'color',
+        ...config
+    }),
+    rating: (maxRating = 5, config = {}) => ({
+        type: 'rating',
+        maxRating,
+        ...config
+    }),
+    signature: (config = {}) => ({
+        type: 'signature',
+        ...config
+    }),
+};

package/dist/data/filter.zod.d.ts

@@ -0,0 +1,295 @@
+import { z } from 'zod';
+/**
+ * Unified Query DSL Specification
+ *
+ * Based on industry best practices from:
+ * - Prisma ORM
+ * - Strapi CMS
+ * - TypeORM
+ * - LoopBack Framework
+ *
+ * Version: 1.0.0
+ * Status: Draft
+ *
+ * Objective: Define a JSON-based, database-agnostic query syntax standard
+ * for data filtering interactions between frontend and backend APIs.
+ *
+ * Design Principles:
+ * 1. Declarative: Frontend describes "what data to get", not "how to query"
+ * 2. Database Agnostic: Syntax contains no database-specific directives
+ * 3. Type Safe: Structure can be statically inferred by TypeScript
+ * 4. Convention over Configuration: Implicit syntax for common queries
+ */
+/**
+ * Comparison operators for equality and inequality checks.
+ * Supported data types: Any
+ */
+export declare const EqualityOperatorSchema: z.ZodObject<{
+    /** Equal to (default) - SQL: = | MongoDB: $eq */
+    $eq: z.ZodOptional<z.ZodAny>;
+    /** Not equal to - SQL: <> or != | MongoDB: $ne */
+    $ne: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    $eq?: any;
+    $ne?: any;
+}, {
+    $eq?: any;
+    $ne?: any;
+}>;
+/**
+ * Comparison operators for numeric and date comparisons.
+ * Supported data types: Number, Date
+ */
+export declare const ComparisonOperatorSchema: z.ZodObject<{
+    /** Greater than - SQL: > | MongoDB: $gt */
+    $gt: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodDate]>>;
+    /** Greater than or equal to - SQL: >= | MongoDB: $gte */
+    $gte: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodDate]>>;
+    /** Less than - SQL: < | MongoDB: $lt */
+    $lt: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodDate]>>;
+    /** Less than or equal to - SQL: <= | MongoDB: $lte */
+    $lte: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodDate]>>;
+}, "strip", z.ZodTypeAny, {
+    $gt?: number | Date | undefined;
+    $gte?: number | Date | undefined;
+    $lt?: number | Date | undefined;
+    $lte?: number | Date | undefined;
+}, {
+    $gt?: number | Date | undefined;
+    $gte?: number | Date | undefined;
+    $lt?: number | Date | undefined;
+    $lte?: number | Date | undefined;
+}>;
+/**
+ * Set operators for membership checks.
+ */
+export declare const SetOperatorSchema: z.ZodObject<{
+    /** In list - SQL: IN (?, ?, ?) | MongoDB: $in */
+    $in: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    /** Not in list - SQL: NOT IN (...) | MongoDB: $nin */
+    $nin: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strip", z.ZodTypeAny, {
+    $in?: any[] | undefined;
+    $nin?: any[] | undefined;
+}, {
+    $in?: any[] | undefined;
+    $nin?: any[] | undefined;
+}>;
+/**
+ * Range operator for interval checks (closed interval).
+ * SQL: BETWEEN ? AND ? | MongoDB: $gte AND $lte
+ */
+export declare const RangeOperatorSchema: z.ZodObject<{
+    /** Between (inclusive) - takes [min, max] array */
+    $between: z.ZodOptional<z.ZodTuple<[z.ZodUnion<[z.ZodNumber, z.ZodDate]>, z.ZodUnion<[z.ZodNumber, z.ZodDate]>], null>>;
+}, "strip", z.ZodTypeAny, {
+    $between?: [number | Date, number | Date] | undefined;
+}, {
+    $between?: [number | Date, number | Date] | undefined;
+}>;
+/**
+ * String pattern matching operators.
+ * Note: Case sensitivity should be handled at backend level.
+ */
+export declare const StringOperatorSchema: z.ZodObject<{
+    /** Contains substring - SQL: LIKE %?% | MongoDB: $regex */
+    $contains: z.ZodOptional<z.ZodString>;
+    /** Starts with prefix - SQL: LIKE ?% | MongoDB: $regex */
+    $startsWith: z.ZodOptional<z.ZodString>;
+    /** Ends with suffix - SQL: LIKE %? | MongoDB: $regex */
+    $endsWith: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    $contains?: string | undefined;
+    $startsWith?: string | undefined;
+    $endsWith?: string | undefined;
+}, {
+    $contains?: string | undefined;
+    $startsWith?: string | undefined;
+    $endsWith?: string | undefined;
+}>;
+/**
+ * Special check operators for null and existence.
+ */
+export declare const SpecialOperatorSchema: z.ZodObject<{
+    /** Is null check - SQL: IS NULL (true) / IS NOT NULL (false) | MongoDB: field: null */
+    $null: z.ZodOptional<z.ZodBoolean>;
+    /** Field exists check (primarily for NoSQL) - MongoDB: $exists */
+    $exist: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    $null?: boolean | undefined;
+    $exist?: boolean | undefined;
+}, {
+    $null?: boolean | undefined;
+    $exist?: boolean | undefined;
+}>;
+/**
+ * All field-level operators combined.
+ * These can be applied to individual fields in a filter.
+ */
+export declare const FieldOperatorsSchema: z.ZodObject<{
+    $eq: z.ZodOptional<z.ZodAny>;
+    $ne: z.ZodOptional<z.ZodAny>;
+    $gt: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodDate]>>;
+    $gte: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodDate]>>;
+    $lt: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodDate]>>;
+    $lte: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodDate]>>;
+    $in: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    $nin: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    $between: z.ZodOptional<z.ZodTuple<[z.ZodUnion<[z.ZodNumber, z.ZodDate]>, z.ZodUnion<[z.ZodNumber, z.ZodDate]>], null>>;
+    $contains: z.ZodOptional<z.ZodString>;
+    $startsWith: z.ZodOptional<z.ZodString>;
+    $endsWith: z.ZodOptional<z.ZodString>;
+    $null: z.ZodOptional<z.ZodBoolean>;
+    $exist: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    $eq?: any;
+    $ne?: any;
+    $gt?: number | Date | undefined;
+    $gte?: number | Date | undefined;
+    $lt?: number | Date | undefined;
+    $lte?: number | Date | undefined;
+    $in?: any[] | undefined;
+    $nin?: any[] | undefined;
+    $between?: [number | Date, number | Date] | undefined;
+    $contains?: string | undefined;
+    $startsWith?: string | undefined;
+    $endsWith?: string | undefined;
+    $null?: boolean | undefined;
+    $exist?: boolean | undefined;
+}, {
+    $eq?: any;
+    $ne?: any;
+    $gt?: number | Date | undefined;
+    $gte?: number | Date | undefined;
+    $lt?: number | Date | undefined;
+    $lte?: number | Date | undefined;
+    $in?: any[] | undefined;
+    $nin?: any[] | undefined;
+    $between?: [number | Date, number | Date] | undefined;
+    $contains?: string | undefined;
+    $startsWith?: string | undefined;
+    $endsWith?: string | undefined;
+    $null?: boolean | undefined;
+    $exist?: boolean | undefined;
+}>;
+/**
+ * Recursive filter type that supports:
+ * 1. Implicit equality: { field: value }
+ * 2. Explicit operators: { field: { $op: value } }
+ * 3. Logical combinations: { $and: [...], $or: [...], $not: {...} }
+ * 4. Nested relations: { relation: { field: value } }
+ */
+export type FilterCondition = {
+    [key: string]: any | z.infer<typeof FieldOperatorsSchema> | FilterCondition;
+} & {
+    /** Logical AND - combines all conditions that must be true */
+    $and?: FilterCondition[];
+    /** Logical OR - at least one condition must be true */
+    $or?: FilterCondition[];
+    /** Logical NOT - negates the condition */
+    $not?: FilterCondition;
+};
+/**
+ * Zod schema for recursive filter validation.
+ * Uses z.lazy() to handle recursive structure.
+ */
+export declare const FilterConditionSchema: z.ZodType<FilterCondition>;
+/**
+ * Top-level query filter wrapper.
+ * This is typically used as the "where" clause in a query.
+ *
+ * @example
+ * ```typescript
+ * const filter: QueryFilter = {
+ *   where: {
+ *     status: "active",                    // Implicit equality
+ *     age: { $gte: 18 },                   // Explicit operator
+ *     $or: [                               // Logical combination
+ *       { role: "admin" },
+ *       { email: { $contains: "@company.com" } }
+ *     ],
+ *     profile: {                           // Nested relation
+ *       verified: true
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare const QueryFilterSchema: z.ZodObject<{
+    where: z.ZodOptional<z.ZodType<FilterCondition, z.ZodTypeDef, FilterCondition>>;
+}, "strip", z.ZodTypeAny, {
+    where?: FilterCondition | undefined;
+}, {
+    where?: FilterCondition | undefined;
+}>;
+/**
+ * Type-safe filter operators for use in TypeScript.
+ *
+ * @example
+ * ```typescript
+ * type UserFilter = Filter<User>;
+ *
+ * const filter: UserFilter = {
+ *   age: { $gte: 18 },
+ *   email: { $contains: "@example.com" }
+ * };
+ * ```
+ */
+export type Filter<T = any> = {
+    [K in keyof T]?: T[K] | {
+        $eq?: T[K];
+        $ne?: T[K];
+        $gt?: T[K] extends number | Date ? T[K] : never;
+        $gte?: T[K] extends number | Date ? T[K] : never;
+        $lt?: T[K] extends number | Date ? T[K] : never;
+        $lte?: T[K] extends number | Date ? T[K] : never;
+        $in?: T[K][];
+        $nin?: T[K][];
+        $between?: T[K] extends number | Date ? [T[K], T[K]] : never;
+        $contains?: T[K] extends string ? string : never;
+        $startsWith?: T[K] extends string ? string : never;
+        $endsWith?: T[K] extends string ? string : never;
+        $null?: boolean;
+        $exist?: boolean;
+    } | (T[K] extends object ? Filter<T[K]> : never);
+} & {
+    $and?: Filter<T>[];
+    $or?: Filter<T>[];
+    $not?: Filter<T>;
+};
+/**
+ * Scalar types supported by the filter system.
+ */
+export type Scalar = string | number | boolean | Date | null;
+export type FieldOperators = z.infer<typeof FieldOperatorsSchema>;
+export type QueryFilter = z.infer<typeof QueryFilterSchema>;
+/**
+ * Normalized filter AST structure.
+ * This is the internal representation after converting all syntactic sugar
+ * to explicit operators.
+ *
+ * Stage 1: Normalization Pass
+ * Input:  { age: 18, role: "admin" }
+ * Output: { $and: [{ age: { $eq: 18 } }, { role: { $eq: "admin" } }] }
+ *
+ * This simplifies adapter implementation by providing a consistent structure.
+ */
+export declare const NormalizedFilterSchema: z.ZodType<any>;
+export type NormalizedFilter = z.infer<typeof NormalizedFilterSchema>;
+/**
+ * All supported operator keys.
+ * Useful for validation and parsing.
+ */
+export declare const FILTER_OPERATORS: readonly ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in", "$nin", "$between", "$contains", "$startsWith", "$endsWith", "$null", "$exist"];
+/**
+ * Logical operator keys.
+ */
+export declare const LOGICAL_OPERATORS: readonly ["$and", "$or", "$not"];
+/**
+ * All operator keys (field + logical).
+ */
+export declare const ALL_OPERATORS: readonly ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in", "$nin", "$between", "$contains", "$startsWith", "$endsWith", "$null", "$exist", "$and", "$or", "$not"];
+export type FilterOperatorKey = typeof FILTER_OPERATORS[number];
+export type LogicalOperatorKey = typeof LOGICAL_OPERATORS[number];
+export type OperatorKey = typeof ALL_OPERATORS[number];
+//# sourceMappingURL=filter.zod.d.ts.map

package/dist/data/filter.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.zod.d.ts","sourceRoot":"","sources":["../../src/data/filter.zod.ts"],"names":[],"mappings":"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"}