@protobase/schema 0.13.4 → 0.14.1

package/dist/field.d.ts

@@ -3,48 +3,93 @@ import { FieldType } from "./model.js";
 import { FieldAccess } from "./access/types.js";
 import { z } from "zod";
 //#region src/field.d.ts
+/** A check on the value that only some field types take: `.min()`, `.max()` and `.regex()`. */
 export type Constraint = 'min' | 'max' | 'regex';
+/** Everything a field's builder methods have set, from which the resource's {@link FieldModel} is built. */
 export type FieldMeta = {
+  /** The field's type. */
   type: FieldType;
+  /** The column, when it is not the snake_case of the field's name (`.column()`). */
   column?: string;
+  /** Whether the value may be `null` (`.optional()`). */
   nullable: boolean;
+  /** Whether the API never writes it (`.readOnly()`). */
   readOnly: boolean;
+  /** Whether filters may use it (`.filterable()`). */
   filterable: boolean;
+  /** Whether sorts may use it (`.sortable()`). */
   sortable: boolean;
+  /** Other names filters may use for it (`.alias()`). */
   aliases: string[];
+  /** Whether `.default()` gave it a value. */
   hasDefault: boolean;
+  /** The value of `.default()`. */
   defaultValue?: unknown;
+  /** Whether the database supplies a value when none is given (`.dbDefault()`). */
   dbDefault?: boolean;
+  /** Its role rules (`.access()`). */
   access?: FieldAccess;
+  /** Whether it is hidden like a password (`.sensitive()`). */
   sensitive?: boolean;
+  /** An enum's values (`f.enum()`). */
   enumValues?: string[];
+  /** A relation's resource and the columns that hold its key (`f.relation()`, `.columns()`). */
   relation?: {
+    /** The resource it points at. */
     resource: string;
+    /** The columns holding the other record's key, in the order of that key; the field's own column when omitted. */
     columns?: string[];
   };
+  /** A decimal's number of digits (`f.decimal()`). */
   precision?: number;
+  /** A decimal's number of digits after the point (`f.decimal()`). */
   scale?: number;
+  /** The least value, or for text the shortest length (`.min()`). */
   min?: number;
+  /** The greatest value, or for text the longest length (`.max()`). */
   max?: number;
+  /** A pattern the text must match (`.regex()`). */
   regex?: {
+    /** The pattern. */
     re: RegExp;
+    /** The message of the issue a value that does not match gets. */
     message: string;
   };
+  /** A file field's settings (`f.file()`). */
   file?: FileOptions;
 };
+/** A field type: its name, the constraints it takes and how it builds the schema that checks a value. */
 export type FieldTypeDef = {
+  /** The field type it defines. */
   type: FieldType;
+  /** The constraints its fields may use; any other throws when the config loads. */
   constraints: readonly Constraint[];
+  /** The Zod schema of a value, from the field's settings. */
   build: (meta: FieldMeta) => z.ZodType;
 };
+/**
+ * A field of a resource, holding values of type `V`, as `f` builds it. Every option returns a new field, so they chain
+ * in any order. See [Field options](website/src/content/docs/reference/data-config.mdx#field-options).
+ */
 export declare class Field<V> {
+  /** Its field type. */
   readonly def: FieldTypeDef;
+  /** What its builder methods have set. */
   readonly meta: FieldMeta;
+  /** The Zod schema a value is checked with on every create and update: the type's, nullable and defaulted as set. */
   readonly schema: z.ZodType<V>;
-  constructor(def: FieldTypeDef, meta: FieldMeta);
+  constructor(
+  /** Its field type. */
+  def: FieldTypeDef,
+  /** What its builder methods have set. */
+  meta: FieldMeta);
+  /** The column, when it is not the snake_case of the field's name, such as `'EMP_NAME'`. */
   column(name: string): Field<V>;
+  /** Never written through the API: ids, computed columns, audit timestamps. */
   readOnly(): Field<V>;
+  /** The column is nullable: the value may be `null`. */
   optional(): Field<V | null>;
+  /** The value a create uses when none is given; the admin's create form shows it. */
   default(value: V): Field<V>;
   /**
    * Role-based rules for reading and writing this column. They never see a record, so the set of
@@ -58,14 +103,22 @@ export declare class Field<V> {
   sensitive(): Field<V>;
   /** The database supplies a value when none is given (identity, now(), ...). */
   dbDefault(): Field<V>;
+  /** Other names filters may use for the field. */
   alias(...names: string[]): Field<V>;
+  /** The field may appear in `filter`, in filter widgets and in the filters of composed pages. Give it an index. */
   filterable(): Field<V>;
+  /** The field may appear in `order_by` and in sorts. */
   sortable(): Field<V>;
+  /** Text must match `re`; a value that does not gets an issue with `message`. Only `f.text()` takes it. */
   regex(re: RegExp, message: string): Field<V>;
+  /** The least value of an integer, or the shortest length of a text. Only `f.integer()` and `f.text()` take it. */
   min(value: number): Field<V>;
+  /** The greatest value of an integer, or the longest length of a text. Only `f.integer()` and `f.text()` take it. */
   max(value: number): Field<V>;
+  /** A copy of the field with `patch` applied, which every option returns. */
   protected with(patch: Partial<FieldMeta>): Field<V>;
   private constrain;
 }
+/** A field of any value type. */
 export type AnyField = Field<any>;
 //#endregion

package/dist/field.js

@@ -1,9 +1,14 @@
 import { z } from "zod";
 //#region src/field.ts
 const fieldRegistry = z.registry();
+/**
+* A field of a resource, holding values of type `V`, as `f` builds it. Every option returns a new field, so they chain
+* in any order. See [Field options](website/src/content/docs/reference/data-config.mdx#field-options).
+*/
 var Field = class Field {
 	def;
 	meta;
+	/** The Zod schema a value is checked with on every create and update: the type's, nullable and defaulted as set. */
 	schema;
 	constructor(def, meta) {
 		this.def = def;
@@ -13,15 +18,19 @@ var Field = class Field {
 		if (meta.hasDefault) schema = schema.default(meta.defaultValue);
 		this.schema = schema.register(fieldRegistry, meta);
 	}
+	/** The column, when it is not the snake_case of the field's name, such as `'EMP_NAME'`. */
 	column(name) {
 		return this.with({ column: name });
 	}
+	/** Never written through the API: ids, computed columns, audit timestamps. */
 	readOnly() {
 		return this.with({ readOnly: true });
 	}
+	/** The column is nullable: the value may be `null`. */
 	optional() {
 		return this.with({ nullable: true });
 	}
+	/** The value a create uses when none is given; the admin's create form shows it. */
 	default(value) {
 		return this.with({
 			hasDefault: true,
@@ -49,27 +58,34 @@ var Field = class Field {
 	dbDefault() {
 		return this.with({ dbDefault: true });
 	}
+	/** Other names filters may use for the field. */
 	alias(...names) {
 		return this.with({ aliases: [...this.meta.aliases, ...names] });
 	}
+	/** The field may appear in `filter`, in filter widgets and in the filters of composed pages. Give it an index. */
 	filterable() {
 		return this.with({ filterable: true });
 	}
+	/** The field may appear in `order_by` and in sorts. */
 	sortable() {
 		return this.with({ sortable: true });
 	}
+	/** Text must match `re`; a value that does not gets an issue with `message`. Only `f.text()` takes it. */
 	regex(re, message) {
 		return this.constrain("regex", { regex: {
 			re,
 			message
 		} });
 	}
+	/** The least value of an integer, or the shortest length of a text. Only `f.integer()` and `f.text()` take it. */
 	min(value) {
 		return this.constrain("min", { min: value });
 	}
+	/** The greatest value of an integer, or the longest length of a text. Only `f.integer()` and `f.text()` take it. */
 	max(value) {
 		return this.constrain("max", { max: value });
 	}
+	/** A copy of the field with `patch` applied, which every option returns. */
 	with(patch) {
 		return new Field(this.def, {
 			...this.meta,

package/dist/fields.d.ts

@@ -3,24 +3,55 @@ import { RelationField } from "./relation-field.js";
 import { FileField } from "./file-field.js";
 import { z } from "zod";
 //#region src/fields.d.ts
+/**
+ * The field builders of a resource's `.fields({ ... })`, one per field type. Each returns a {@link Field} whose options
+ * chain in any order. See [Field types](website/src/content/docs/reference/data-config.mdx#field-types).
+ *
+ * @example
+ * ```ts
+ * .fields({
+ *   id: f.integer().readOnly().filterable().sortable().dbDefault(),
+ *   status: f.enum(['booked', 'ready', 'collected']).default('booked').filterable(),
+ *   customer_id: f.relation('customers').filterable(),
+ *   estimate: f.decimal({ precision: 8, scale: 2 }),
+ *   notes: f.text().optional().column('internal_notes'),
+ * })
+ * ```
+ */
 export declare const f: {
+  /** Text: a `text`, `varchar` or `bpchar` column. Takes `.min()`, `.max()` (length) and `.regex()`. */
   text: () => Field<string>;
+  /** A 32-bit or smaller integer: an `int2` or `int4` column. Takes `.min()` and `.max()`. */
   integer: () => Field<number>;
+  /** A 64-bit integer: an `int8` column, a string in the API so that all 64 bits survive. */
   bigint: () => Field<string>;
+  /** An exact decimal of `precision` digits, `scale` of them after the point: a `numeric` column, a string in the API. */
   decimal: (o: {
     precision: number;
     scale: number;
   }) => Field<string>;
+  /** A `bool` column. */
   boolean: () => Field<boolean>;
+  /** A `date` column, `2026-10-08` in the API. */
   date: () => Field<string>;
+  /** A `timestamp` or `timestamptz` column, ISO 8601 with an offset in the API. */
   timestamp: () => Field<string>;
+  /** A `uuid` column. */
   uuid: () => Field<string>;
+  /** One of `values`: a Postgres enum, or text with a `CHECK (... IN ...)`. The record type is the union of the values. */
   enum: <const T extends readonly string[]>(values: T) => Field<T[number]>;
+  /** Any JSON: a `json` or `jsonb` column. */
   json: () => Field<z.core.util.JSONType>;
+  /**
+   * The key of a record of `resource`, in that resource's key column(s); the admin shows the other record's title and
+   * links to it. A relation to a resource with a key of several columns names them with `.columns()`.
+   */
   relation: (resource: string) => RelationField<string | number>;
   /** A file: its column holds `{provider}:{path}?name=…&size=…` as text, and responses carry `{ uri, name, type, size, url }`. */
   file: () => FileField<string>;
+  /** An ISO 4217 currency code such as `EUR`, in a `text` column. */
   currency: () => Field<string>;
+  /** An ISO 3166-1 alpha-2 country code such as `NL`, in a `text` column. */
   country: () => Field<string>;
 };
 //#endregion

package/dist/fields.js

@@ -30,17 +30,46 @@ const make = (def, extra = {}) => new Field(def, {
 	...baseMeta(def),
 	...extra
 });
+/**
+* The field builders of a resource's `.fields({ ... })`, one per field type. Each returns a {@link Field} whose options
+* chain in any order. See [Field types](website/src/content/docs/reference/data-config.mdx#field-types).
+*
+* @example
+* ```ts
+* .fields({
+*   id: f.integer().readOnly().filterable().sortable().dbDefault(),
+*   status: f.enum(['booked', 'ready', 'collected']).default('booked').filterable(),
+*   customer_id: f.relation('customers').filterable(),
+*   estimate: f.decimal({ precision: 8, scale: 2 }),
+*   notes: f.text().optional().column('internal_notes'),
+* })
+* ```
+*/
 const f = {
+	/** Text: a `text`, `varchar` or `bpchar` column. Takes `.min()`, `.max()` (length) and `.regex()`. */
 	text: () => make(text),
+	/** A 32-bit or smaller integer: an `int2` or `int4` column. Takes `.min()` and `.max()`. */
 	integer: () => make(integer),
+	/** A 64-bit integer: an `int8` column, a string in the API so that all 64 bits survive. */
 	bigint: () => make(bigint),
+	/** An exact decimal of `precision` digits, `scale` of them after the point: a `numeric` column, a string in the API. */
 	decimal: (o) => make(decimal, o),
+	/** A `bool` column. */
 	boolean: () => make(boolean),
+	/** A `date` column, `2026-10-08` in the API. */
 	date: () => make(date),
+	/** A `timestamp` or `timestamptz` column, ISO 8601 with an offset in the API. */
 	timestamp: () => make(timestamp),
+	/** A `uuid` column. */
 	uuid: () => make(uuid),
+	/** One of `values`: a Postgres enum, or text with a `CHECK (... IN ...)`. The record type is the union of the values. */
 	enum: (values) => make(enumeration, { enumValues: [...values] }),
+	/** Any JSON: a `json` or `jsonb` column. */
 	json: () => make(json),
+	/**
+	* The key of a record of `resource`, in that resource's key column(s); the admin shows the other record's title and
+	* links to it. A relation to a resource with a key of several columns names them with `.columns()`.
+	*/
 	relation: (resource) => new RelationField(relation, {
 		...baseMeta(relation),
 		relation: { resource }
@@ -54,7 +83,9 @@ const f = {
 			provider: "private"
 		}
 	}),
+	/** An ISO 4217 currency code such as `EUR`, in a `text` column. */
 	currency: () => make(currency),
+	/** An ISO 3166-1 alpha-2 country code such as `NL`, in a `text` column. */
 	country: () => make(country)
 };
 //#endregion

package/dist/file-field.d.ts

@@ -2,7 +2,7 @@ import { FileProcessor, ImageVariant, ImageVariantOptions } from "./files/file-o
 import { FieldAccess } from "./access/types.js";
 import { Field, FieldMeta } from "./field.js";
 //#region src/file-field.d.ts
-/** `f.file()`: a text column holding a file's URI, uploaded through `:upload`. */
+/** `f.file()`: a text column holding a file's URI, uploaded through `:upload`. See [Files](website/src/content/docs/reference/files.mdx). */
 export declare class FileField<V> extends Field<V> {
   /** Allowed types, checked against the type detected from the content: `['image/*', 'application/pdf']`. */
   accept(types: readonly string[]): FileField<V>;
@@ -27,10 +27,15 @@ export declare class FileField<V> extends Field<V> {
    * format: 'webp' } }`. `{ original }` stores that image instead of the upload. Other files get none.
    */
   variants(variants: Record<string, ImageVariant>, options?: ImageVariantOptions): FileField<V>;
+  /** The column is nullable: the field may hold no file. */
   optional(): FileField<V | null>;
+  /** Never written through the API. */
   readOnly(): FileField<V>;
+  /** The column, when it is not the snake_case of the field's name. */
   column(name: string): FileField<V>;
+  /** Role-based rules for reading and writing the file; uploading needs write access to the field. */
   access(rules: FieldAccess): FileField<V>;
+  /** A copy of the field with `patch` applied, which every option returns. */
   protected with(patch: Partial<FieldMeta>): FileField<V>;
   private withFile;
 }

package/dist/file-field.js

@@ -1,7 +1,7 @@
 import { Field } from "./field.js";
 import { checkedAccept, checkedProvider, checkedVariant, checkedVariants, parseSize } from "./files/file-options.js";
 //#region src/file-field.ts
-/** `f.file()`: a text column holding a file's URI, uploaded through `:upload`. */
+/** `f.file()`: a text column holding a file's URI, uploaded through `:upload`. See [Files](website/src/content/docs/reference/files.mdx). */
 var FileField = class FileField extends Field {
 	/** Allowed types, checked against the type detected from the content: `['image/*', 'application/pdf']`. */
 	accept(types) {
@@ -49,21 +49,26 @@ var FileField = class FileField extends Field {
 			...options.original && { original: checkedVariant("The original", options.original) }
 		});
 	}
+	/** The column is nullable: the field may hold no file. */
 	optional() {
 		return this.with({ nullable: true });
 	}
+	/** Never written through the API. */
 	readOnly() {
 		return this.with({ readOnly: true });
 	}
+	/** The column, when it is not the snake_case of the field's name. */
 	column(name) {
 		return this.with({ column: name });
 	}
+	/** Role-based rules for reading and writing the file; uploading needs write access to the field. */
 	access(rules) {
 		return this.with({ access: {
 			...this.meta.access,
 			...rules
 		} });
 	}
+	/** A copy of the field with `patch` applied, which every option returns. */
 	with(patch) {
 		return new FileField(this.def, {
 			...this.meta,

package/dist/files/file-options.d.ts

@@ -1,8 +1,11 @@
 //#region src/files/file-options.d.ts
 /** What a processor gets: the stored upload's decided type, size and name, its first bytes, and the whole of it on demand. */
 export type FileProcessorInput = {
+  /** The file's name, its extension matched to the decided type. */
   name: string;
+  /** The type decided from the content, such as `image/jpeg`. */
   type: string;
+  /** The size in bytes. */
   size: number;
   /** The first bytes of the content (up to 256 KB), enough for image headers. */
   head: Uint8Array;
@@ -16,10 +19,12 @@ export type FileProcessorInput = {
 export type FileProcessor = {
   /** Exact types and `type/*` wildcards; every type when omitted. */
   accepts?: readonly string[];
+  /** The value for the column, which must pass that field's schema. */
   run: (file: FileProcessorInput) => unknown;
 };
 /** The formats an image variant is written in. */
 export declare const imageFormats: readonly ["webp", "avif", "jpeg", "png"];
+/** A format an image variant is written in: `webp`, `avif`, `jpeg` or `png`. */
 export type ImageFormat = (typeof imageFormats)[number];
 /**
  * A resized copy of an uploaded image: at most `width` by `height` pixels, never enlarged. `inside` (the default) keeps
@@ -27,25 +32,37 @@ export type ImageFormat = (typeof imageFormats)[number];
  * format's default when omitted.
  */
 export type ImageVariant = {
+  /** The largest width in pixels; any width when omitted. */
   width?: number;
+  /** The largest height in pixels; any height when omitted. */
   height?: number;
+  /** `inside` keeps the whole image within the box; `cover` fills the box and crops the rest, and needs both sides. */
   fit?: 'inside' | 'cover';
+  /** The format it is written in. */
   format: ImageFormat;
+  /** 1 to 100; the format's default when omitted. */
   quality?: number;
 };
 /** `.variants()`' second argument: `original` replaces the upload by that image, so the upload itself is not kept. */
 export type ImageVariantOptions = {
+  /** The image stored instead of the upload, such as `{ width: 2560, format: 'webp' }`. */
   original?: ImageVariant;
 };
 /** A file field's settings, as the builder collects them. */
 export type FileOptions = {
+  /** The allowed types and `type/*` wildcards (`.accept()`); any type when empty. */
   accept: string[];
+  /** The largest upload in bytes (`.maxSize()`). */
   maxSize: number;
+  /** The provider of `files.providers` the files are stored with (`.storage()`, `.public()`). */
   provider: string;
+  /** The processors computing other fields from each upload, by field name (`.derive()`). */
   derive?: Record<string, FileProcessor>;
   /** The read-only text field each image's ThumbHash goes to (`.placeholder()`). */
   placeholder?: string;
+  /** The resized copies stored beside each image, by name (`.variants()`). */
   variants?: Record<string, ImageVariant>;
+  /** The image stored instead of the upload (`.variants()`' `original`). */
   original?: ImageVariant;
 };
 /** Bytes from a number or text such as `10 MB` (decimal units) or `5 MiB` (binary units). */

package/dist/filter/check.d.ts

@@ -1,10 +1,15 @@
 import { CheckedFilter, FilterError, FilterExpr, ResourceModel } from "../model.js";
 //#region src/filter/check.d.ts
+/** What `checkFilter` gives: the filter with each field resolved to its model, or the errors. */
 export type CheckResult = {
+  /** The filter is valid for the resource. */
   ok: true;
+  /** The filter, each field resolved to the resource's field model. */
   filter: CheckedFilter;
 } | {
+  /** The filter is not valid for the resource. */
   ok: false;
+  /** Each problem, with where it is in the text. */
   errors: FilterError[];
 };
 /**

package/dist/filter/evaluate.d.ts

@@ -1,5 +1,6 @@
 import { CheckedFilter } from "../model.js";
 //#region src/filter/evaluate.d.ts
+/** How `evaluateFilter` evaluates. */
 export type EvaluateOptions = {
   /** Clock for `now()`; defaults to the current time. */
   now?: () => Date;

package/dist/filter/order-by.d.ts

@@ -1,22 +1,36 @@
 import { FilterError, OrderByItem, ResourceModel, SortSpec } from "../model.js";
 //#region src/filter/order-by.d.ts
+/** What `parseOrderBy` gives: the order's items, or the errors. */
 export type OrderByParse = {
+  /** The text parsed. */
   ok: true;
+  /** The fields to sort on, in order. */
   items: OrderByItem[];
+  /** None. */
   errors: [];
 } | {
+  /** The text did not parse. */
   ok: false;
+  /** The items that parsed. */
   items: OrderByItem[];
+  /** Each problem, with where it is in the text. */
   errors: FilterError[];
 };
+/** What `checkOrderBy` gives: the sort, or the errors. */
 export type OrderByCheck = {
+  /** The order is valid for the resource. */
   ok: true;
+  /** The fields to sort on and their directions, in order. */
   sort: SortSpec;
 } | {
+  /** The order is not valid for the resource. */
   ok: false;
+  /** Each problem, with where it is in the text. */
   errors: FilterError[];
 };
+/** Parses order text, AIP-132 as the API's `order_by` takes it, such as `created_at desc, name`; `asc` and `desc` in any case. */
 export declare const parseOrderBy: (source: string) => OrderByParse;
+/** The order as text, as `parseOrderBy` reads it. */
 export declare const printOrderBy: (items: OrderByItem[]) => string;
 /** Validates against sortable fields; traversal is not supported yet. */
 export declare const checkOrderBy: (model: ResourceModel, items: OrderByItem[]) => OrderByCheck;

package/dist/filter/order-by.js

@@ -8,6 +8,7 @@ const generic = (items) => items.map((item) => ({
 	span: item.span
 }));
 const lowercaseDirections = (source) => source.replace(/([^\s,])(\s+)(asc|desc)(?=\s|,|$)/gi, (_, before, space, word) => `${before}${space}${word.toLowerCase()}`);
+/** Parses order text, AIP-132 as the API's `order_by` takes it, such as `created_at desc, name`; `asc` and `desc` in any case. */
 const parseOrderBy$1 = (source) => {
 	const parsed = parseOrderBy(lowercaseDirections(source));
 	const items = parsed.items.map((item) => ({
@@ -29,6 +30,7 @@ const parseOrderBy$1 = (source) => {
 		errors: parsed.errors
 	};
 };
+/** The order as text, as `parseOrderBy` reads it. */
 const printOrderBy$1 = (items) => printOrderBy(generic(items));
 /** Validates against sortable fields; traversal is not supported yet. */
 const checkOrderBy$1 = (model, items) => {

package/dist/filter/parse.d.ts

@@ -1,19 +1,33 @@
 import { FilterError, FilterExpr } from "../model.js";
 import { ParseOptions } from "aip-parsers/filter";
 //#region src/filter/parse.d.ts
+/** What `parseFilter` gives: the filter, `undefined` for empty text, or the errors in the order they occur in the text. */
 export type FilterParse = {
+  /** The text parsed. */
   ok: true;
+  /** The filter, or `undefined` when the text is empty. */
   ast: FilterExpr | undefined;
+  /** None. */
   errors: [];
 } | {
+  /** The text did not parse. */
   ok: false;
+  /** As much of the filter as parsed. */
   ast: FilterExpr | undefined;
+  /** Each problem, with where it is in the text. */
   errors: FilterError[];
 };
+/** Bounds on filter text: its length in characters and how deeply its expressions nest. */
 export type FilterLimits = Pick<ParseOptions, 'maxLength' | 'maxDepth'>;
 /**
- * Parses with the library, then lowers to Protobase's filter shape. Collects all errors.
- * `maxLength` defaults to 10,000 characters and `maxDepth` to 64.
+ * Parses filter text, AIP-160 as the API takes it, into a filter, collecting every error. `maxLength` defaults to
+ * 10,000 characters and `maxDepth` to 64. Check the result against a resource with `checkFilter` before running it.
+ *
+ * @example
+ * ```ts
+ * const parsed = parseFilter('status = "paid" AND total > 100')
+ * if (parsed.ok && parsed.ast) printFilter(parsed.ast) // 'status = "paid" AND total > 100'
+ * ```
  */
 declare const parseFilter$1: (source: string, limits?: FilterLimits) => FilterParse;
 //#endregion

package/dist/filter/parse.js

@@ -3,8 +3,14 @@ import { lower } from "./lower.js";
 import { parseFilter } from "aip-parsers/filter";
 //#region src/filter/parse.ts
 /**
-* Parses with the library, then lowers to Protobase's filter shape. Collects all errors.
-* `maxLength` defaults to 10,000 characters and `maxDepth` to 64.
+* Parses filter text, AIP-160 as the API takes it, into a filter, collecting every error. `maxLength` defaults to
+* 10,000 characters and `maxDepth` to 64. Check the result against a resource with `checkFilter` before running it.
+*
+* @example
+* ```ts
+* const parsed = parseFilter('status = "paid" AND total > 100')
+* if (parsed.ok && parsed.ast) printFilter(parsed.ast) // 'status = "paid" AND total > 100'
+* ```
 */
 const parseFilter$1 = (source, limits = {}) => {
 	const parsed = parseFilter(source, {