@plumile/filter-query 0.1.32 → 0.1.33

package/src/__tests__/list-edge.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { defineSchema, numberField } from '../schema.js';
-import { parse } from '../parse.js';
-
-const schema = defineSchema({ price: numberField(['in']) });
-
-describe('list operator edge cases', () => {
-  it('empty list value produces no filter entry and an InvalidValue diagnostic', () => {
-    const { filters, diagnostics } = parse('price.in=', schema);
-    expect(filters.price).toBeUndefined();
-    const invalids = diagnostics.filter((d) => {
-      return d.kind === 'InvalidValue';
-    });
-    expect(invalids.length).toBe(1);
-  });
-
-  it('decode error in list value yields DecodeError diagnostic and no filter change', () => {
-    const { filters, diagnostics } = parse('price.in=1%ZZ', schema);
-    expect(filters).toEqual({});
-    expect(
-      diagnostics.some((d) => {
-        return d.kind === 'DecodeError' && d.operator === 'in';
-      }),
-    ).toBe(true);
-  });
-});

package/src/__tests__/mutate.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { defineSchema, numberField, stringField } from '../schema.js';
-import { setFilter, removeFilter, mergeFilters, isEmpty } from '../mutate.js';
-import { parse } from '../parse.js';
-
-const schema = defineSchema({
-  price: numberField(),
-  title: stringField(),
-});
-
-describe('mutate helpers', () => {
-  it('setFilter adds and removes operators while cleaning up empty fields', () => {
-    const base = parse('price.gt=10', schema).filters;
-    const withBetween = setFilter(base, schema, 'price', 'between', [1, 2]);
-    expect(withBetween).not.toBe(base);
-    expect(withBetween.price?.between).toEqual([1, 2]);
-    expect(isEmpty(withBetween)).toBe(false);
-
-    const removedBetween = setFilter(
-      withBetween,
-      schema,
-      'price',
-      'between',
-      undefined,
-    );
-    expect(removedBetween.price?.between).toBeUndefined();
-    expect(removedBetween.price?.gt).toBe(10);
-
-    const withoutField = setFilter(
-      removedBetween,
-      schema,
-      'price',
-      'gt',
-      undefined,
-    );
-    expect(withoutField.price).toBeUndefined();
-    expect(isEmpty(withoutField)).toBe(true);
-  });
-
-  it('setFilter keeps reference when writing same scalar value', () => {
-    const base = parse('title.eq=hello', schema).filters;
-    const same = setFilter(base, schema, 'title', 'eq', 'hello');
-    expect(same).toBe(base);
-  });
-
-  it('removeFilter drops only the targeted operator and preserves others', () => {
-    const base = parse('price.gt=10&price.lt=20', schema).filters;
-    const withoutGt = removeFilter(base, 'price', 'gt');
-    expect(withoutGt).not.toBe(base);
-    expect(withoutGt.price?.lt).toBe(20);
-    expect(withoutGt.price?.gt).toBeUndefined();
-
-    const withoutAny = removeFilter(withoutGt, 'price', 'lt');
-    expect(withoutAny.price).toBeUndefined();
-    expect(isEmpty(withoutAny)).toBe(true);
-  });
-
-  it('removeFilter returns original reference when nothing changes', () => {
-    const base = parse('price.gt=10', schema).filters;
-    const untouched = removeFilter(base, 'title');
-    expect(untouched).toBe(base);
-  });
-
-  it('mergeFilters merges incoming values and preserves reference when unchanged', () => {
-    const a = parse('price.gt=10&title.contains=foo', schema).filters;
-    const identical = mergeFilters(a, parse('price.gt=10', schema).filters);
-    expect(identical).toBe(a);
-
-    const patch = {
-      price: { lt: 30 },
-      title: { contains: 'bar' },
-    };
-    const merged = mergeFilters(a, patch);
-    expect(merged).not.toBe(a);
-    expect(merged.price).toEqual({ lt: 30 });
-    expect(merged.title?.contains).toBe('bar');
-    expect(a.price?.gt).toBe(10); // original untouched
-  });
-
-  it('isEmpty reflects whether any filters remain', () => {
-    expect(isEmpty({})).toBe(true);
-    const parsed = parse('title.eq=hello', schema).filters;
-    expect(isEmpty(parsed)).toBe(false);
-  });
-});

package/src/__tests__/parse-stringify.test.ts

@@ -1,104 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { defineSchema, numberField, stringField } from '../schema.js';
-import { parse } from '../parse.js';
-import { stringify } from '../stringify.js';
-
-const schema = defineSchema({
-  price: numberField(),
-  title: stringField(),
-});
-
-describe('parse & stringify', () => {
-  it('parses scalar and list operators and round-trips', () => {
-    const q =
-      'price.gt=10&price.lte=100&price.in=10,20&title.contains=foo%20bar&title.in=a&title.in=b';
-    const { filters, diagnostics } = parse(q, schema);
-    expect(diagnostics.length).toBe(0);
-    expect(filters.price?.gt).toBe(10);
-    expect(filters.price?.lte).toBe(100);
-    expect(filters.price?.in).toEqual([10, 20]);
-    expect(filters.title?.contains).toBe('foo bar');
-    expect(filters.title?.in).toEqual(['a', 'b']);
-    const out = stringify(filters, schema);
-    // canonical order: price first (decl), then title
-    expect(out).toContain('price.gt=10');
-    expect(out).toContain('price.lte=100');
-    expect(out).toContain('price.in=10,20');
-    expect(out).toContain('title.contains=foo%20bar');
-    expect(out).toContain('title.in=a,b');
-  });
-
-  it('handles between and duplicate between diagnostic', () => {
-    const q = 'price.between=1,5&price.between=2,6';
-    const { filters, diagnostics } = parse(q, schema);
-    expect(filters.price?.between).toEqual([1, 5]);
-    expect(
-      diagnostics.some((d) => {
-        return d.kind === 'DuplicateBetween';
-      }),
-    ).toBe(true);
-  });
-
-  it('round-trips canonical ordering', () => {
-    const q = 'title.ew=bar&price.in=2,1&price.gt=3&title.sw=foo';
-    const { filters } = parse(q, schema);
-    const out = stringify(filters, schema);
-    // price declared before title so should start with price.
-    expect(out.startsWith('price.')).toBe(true);
-    // parsing the output again should yield equivalent filters
-    const again = parse(out, schema).filters;
-    expect(again).toEqual(filters);
-  });
-
-  it('produces diagnostics for invalid number and invalid between arity', () => {
-    const q = 'price.gt=xx&price.between=1,2,3&title.contains=x%ZZ';
-    const { diagnostics } = parse(q, schema);
-    expect(
-      diagnostics.find((d) => {
-        return d.kind === 'InvalidValue';
-      }),
-    ).toBeTruthy();
-    expect(
-      diagnostics.find((d) => {
-        return d.kind === 'InvalidArity';
-      }),
-    ).toBeTruthy();
-    expect(
-      diagnostics.find((d) => {
-        return d.kind === 'DecodeError';
-      }),
-    ).toBeTruthy();
-  });
-
-  it('merges multiple nin occurrences preserving order', () => {
-    const q = 'price.nin=1,2&price.nin=3&price.nin=4,5';
-    const { filters } = parse(q, schema);
-    expect(filters.price?.nin).toEqual([1, 2, 3, 4, 5]);
-    const s = stringify(filters, schema);
-    expect(s).toContain('price.nin=1,2,3,4,5');
-  });
-
-  it('supports implicit eq and explicit neq operators with last-write', () => {
-    const q = 'price=10&price=11&title=foo&title.neq=bar';
-    const { filters } = parse(q, schema);
-    expect(filters.price?.eq).toBe(11); // last write wins
-    expect(filters.title?.eq).toBe('foo');
-    expect(filters.title?.neq).toBe('bar');
-    const s = stringify(filters, schema);
-    expect(s).toContain('price=11');
-    expect(s).toMatch(/title=foo/);
-    expect(s).toMatch(/title\.neq=bar/);
-  });
-
-  it('supports sw / ew / contains textual operators', () => {
-    const q = 'title.sw=Hello&title.ew=World&title.contains=lo%20Wo';
-    const { filters } = parse(q, schema);
-    expect(filters.title?.sw).toBe('Hello');
-    expect(filters.title?.ew).toBe('World');
-    expect(filters.title?.contains).toBe('lo Wo');
-    const s = stringify(filters, schema);
-    expect(s).toContain('title.sw=Hello');
-    expect(s).toContain('title.ew=World');
-    expect(s).toContain('title.contains=lo%20Wo');
-  });
-});

package/src/__tests__/parse.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { defineSchema, numberField, stringField } from '../schema.js';
-import { parse } from '../parse.js';
-
-const schema = defineSchema({
-  title: stringField(),
-  price: numberField(),
-});
-
-describe('parse helpers', () => {
-  it('parses implicit equality and explicit operators into the same field object', () => {
-    const result = parse('?title=foo&title.contains=bar', schema);
-    expect(result.filters.title).toEqual({
-      eq: 'foo',
-      contains: 'bar',
-    });
-    expect(result.diagnostics).toEqual([]);
-  });
-
-  it('handles between operator arity and numeric validation', () => {
-    const ok = parse('price.between=1,3', schema);
-    expect(ok.filters.price?.between).toEqual([1, 3]);
-    expect(ok.diagnostics).toEqual([]);
-
-    const wrongArity = parse('price.between=1', schema);
-    expect(wrongArity.filters.price).toBeUndefined();
-    expect(wrongArity.diagnostics).toContainEqual(
-      expect.objectContaining({
-        kind: 'InvalidArity',
-        field: 'price',
-        operator: 'between',
-      }),
-    );
-
-    const invalidValue = parse('price.between=1,not-a-number', schema);
-    expect(invalidValue.filters.price).toBeUndefined();
-    expect(invalidValue.diagnostics).toContainEqual(
-      expect.objectContaining({
-        kind: 'InvalidValue',
-        field: 'price',
-        operator: 'between',
-      }),
-    );
-  });
-
-  it('records duplicate between declarations as diagnostics', () => {
-    const result = parse('price.between=1,3&price.between=2,4', schema);
-    expect(result.filters.price?.between).toEqual([1, 3]);
-    expect(result.diagnostics).toContainEqual(
-      expect.objectContaining({
-        kind: 'DuplicateBetween',
-        field: 'price',
-      }),
-    );
-  });
-
-  it('aggregates list operators and appends across segments', () => {
-    const list = parse('title.in=foo,bar%20baz&title.in=qux', schema);
-    expect(list.filters.title?.in).toEqual(['foo', 'bar baz', 'qux']);
-    expect(list.diagnostics).toEqual([]);
-
-    const numericList = parse('price.in=1,NaN,3', schema);
-    expect(numericList.filters.price?.in).toEqual([1, 3]);
-    expect(numericList.diagnostics).toContainEqual(
-      expect.objectContaining({
-        kind: 'InvalidValue',
-        field: 'price',
-        operator: 'in',
-      }),
-    );
-  });
-
-  it('decodes values and reports decode failures', () => {
-    const decoded = parse('title.contains=hello%20world', schema);
-    expect(decoded.filters.title?.contains).toBe('hello world');
-    expect(decoded.diagnostics).toEqual([]);
-
-    const failure = parse('title.eq=%', schema);
-    expect(failure.filters.title).toBeUndefined();
-    expect(failure.diagnostics).toContainEqual(
-      expect.objectContaining({
-        kind: 'DecodeError',
-        field: 'title',
-        operator: 'eq',
-      }),
-    );
-  });
-
-  it('validates scalar numeric operators and surfaces invalid values', () => {
-    const ok = parse('price.eq=42', schema);
-    expect(ok.filters.price?.eq).toBe(42);
-
-    const bad = parse('price.eq=', schema);
-    expect(bad.filters.price).toBeUndefined();
-    expect(bad.diagnostics).toContainEqual(
-      expect.objectContaining({
-        kind: 'InvalidValue',
-        field: 'price',
-        operator: 'eq',
-      }),
-    );
-  });
-
-  it('reports unknown fields and operators', () => {
-    const field = parse('unknown.eq=value', schema);
-    expect(field.filters.unknown as unknown).toBeUndefined();
-    expect(field.diagnostics).toContainEqual(
-      expect.objectContaining({
-        kind: 'UnknownField',
-        field: 'unknown',
-      }),
-    );
-
-    const operator = parse('title.between=foo,bar', schema);
-    expect(operator.filters.title).toBeUndefined();
-    expect(operator.diagnostics).toContainEqual(
-      expect.objectContaining({
-        kind: 'UnknownOperator',
-        field: 'title',
-        operator: 'between',
-      }),
-    );
-  });
-
-  it('returns empty result for blank input', () => {
-    expect(parse('', schema)).toEqual({ filters: {}, diagnostics: [] });
-    expect(parse('   ', schema)).toEqual({ filters: {}, diagnostics: [] });
-    expect(parse('?', schema)).toEqual({ filters: {}, diagnostics: [] });
-  });
-});

package/src/__tests__/remove-filter.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { defineSchema, numberField, stringField } from '../schema.js';
-import { parse } from '../parse.js';
-import { setFilter, removeFilter, isEmpty, mergeFilters } from '../mutate.js';
-
-const schema = defineSchema({
-  price: numberField(['gt', 'lte', 'in']),
-  title: stringField(['contains', 'in']),
-});
-
-describe('removeFilter & isEmpty', () => {
-  it('removeFilter(operator) removes only that operator keeping field if others remain', () => {
-    const base = parse('price.gt=10&price.lte=20', schema).filters;
-    const removed = removeFilter(base, 'price', 'gt');
-    expect(removed.price?.gt).toBeUndefined();
-    expect(removed.price?.lte).toBe(20);
-    // field object replaced (immutability) but root cloned
-    expect(removed).not.toBe(base);
-  });
-
-  it('removeFilter(field) removes entire field object when no operator specified', () => {
-    const base = parse('price.gt=10&title.contains=foo', schema).filters;
-    const withoutPrice = removeFilter(base, 'price');
-    expect(withoutPrice.price).toBeUndefined();
-    expect(withoutPrice.title?.contains).toBe('foo');
-  });
-
-  it('setFilter(undefined) removes operator and prunes empty field', () => {
-    let parsed = parse('price.gt=10', schema).filters;
-    parsed = setFilter(parsed, schema, 'price', 'gt', undefined);
-    expect(parsed.price).toBeUndefined();
-    expect(isEmpty(parsed)).toBe(true);
-  });
-
-  it('mergeFilters applies changes and preserves identity when patch is noop after removals', () => {
-    const a = parse('price.gt=10&price.lte=20', schema).filters;
-    const b = removeFilter(a, 'price', 'lte');
-    // patching with remaining price field should keep reference
-    const merged = mergeFilters(b, { price: b.price } as any);
-    expect(merged).toBe(b);
-    // adding new info changes reference
-    const merged2 = mergeFilters(b, { title: { contains: 'x' } } as any);
-    expect(merged2).not.toBe(b);
-    expect(merged2.title?.contains).toBe('x');
-  });
-});

package/src/__tests__/schema-edge.test.ts

@@ -1,51 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { defineSchema, numberField, stringField } from '../schema.js';
-import { parse } from '../parse.js';
-
-describe('schema & parse edge cases', () => {
-  it('defineSchema returns a frozen object', () => {
-    const schema = defineSchema({ price: numberField(['gt']) });
-    expect(Object.isFrozen(schema)).toBe(true);
-  });
-
-  it('restricted operator whitelist rejects others (UnknownOperator)', () => {
-    const schema = defineSchema({ price: numberField(['gt']) });
-    const { filters, diagnostics } = parse('price.gt=5&price.lte=10', schema);
-    expect(filters.price?.gt).toBe(5);
-    expect(
-      diagnostics.some((d) => {
-        return d.kind === 'UnknownOperator' && d.operator === 'lte';
-      }),
-    ).toBe(true);
-  });
-
-  it('invalid key shapes or unknown implicit fields produce UnknownField only for unknown names', () => {
-    const schema = defineSchema({ price: numberField(['gt']) });
-    const { filters, diagnostics } = parse('pricegt=5&price.=6&.gt=7', schema);
-    expect(filters).toEqual({});
-    // pricegt becomes implicit eq -> UnknownField; the malformed keys with trailing/leading dot are ignored
-    expect(
-      diagnostics.filter((d) => {
-        return d.kind === 'UnknownField';
-      }).length,
-    ).toBe(1);
-  });
-
-  it('list operator keeps only valid numeric items and reports diagnostics for invalid + empty ones', () => {
-    const schema = defineSchema({ price: numberField(['in']) });
-    const { filters, diagnostics } = parse('price.in=1,abc,2,', schema);
-    expect(filters.price?.in).toEqual([1, 2]);
-    expect(
-      diagnostics.filter((d) => {
-        return d.kind === 'InvalidValue' && d.operator === 'in';
-      }).length,
-    ).toBeGreaterThanOrEqual(2); // 'abc' and '' both invalid
-  });
-
-  it('empty search yields empty filters & no diagnostics', () => {
-    const schema = defineSchema({ title: stringField(['contains']) });
-    const { filters, diagnostics } = parse('', schema);
-    expect(filters).toEqual({});
-    expect(diagnostics).toEqual([]);
-  });
-});

package/src/__tests__/schema-infer.test-d.ts

@@ -1,24 +0,0 @@
-import { defineSchema, numberField, stringField } from '../schema.js';
-import type { InferFilters } from '../types.js';
-
-export const schema = defineSchema({
-  price: numberField(['gt', 'between']),
-  title: stringField(['contains', 'in']),
-});
-
-type F = InferFilters<typeof schema>;
-
-// valid usages
-const a: F = { price: { gt: 1 }, title: { contains: 'x' } };
-const b: F = { price: { between: [1, 2] as const } }; // ok
-
-const c: F = { price: { in: [1, 2] } };
-// @ts-expect-error wrong tuple arity
-const d: F = { price: { between: [1, 2, 3] } };
-// @ts-expect-error wrong type
-const e: F = { price: { gt: 'nope' } };
-// @ts-expect-error missing array for list operator
-const f: F = { title: { in: 'x' } };
-
-// force usage to avoid unused variable errors
-export const _examples = { a, b, c, d, e, f };

package/src/__tests__/schema.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { numberField, stringField, defineSchema } from '../schema.js';
-
-describe('schema helpers', () => {
-  it('numberField parses finite numbers and rejects invalid input', () => {
-    const descriptor = numberField();
-    expect(descriptor.kind).toBe('number');
-    expect(descriptor.operators).toContain('between');
-    expect(descriptor.parse('42')).toBe(42);
-    expect(descriptor.parse('')).toBeUndefined();
-    expect(descriptor.parse('NaN')).toBeUndefined();
-    expect(descriptor.serialize(13)).toBe('13');
-  });
-
-  it('stringField returns raw strings and serializes values', () => {
-    const descriptor = stringField(['eq', 'contains']);
-    expect(descriptor.kind).toBe('string');
-    expect(descriptor.operators).toEqual(['eq', 'contains']);
-    expect(descriptor.parse('hello')).toBe('hello');
-    expect(descriptor.serialize(100)).toBe('100');
-  });
-
-  it('defineSchema freezes the returned schema copy', () => {
-    const source = { title: stringField() };
-    const schema = defineSchema(source);
-    expect(schema).not.toBe(source);
-    expect(Object.isFrozen(schema)).toBe(true);
-    expect(schema.title).toBeDefined();
-  });
-});

package/src/__tests__/stability-and-diagnostics.test.ts

@@ -1,40 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { defineSchema, numberField, stringField } from '../schema.js';
-import { parse } from '../parse.js';
-import { setFilter, mergeFilters } from '../mutate.js';
-
-const schema = defineSchema({
-  price: numberField(),
-  title: stringField(),
-});
-
-describe('reference stability & combined diagnostics', () => {
-  it('setFilter preserves reference when setting identical value again', () => {
-    const empty = parse('', schema).filters;
-    const f1 = setFilter(empty, schema, 'price', 'gt', 10);
-    expect(f1).not.toBe(empty);
-    const f2 = setFilter(f1, schema, 'price', 'gt', 10);
-    expect(f2).toBe(f1); // identical value no change
-    const f3 = setFilter(f2, schema, 'price', 'lte', 20);
-    expect(f3).not.toBe(f2);
-    // mergeFilters with empty patch returns same reference
-    const m1 = mergeFilters(f3, {} as any); // patch brings nothing
-    expect(m1).toBe(f3);
-    // mergeFilters with identical field object also preserves root
-    const patchSame = { price: f3.price } as any;
-    const m2 = mergeFilters(f3, patchSame);
-    expect(m2).toBe(f3);
-  });
-
-  it('reports UnknownField and UnknownOperator in same parse plus other diagnostics', () => {
-    const q = 'unknown.gt=5&price.xyz=10&price.gte=abc';
-    const { diagnostics } = parse(q, schema);
-    // collect kinds
-    const kinds = diagnostics.map((d) => {
-      return d.kind;
-    });
-    expect(kinds).toContain('UnknownField');
-    expect(kinds).toContain('UnknownOperator');
-    expect(kinds).toContain('InvalidValue'); // abc invalid number
-  });
-});

package/src/__tests__/stringify.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { defineSchema, numberField, stringField } from '../schema.js';
-import { parse } from '../parse.js';
-import { stringify } from '../stringify.js';
-import type { InferFilters } from '../types.js';
-
-const schema = defineSchema({
-  title: stringField(['eq', 'contains', 'in']),
-  price: numberField(['eq', 'between', 'in', 'nin']),
-});
-
-describe('stringify helpers', () => {
-  it('omits dot for implicit equality and uses dotted keys for other operators', () => {
-    const { filters } = parse('title=hello&title.contains=world', schema);
-    const output = stringify(filters, schema);
-    const segments = output.split('&');
-    expect(segments).toContain('title=hello');
-    expect(segments).toContain('title.contains=world');
-  });
-
-  it('serializes operators in schema order including between and list variants', () => {
-    const { filters } = parse(
-      'title=hello&title.contains=world&price=1&price.between=1,4&price.in=2,3&price.nin=5,6',
-      schema,
-    );
-    const output = stringify(filters, schema);
-    expect(output.split('&')).toEqual([
-      'title=hello',
-      'title.contains=world',
-      'price=1',
-      'price.between=1,4',
-      'price.in=2,3',
-      'price.nin=5,6',
-    ]);
-  });
-
-  it('stringifies non primitive scalars before encoding', () => {
-    const customSchema = defineSchema({
-      meta: stringField(['eq']),
-    });
-    type CustomFilters = InferFilters<typeof customSchema>;
-    const filters: CustomFilters = {
-      meta: {
-        eq: { nested: true } as unknown,
-      },
-    };
-    const output = stringify(filters, customSchema);
-    expect(output).toBe(
-      `meta=${encodeURIComponent(JSON.stringify({ nested: true }))}`,
-    );
-  });
-
-  it('skips operators with undefined or empty values', () => {
-    type Filters = InferFilters<typeof schema>;
-    const filters: Filters = {
-      title: {
-        contains: 'value',
-      },
-      price: {} as Filters['price'],
-    };
-    const output = stringify(filters, schema);
-    expect(output).toBe('title.contains=value');
-  });
-});

package/src/errors.ts

@@ -1,75 +0,0 @@
-/**
- * Union of all diagnostic variants that can be produced while parsing a filter query string.
- */
-export type Diagnostic =
-  | UnknownFieldDiagnostic
-  | UnknownOperatorDiagnostic
-  | InvalidValueDiagnostic
-  | InvalidArityDiagnostic
-  | DuplicateBetweenDiagnostic
-  | DecodeErrorDiagnostic;
-
-/**
- * Common diagnostic shape.
- * Consumers should refine via the `kind` discriminant before reading additional fields.
- */
-export interface BaseDiagnostic {
-  readonly kind: string;
-  readonly field?: string;
-  readonly operator?: string;
-  readonly detail?: string;
-}
-
-/**
- * Raised when the query references a field that is not present in the schema definition.
- */
-export interface UnknownFieldDiagnostic extends BaseDiagnostic {
-  kind: 'UnknownField';
-  field: string;
-}
-/**
- * Raised when a field is known but an operator that is not whitelisted on the schema
- * is encountered.
- */
-export interface UnknownOperatorDiagnostic extends BaseDiagnostic {
-  kind: 'UnknownOperator';
-  field: string;
-  operator: string;
-}
-/**
- * Signals that a value could not be parsed according to the field descriptor
- * (e.g. malformed number).
- */
-export interface InvalidValueDiagnostic extends BaseDiagnostic {
-  kind: 'InvalidValue';
-  field: string;
-  operator: string;
-  detail?: string;
-}
-/**
- * Emitted when an operator receives an unexpected number of values
- * (e.g. `between` without exactly two items).
- */
-export interface InvalidArityDiagnostic extends BaseDiagnostic {
-  kind: 'InvalidArity';
-  field: string;
-  operator: string;
-  detail: string; // expected arity info
-}
-/**
- * Indicates that multiple `between` declarations were encountered for the same field;
- * only the first is kept.
- */
-export interface DuplicateBetweenDiagnostic extends BaseDiagnostic {
-  kind: 'DuplicateBetween';
-  field: string;
-}
-/**
- * Raised when a value cannot be decoded from the URL query string (invalid percent-encoding).
- */
-export interface DecodeErrorDiagnostic extends BaseDiagnostic {
-  kind: 'DecodeError';
-  field: string;
-  operator: string;
-  detail: string;
-}