@objectstack/spec 1.0.5 → 1.0.7

package/dist/{field.zod-Da5S-hAo.d.ts → field.zod-dhbAw0SA.d.mts}

@@ -1,5 +1,875 @@
+import { F as FilterCondition } from './filter.zod-BMWnz4HE.mjs';
 import { z } from 'zod';
 
+/**
+ * Sort Node
+ * Represents "Order By".
+ */
+declare const SortNodeSchema: z.ZodObject<{
+    field: z.ZodString;
+    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+}, "strip", z.ZodTypeAny, {
+    field: string;
+    order: "asc" | "desc";
+}, {
+    field: string;
+    order?: "asc" | "desc" | undefined;
+}>;
+/**
+ * Aggregation Function Enum
+ * Standard aggregation functions for data analysis.
+ *
+ * Supported Functions:
+ * - **count**: Count rows (SQL: COUNT(*) or COUNT(field))
+ * - **sum**: Sum numeric values (SQL: SUM(field))
+ * - **avg**: Average numeric values (SQL: AVG(field))
+ * - **min**: Minimum value (SQL: MIN(field))
+ * - **max**: Maximum value (SQL: MAX(field))
+ * - **count_distinct**: Count unique values (SQL: COUNT(DISTINCT field))
+ * - **array_agg**: Aggregate values into array (SQL: ARRAY_AGG(field))
+ * - **string_agg**: Concatenate values (SQL: STRING_AGG(field, delimiter))
+ *
+ * Performance Considerations:
+ * - COUNT(*) is typically faster than COUNT(field) as it doesn't check for nulls
+ * - COUNT DISTINCT may require additional memory for tracking unique values
+ * - Window aggregates (with OVER clause) can be more efficient than subqueries
+ * - Large GROUP BY operations benefit from proper indexing on grouped fields
+ *
+ * @example
+ * // SQL: SELECT region, SUM(amount) FROM sales GROUP BY region
+ * {
+ *   object: 'sales',
+ *   fields: ['region'],
+ *   aggregations: [
+ *     { function: 'sum', field: 'amount', alias: 'total_sales' }
+ *   ],
+ *   groupBy: ['region']
+ * }
+ *
+ * @example
+ * // Salesforce SOQL: SELECT COUNT(Id) FROM Account
+ * {
+ *   object: 'account',
+ *   aggregations: [
+ *     { function: 'count', alias: 'total_accounts' }
+ *   ]
+ * }
+ */
+declare const AggregationFunction: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+/**
+ * Aggregation Node
+ * Represents an aggregated field with function.
+ *
+ * Aggregations summarize data across groups of rows (GROUP BY).
+ * Used with `groupBy` to create analytical queries.
+ *
+ * @example
+ * // SQL: SELECT customer_id, COUNT(*), SUM(amount) FROM orders GROUP BY customer_id
+ * {
+ *   object: 'order',
+ *   fields: ['customer_id'],
+ *   aggregations: [
+ *     { function: 'count', alias: 'order_count' },
+ *     { function: 'sum', field: 'amount', alias: 'total_amount' }
+ *   ],
+ *   groupBy: ['customer_id']
+ * }
+ *
+ * @example
+ * // Salesforce SOQL: SELECT LeadSource, COUNT(Id) FROM Lead GROUP BY LeadSource
+ * {
+ *   object: 'lead',
+ *   fields: ['lead_source'],
+ *   aggregations: [
+ *     { function: 'count', alias: 'lead_count' }
+ *   ],
+ *   groupBy: ['lead_source']
+ * }
+ */
+declare const AggregationNodeSchema: z.ZodObject<{
+    function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+    field: z.ZodOptional<z.ZodString>;
+    alias: z.ZodString;
+    distinct: z.ZodOptional<z.ZodBoolean>;
+    filter: z.ZodOptional<z.ZodType<FilterCondition, z.ZodTypeDef, FilterCondition>>;
+}, "strip", z.ZodTypeAny, {
+    function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+    alias: string;
+    filter?: FilterCondition | undefined;
+    field?: string | undefined;
+    distinct?: boolean | undefined;
+}, {
+    function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+    alias: string;
+    filter?: FilterCondition | undefined;
+    field?: string | undefined;
+    distinct?: boolean | undefined;
+}>;
+/**
+ * Join Type Enum
+ * Standard SQL join types for combining tables.
+ *
+ * Join Types:
+ * - **inner**: Returns only matching rows from both tables (SQL: INNER JOIN)
+ * - **left**: Returns all rows from left table, matching rows from right (SQL: LEFT JOIN)
+ * - **right**: Returns all rows from right table, matching rows from left (SQL: RIGHT JOIN)
+ * - **full**: Returns all rows from both tables (SQL: FULL OUTER JOIN)
+ *
+ * @example
+ * // SQL: SELECT * FROM orders INNER JOIN customers ON orders.customer_id = customers.id
+ * {
+ *   object: 'order',
+ *   joins: [
+ *     {
+ *       type: 'inner',
+ *       object: 'customer',
+ *       on: ['order.customer_id', '=', 'customer.id']
+ *     }
+ *   ]
+ * }
+ *
+ * @example
+ * // Salesforce SOQL-style: Find all customers and their orders (if any)
+ * {
+ *   object: 'customer',
+ *   joins: [
+ *     {
+ *       type: 'left',
+ *       object: 'order',
+ *       on: ['customer.id', '=', 'order.customer_id']
+ *     }
+ *   ]
+ * }
+ */
+declare const JoinType: z.ZodEnum<["inner", "left", "right", "full"]>;
+/**
+ * Join Execution Strategy
+ * Hints to the query engine on how to execute the join.
+ *
+ * Strategies:
+ * - **auto**: Engine decides best strategy (Default).
+ * - **database**: Push down join to the database (Requires same datasource).
+ * - **hash**: Load both sets into memory and hash join (Cross-datasource, memory intensive).
+ * - **loop**: Nested loop lookup (N+1 safe version). (Good for small right-side lookups).
+ */
+declare const JoinStrategy: z.ZodEnum<["auto", "database", "hash", "loop"]>;
+/**
+ * Join Node
+ * Represents table joins for combining data from multiple objects.
+ *
+ * Joins connect related data across multiple tables using ON conditions.
+ * Supports both direct object joins and subquery joins.
+ *
+ * @example
+ * // SQL: SELECT o.*, c.name FROM orders o INNER JOIN customers c ON o.customer_id = c.id
+ * {
+ *   object: 'order',
+ *   fields: ['id', 'amount'],
+ *   joins: [
+ *     {
+ *       type: 'inner',
+ *       object: 'customer',
+ *       alias: 'c',
+ *       on: ['order.customer_id', '=', 'c.id']
+ *     }
+ *   ]
+ * }
+ *
+ * @example
+ * // SQL: Multi-table join
+ * // SELECT * FROM orders o
+ * // INNER JOIN customers c ON o.customer_id = c.id
+ * // LEFT JOIN shipments s ON o.id = s.order_id
+ * {
+ *   object: 'order',
+ *   joins: [
+ *     {
+ *       type: 'inner',
+ *       object: 'customer',
+ *       alias: 'c',
+ *       on: ['order.customer_id', '=', 'c.id']
+ *     },
+ *     {
+ *       type: 'left',
+ *       object: 'shipment',
+ *       alias: 's',
+ *       on: ['order.id', '=', 's.order_id']
+ *     }
+ *   ]
+ * }
+ *
+ * @example
+ * // Salesforce SOQL: SELECT Name, (SELECT LastName FROM Contacts) FROM Account
+ * {
+ *   object: 'account',
+ *   fields: ['name'],
+ *   joins: [
+ *     {
+ *       type: 'left',
+ *       object: 'contact',
+ *       on: ['account.id', '=', 'contact.account_id']
+ *     }
+ *   ]
+ * }
+ *
+ * @example
+ * // Subquery Join: Join with a filtered/aggregated dataset
+ * {
+ *   object: 'customer',
+ *   joins: [
+ *     {
+ *       type: 'left',
+ *       object: 'order',
+ *       alias: 'high_value_orders',
+ *       on: ['customer.id', '=', 'high_value_orders.customer_id'],
+ *       subquery: {
+ *         object: 'order',
+ *         fields: ['customer_id', 'total'],
+ *         filters: ['total', '>', 1000]
+ *       }
+ *     }
+ *   ]
+ * }
+ */
+declare const JoinNodeSchema: z.ZodType<any>;
+/**
+ * Window Function Enum
+ * Advanced analytical functions for row-based calculations.
+ *
+ * Window Functions:
+ * - **row_number**: Sequential number within partition (SQL: ROW_NUMBER() OVER (...))
+ * - **rank**: Rank with gaps for ties (SQL: RANK() OVER (...))
+ * - **dense_rank**: Rank without gaps (SQL: DENSE_RANK() OVER (...))
+ * - **percent_rank**: Relative rank as percentage (SQL: PERCENT_RANK() OVER (...))
+ * - **lag**: Access previous row value (SQL: LAG(field) OVER (...))
+ * - **lead**: Access next row value (SQL: LEAD(field) OVER (...))
+ * - **first_value**: First value in window (SQL: FIRST_VALUE(field) OVER (...))
+ * - **last_value**: Last value in window (SQL: LAST_VALUE(field) OVER (...))
+ * - **sum/avg/count/min/max**: Aggregates over window (SQL: SUM(field) OVER (...))
+ *
+ * @example
+ * // SQL: SELECT *, ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY amount DESC) as rank
+ * //      FROM orders
+ * {
+ *   object: 'order',
+ *   fields: ['id', 'customer_id', 'amount'],
+ *   windowFunctions: [
+ *     {
+ *       function: 'row_number',
+ *       alias: 'rank',
+ *       over: {
+ *         partitionBy: ['customer_id'],
+ *         orderBy: [{ field: 'amount', order: 'desc' }]
+ *       }
+ *     }
+ *   ]
+ * }
+ *
+ * @example
+ * // SQL: Running total with SUM() OVER (...)
+ * {
+ *   object: 'transaction',
+ *   fields: ['date', 'amount'],
+ *   windowFunctions: [
+ *     {
+ *       function: 'sum',
+ *       field: 'amount',
+ *       alias: 'running_total',
+ *       over: {
+ *         orderBy: [{ field: 'date', order: 'asc' }],
+ *         frame: {
+ *           type: 'rows',
+ *           start: 'UNBOUNDED PRECEDING',
+ *           end: 'CURRENT ROW'
+ *         }
+ *       }
+ *     }
+ *   ]
+ * }
+ */
+declare const WindowFunction: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+/**
+ * Window Specification
+ * Defines PARTITION BY and ORDER BY for window functions.
+ *
+ * Window specifications control how window functions compute values:
+ * - **partitionBy**: Divide rows into groups (like GROUP BY but without collapsing rows)
+ * - **orderBy**: Define order for ranking and offset functions
+ * - **frame**: Specify which rows to include in aggregate calculations
+ *
+ * @example
+ * // Partition by department, order by salary
+ * {
+ *   partitionBy: ['department'],
+ *   orderBy: [{ field: 'salary', order: 'desc' }]
+ * }
+ *
+ * @example
+ * // Moving average with frame specification
+ * {
+ *   orderBy: [{ field: 'date', order: 'asc' }],
+ *   frame: {
+ *     type: 'rows',
+ *     start: '6 PRECEDING',
+ *     end: 'CURRENT ROW'
+ *   }
+ * }
+ */
+declare const WindowSpecSchema: z.ZodObject<{
+    partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        order: "asc" | "desc";
+    }, {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }>, "many">>;
+    frame: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+        start: z.ZodOptional<z.ZodString>;
+        end: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    }, {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    orderBy?: {
+        field: string;
+        order: "asc" | "desc";
+    }[] | undefined;
+    partitionBy?: string[] | undefined;
+    frame?: {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    } | undefined;
+}, {
+    orderBy?: {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }[] | undefined;
+    partitionBy?: string[] | undefined;
+    frame?: {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    } | undefined;
+}>;
+/**
+ * Window Function Node
+ * Represents window function with OVER clause.
+ *
+ * Window functions perform calculations across a set of rows related to the current row,
+ * without collapsing the result set (unlike GROUP BY aggregations).
+ *
+ * @example
+ * // SQL: Top 3 products per category
+ * // SELECT *, ROW_NUMBER() OVER (PARTITION BY category ORDER BY sales DESC) as rank
+ * // FROM products
+ * {
+ *   object: 'product',
+ *   fields: ['name', 'category', 'sales'],
+ *   windowFunctions: [
+ *     {
+ *       function: 'row_number',
+ *       alias: 'category_rank',
+ *       over: {
+ *         partitionBy: ['category'],
+ *         orderBy: [{ field: 'sales', order: 'desc' }]
+ *       }
+ *     }
+ *   ]
+ * }
+ *
+ * @example
+ * // SQL: Year-over-year comparison with LAG
+ * {
+ *   object: 'monthly_sales',
+ *   fields: ['month', 'revenue'],
+ *   windowFunctions: [
+ *     {
+ *       function: 'lag',
+ *       field: 'revenue',
+ *       alias: 'prev_year_revenue',
+ *       over: {
+ *         orderBy: [{ field: 'month', order: 'asc' }]
+ *       }
+ *     }
+ *   ]
+ * }
+ */
+declare const WindowFunctionNodeSchema: z.ZodObject<{
+    function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+    field: z.ZodOptional<z.ZodString>;
+    alias: z.ZodString;
+    over: z.ZodObject<{
+        partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        frame: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+            start: z.ZodOptional<z.ZodString>;
+            end: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        }, {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        partitionBy?: string[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    }, {
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        partitionBy?: string[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+    alias: string;
+    over: {
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        partitionBy?: string[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    };
+    field?: string | undefined;
+}, {
+    function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+    alias: string;
+    over: {
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        partitionBy?: string[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    };
+    field?: string | undefined;
+}>;
+/**
+ * Field Selection Node
+ * Represents "Select" attributes, including joins.
+ */
+declare const FieldNodeSchema: z.ZodType<any>;
+/**
+ * Full-Text Search Configuration
+ * Defines full-text search parameters for text queries.
+ *
+ * Supports:
+ * - Multi-field search
+ * - Relevance scoring
+ * - Fuzzy matching
+ * - Language-specific analyzers
+ *
+ * @example
+ * {
+ *   query: "John Smith",
+ *   fields: ["name", "email", "description"],
+ *   fuzzy: true,
+ *   boost: { "name": 2.0, "email": 1.5 }
+ * }
+ */
+declare const FullTextSearchSchema: z.ZodObject<{
+    query: z.ZodString;
+    fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    fuzzy: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    operator: z.ZodDefault<z.ZodOptional<z.ZodEnum<["and", "or"]>>>;
+    boost: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    minScore: z.ZodOptional<z.ZodNumber>;
+    language: z.ZodOptional<z.ZodString>;
+    highlight: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    fuzzy: boolean;
+    operator: "and" | "or";
+    highlight: boolean;
+    fields?: string[] | undefined;
+    boost?: Record<string, number> | undefined;
+    minScore?: number | undefined;
+    language?: string | undefined;
+}, {
+    query: string;
+    fields?: string[] | undefined;
+    fuzzy?: boolean | undefined;
+    operator?: "and" | "or" | undefined;
+    boost?: Record<string, number> | undefined;
+    minScore?: number | undefined;
+    language?: string | undefined;
+    highlight?: boolean | undefined;
+}>;
+type FullTextSearch = z.infer<typeof FullTextSearchSchema>;
+/**
+ * Query AST Schema
+ * The universal data retrieval contract defined in `ast-structure.mdx`.
+ *
+ * This schema represents ObjectQL - a universal query language that abstracts
+ * SQL, NoSQL, and SaaS APIs into a single unified interface.
+ *
+ * Updates (v2):
+ * - Aligned with modern ORM standards (Prisma/TypeORM)
+ * - Added `cursor` based pagination support
+ * - Renamed `top`/`skip` to `limit`/`offset`
+ * - Unified filtering syntax with `FilterConditionSchema`
+ *
+ * Updates (v3):
+ * - Added `search` parameter for full-text search (P2 requirement)
+ *
+ * @example
+ * // Simple query: SELECT name, email FROM account WHERE status = 'active'
+ * {
+ *   object: 'account',
+ *   fields: ['name', 'email'],
+ *   where: { status: 'active' }
+ * }
+ *
+ * @example
+ * // Pagination with Limit/Offset
+ * {
+ *   object: 'post',
+ *   where: { published: true },
+ *   orderBy: [{ field: 'created_at', order: 'desc' }],
+ *   limit: 20,
+ *   offset: 40
+ * }
+ *
+ * @example
+ * // Full-text search
+ * {
+ *   object: 'article',
+ *   search: {
+ *     query: "machine learning",
+ *     fields: ["title", "content"],
+ *     fuzzy: true,
+ *     boost: { "title": 2.0 }
+ *   },
+ *   limit: 10
+ * }
+ */
+declare const BaseQuerySchema: z.ZodObject<{
+    /** Target Entity */
+    object: z.ZodString;
+    /** Select Clause */
+    fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+    /** Where Clause (Filtering) */
+    where: z.ZodOptional<z.ZodType<FilterCondition, z.ZodTypeDef, FilterCondition>>;
+    /** Full-Text Search */
+    search: z.ZodOptional<z.ZodObject<{
+        query: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        fuzzy: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        operator: z.ZodDefault<z.ZodOptional<z.ZodEnum<["and", "or"]>>>;
+        boost: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        minScore: z.ZodOptional<z.ZodNumber>;
+        language: z.ZodOptional<z.ZodString>;
+        highlight: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+        fuzzy: boolean;
+        operator: "and" | "or";
+        highlight: boolean;
+        fields?: string[] | undefined;
+        boost?: Record<string, number> | undefined;
+        minScore?: number | undefined;
+        language?: string | undefined;
+    }, {
+        query: string;
+        fields?: string[] | undefined;
+        fuzzy?: boolean | undefined;
+        operator?: "and" | "or" | undefined;
+        boost?: Record<string, number> | undefined;
+        minScore?: number | undefined;
+        language?: string | undefined;
+        highlight?: boolean | undefined;
+    }>>;
+    /** Order By Clause (Sorting) */
+    orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        order: "asc" | "desc";
+    }, {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }>, "many">>;
+    /** Pagination */
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    top: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    /** Joins */
+    joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+    /** Aggregations */
+    aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+        field: z.ZodOptional<z.ZodString>;
+        alias: z.ZodString;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+        filter: z.ZodOptional<z.ZodType<FilterCondition, z.ZodTypeDef, FilterCondition>>;
+    }, "strip", z.ZodTypeAny, {
+        function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        filter?: FilterCondition | undefined;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }, {
+        function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        filter?: FilterCondition | undefined;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }>, "many">>;
+    /** Group By Clause */
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Having Clause */
+    having: z.ZodOptional<z.ZodType<FilterCondition, z.ZodTypeDef, FilterCondition>>;
+    /** Window Functions */
+    windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+        field: z.ZodOptional<z.ZodString>;
+        alias: z.ZodString;
+        over: z.ZodObject<{
+            partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+            }, "strip", z.ZodTypeAny, {
+                field: string;
+                order: "asc" | "desc";
+            }, {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }>, "many">>;
+            frame: z.ZodOptional<z.ZodObject<{
+                type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                start: z.ZodOptional<z.ZodString>;
+                end: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            }, {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            orderBy?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | undefined;
+            partitionBy?: string[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        }, {
+            orderBy?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | undefined;
+            partitionBy?: string[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+        alias: string;
+        over: {
+            orderBy?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | undefined;
+            partitionBy?: string[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }, {
+        function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+        alias: string;
+        over: {
+            orderBy?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | undefined;
+            partitionBy?: string[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }>, "many">>;
+    /** Subquery flag */
+    distinct: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    where?: FilterCondition | undefined;
+    distinct?: boolean | undefined;
+    fields?: any[] | undefined;
+    search?: {
+        query: string;
+        fuzzy: boolean;
+        operator: "and" | "or";
+        highlight: boolean;
+        fields?: string[] | undefined;
+        boost?: Record<string, number> | undefined;
+        minScore?: number | undefined;
+        language?: string | undefined;
+    } | undefined;
+    orderBy?: {
+        field: string;
+        order: "asc" | "desc";
+    }[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    top?: number | undefined;
+    cursor?: Record<string, any> | undefined;
+    joins?: any[] | undefined;
+    aggregations?: {
+        function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        filter?: FilterCondition | undefined;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }[] | undefined;
+    groupBy?: string[] | undefined;
+    having?: FilterCondition | undefined;
+    windowFunctions?: {
+        function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+        alias: string;
+        over: {
+            orderBy?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | undefined;
+            partitionBy?: string[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }[] | undefined;
+}, {
+    object: string;
+    where?: FilterCondition | undefined;
+    distinct?: boolean | undefined;
+    fields?: any[] | undefined;
+    search?: {
+        query: string;
+        fields?: string[] | undefined;
+        fuzzy?: boolean | undefined;
+        operator?: "and" | "or" | undefined;
+        boost?: Record<string, number> | undefined;
+        minScore?: number | undefined;
+        language?: string | undefined;
+        highlight?: boolean | undefined;
+    } | undefined;
+    orderBy?: {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    top?: number | undefined;
+    cursor?: Record<string, any> | undefined;
+    joins?: any[] | undefined;
+    aggregations?: {
+        function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        filter?: FilterCondition | undefined;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }[] | undefined;
+    groupBy?: string[] | undefined;
+    having?: FilterCondition | undefined;
+    windowFunctions?: {
+        function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+        alias: string;
+        over: {
+            orderBy?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | undefined;
+            partitionBy?: string[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }[] | undefined;
+}>;
+type QueryAST = z.infer<typeof BaseQuerySchema> & {
+    expand?: Record<string, QueryAST>;
+};
+type QueryInput = z.input<typeof BaseQuerySchema> & {
+    expand?: Record<string, QueryInput>;
+};
+declare const QuerySchema: z.ZodType<QueryAST, z.ZodTypeDef, QueryInput>;
+type SortNode = z.infer<typeof SortNodeSchema>;
+type AggregationNode = z.infer<typeof AggregationNodeSchema>;
+type JoinNode = z.infer<typeof JoinNodeSchema>;
+type WindowFunctionNode = z.infer<typeof WindowFunctionNodeSchema>;
+type WindowSpec = z.infer<typeof WindowSpecSchema>;
+
 /**
  * Field Type Enum
  */
@@ -6586,4 +7456,4 @@ declare const Field: {
     };
 };
 
-export { type Address as A, type ComputedFieldCache as C, type DataQualityRules as D, FieldType as F, type LocationCoordinates as L, type SelectOption as S, type VectorConfig as V, FieldSchema as a, AddressSchema as b, ComputedFieldCacheSchema as c, type CurrencyConfig as d, CurrencyConfigSchema as e, type CurrencyValue as f, CurrencyValueSchema as g, DataQualityRulesSchema as h, Field as i, type FieldInput as j, type FileAttachmentConfig as k, FileAttachmentConfigSchema as l, LocationCoordinatesSchema as m, SelectOptionSchema as n, VectorConfigSchema as o };
+export { type Address as A, SortNodeSchema as B, type ComputedFieldCache as C, type DataQualityRules as D, VectorConfigSchema as E, FieldType as F, type WindowFunctionNode as G, WindowFunctionNodeSchema as H, type WindowSpec as I, type JoinNode as J, WindowSpecSchema as K, type LocationCoordinates as L, type QueryAST as Q, type SelectOption as S, type VectorConfig as V, WindowFunction as W, type QueryInput as a, FieldSchema as b, AddressSchema as c, AggregationFunction as d, type AggregationNode as e, AggregationNodeSchema as f, ComputedFieldCacheSchema as g, type CurrencyConfig as h, CurrencyConfigSchema as i, type CurrencyValue as j, CurrencyValueSchema as k, DataQualityRulesSchema as l, Field as m, type FieldInput as n, FieldNodeSchema as o, type FileAttachmentConfig as p, FileAttachmentConfigSchema as q, type FullTextSearch as r, FullTextSearchSchema as s, JoinNodeSchema as t, JoinStrategy as u, JoinType as v, LocationCoordinatesSchema as w, QuerySchema as x, SelectOptionSchema as y, type SortNode as z };