@proteos/sdk 0.18.1

package/src/meta/apps.ts

@@ -0,0 +1,107 @@
+import type { ProteosClient } from '../client.js'
+import { PageIterator } from '../iterator.js'
+import type { ListResult } from '../types/common.js'
+import type { App, CreateAppRequest, ListAppsOptions, UpdateAppRequest } from './types.js'
+
+const APPS_BASE_PATH = '/meta/v1/apps'
+
+/**
+ * Service for managing apps.
+ * Apps group menu configurations and other org-scoped metadata under a
+ * stable slug. Slugs are unique per org.
+ */
+export interface AppService {
+  /**
+   * Lists apps with optional filtering.
+   *
+   * @param options - Filter and pagination options
+   * @returns Async iterator over apps
+   */
+  list(options?: ListAppsOptions): PageIterator<App, ListAppsOptions>
+
+  /**
+   * Fetches a single page of apps.
+   */
+  listPage(options?: ListAppsOptions): Promise<ListResult<App>>
+
+  /**
+   * Gets a single app by slug.
+   *
+   * @param slug - App slug (unique within the caller's org)
+   * @returns The app
+   * @throws {ProteosError} If app not found (404)
+   */
+  get(slug: string): Promise<App>
+
+  /**
+   * Creates a new app.
+   *
+   * @param request - App creation request
+   * @returns The created app
+   * @throws {ProteosError} If validation fails (400) or conflict (409)
+   */
+  create(request: CreateAppRequest): Promise<App>
+
+  /**
+   * Creates or updates an app idempotently by slug. The URL slug wins on
+   * mismatch with the body's slug field (`PUT /meta/v1/apps/:slug`).
+   *
+   * @param slug - App slug
+   * @param request - Full app body
+   * @returns The created or updated app
+   */
+  upsert(slug: string, request: CreateAppRequest): Promise<App>
+
+  /**
+   * Updates an existing app.
+   *
+   * @param slug - App slug
+   * @param request - Fields to update
+   * @returns The updated app
+   * @throws {ProteosError} If app not found (404) or validation fails (400)
+   */
+  update(slug: string, request: UpdateAppRequest): Promise<App>
+
+  /**
+   * Deletes an app.
+   *
+   * @param slug - App slug
+   * @throws {ProteosError} If app not found (404)
+   */
+  delete(slug: string): Promise<void>
+}
+
+/**
+ * Implementation of AppService.
+ */
+export class AppServiceImpl implements AppService {
+  constructor(private readonly client: ProteosClient) {}
+
+  list(options: ListAppsOptions = {}): PageIterator<App, ListAppsOptions> {
+    return new PageIterator((opts) => this.listPage(opts), options)
+  }
+
+  async listPage(options: ListAppsOptions = {}): Promise<ListResult<App>> {
+    return this.client.requestWithQuery<ListResult<App>>('GET', APPS_BASE_PATH, options)
+  }
+
+  async get(slug: string): Promise<App> {
+    return this.client.request<App>('GET', `${APPS_BASE_PATH}/${slug}`)
+  }
+
+  async create(request: CreateAppRequest): Promise<App> {
+    return this.client.request<App>('POST', APPS_BASE_PATH, request)
+  }
+
+  async upsert(slug: string, request: CreateAppRequest): Promise<App> {
+    return this.client.request<App>('PUT', `${APPS_BASE_PATH}/${slug}`, { ...request, slug })
+  }
+
+  async update(slug: string, request: UpdateAppRequest): Promise<App> {
+    return this.client.request<App>('PATCH', `${APPS_BASE_PATH}/${slug}`, request)
+  }
+
+  async delete(slug: string): Promise<void> {
+    await this.client.request<void>('DELETE', `${APPS_BASE_PATH}/${slug}`)
+  }
+}

package/src/meta/components.ts

@@ -0,0 +1,124 @@
+import type { ProteosClient } from '../client.js'
+import { PageIterator } from '../iterator.js'
+import type { ListResult } from '../types/common.js'
+import type {
+  Component,
+  CreateComponentRequest,
+  ListComponentsOptions,
+  UpdateComponentRequest,
+} from './types.js'
+
+const COMPONENTS_BASE_PATH = '/meta/v1/components'
+
+/**
+ * Service for managing UI component definitions.
+ * Components define reusable UI elements in the system.
+ */
+export interface ComponentService {
+  /**
+   * Lists components with optional filtering.
+   *
+   * @param options - Filter and pagination options
+   * @returns Async iterator over components
+   */
+  list(options?: ListComponentsOptions): PageIterator<Component, ListComponentsOptions>
+
+  /**
+   * Fetches a single page of components.
+   */
+  listPage(options?: ListComponentsOptions): Promise<ListResult<Component>>
+
+  /**
+   * Gets a single component by ID.
+   *
+   * @param id - Component ID
+   * @returns The component
+   * @throws {ProteosError} If component not found (404)
+   */
+  get(id: string): Promise<Component>
+
+  /**
+   * Creates a new component.
+   *
+   * @param request - Component creation request
+   * @returns The created component
+   * @throws {ProteosError} If validation fails (400) or conflict (409)
+   */
+  create(request: CreateComponentRequest): Promise<Component>
+
+  /**
+   * Creates or updates a component (upsert operation).
+   * If a component with the same slug exists, it is updated; otherwise, a new one is created.
+   *
+   * @param request - Component creation request
+   * @returns The created or updated component
+   */
+  upsert(request: CreateComponentRequest): Promise<Component>
+
+  /**
+   * Updates an existing component.
+   *
+   * @param id - Component ID
+   * @param request - Fields to update
+   * @returns The updated component
+   * @throws {ProteosError} If component not found (404) or validation fails (400)
+   */
+  update(id: string, request: UpdateComponentRequest): Promise<Component>
+
+  /**
+   * Deletes a component.
+   *
+   * @param id - Component ID
+   * @throws {ProteosError} If component not found (404)
+   */
+  delete(id: string): Promise<void>
+
+  /**
+   * Returns the URL the component runtime imports to load a component's
+   * compiled ESM bundle (`GET /meta/v1/components/:slug/bundle`). The path is
+   * gateway-prefixed and relative; prepend the API origin to fetch it.
+   *
+   * @param slug - Component slug
+   * @returns The relative bundle URL
+   */
+  bundleUrl(slug: string): string
+}
+
+/**
+ * Implementation of ComponentService.
+ */
+export class ComponentServiceImpl implements ComponentService {
+  constructor(private readonly client: ProteosClient) {}
+
+  list(options: ListComponentsOptions = {}): PageIterator<Component, ListComponentsOptions> {
+    return new PageIterator((opts) => this.listPage(opts), options)
+  }
+
+  async listPage(options: ListComponentsOptions = {}): Promise<ListResult<Component>> {
+    return this.client.requestWithQuery<ListResult<Component>>('GET', COMPONENTS_BASE_PATH, options)
+  }
+
+  async get(id: string): Promise<Component> {
+    return this.client.request<Component>('GET', `${COMPONENTS_BASE_PATH}/${id}`)
+  }
+
+  async create(request: CreateComponentRequest): Promise<Component> {
+    return this.client.request<Component>('POST', COMPONENTS_BASE_PATH, request)
+  }
+
+  async upsert(request: CreateComponentRequest): Promise<Component> {
+    return this.client.request<Component>('POST', `${COMPONENTS_BASE_PATH}/upsert`, request)
+  }
+
+  async update(id: string, request: UpdateComponentRequest): Promise<Component> {
+    return this.client.request<Component>('PATCH', `${COMPONENTS_BASE_PATH}/${id}`, request)
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.client.request<void>('DELETE', `${COMPONENTS_BASE_PATH}/${id}`)
+  }
+
+  bundleUrl(slug: string): string {
+    return `${COMPONENTS_BASE_PATH}/${slug}/bundle`
+  }
+}

package/src/meta/currency/index.ts

@@ -0,0 +1,202 @@
+import type { CurrencyValue } from '../types.js'
+
+/**
+ * Currency + locale-number helpers backed entirely by the runtime's built-in
+ * `Intl` data — no bundled ISO-4217 table, no codegen. The platform validates
+ * codes on the backend (golang.org/x/text/currency); this module sources the
+ * selectable list and renders codes/symbols/amounts for the UI.
+ *
+ * Amounts are canonical decimal STRINGS (`^-?\d+(\.\d+)?$`) end-to-end; every
+ * formatter here operates on the string and never round-trips through a JS
+ * number, so precision and trailing zeros are preserved.
+ */
+
+let cachedCodes: string[] | null = null
+
+/**
+ * All currency codes the runtime knows, sorted and memoized. Sourced from
+ * `Intl.supportedValuesOf` (ES2022). When an attribute's
+ * `allowed_currency_codes` is unset, this is the full selectable set.
+ */
+export function allCurrencyCodes(): string[] {
+  if (cachedCodes) return cachedCodes
+  const supported =
+    typeof Intl !== 'undefined' && 'supportedValuesOf' in Intl
+      ? (Intl as unknown as { supportedValuesOf(key: 'currency'): string[] }).supportedValuesOf(
+          'currency',
+        )
+      : []
+  cachedCodes = [...supported].sort()
+  return cachedCodes
+}
+
+/**
+ * Localized display name for a currency code (e.g. `"US Dollar"`), via
+ * `Intl.DisplayNames`. Falls back to the code itself when unavailable.
+ */
+export function currencyLabel(code: string, locale?: string): string {
+  try {
+    const names = new Intl.DisplayNames(locale ? [locale] : undefined, { type: 'currency' })
+    return names.of(code) ?? code
+  } catch {
+    return code
+  }
+}
+
+/**
+ * The narrow symbol for a currency code (e.g. `"$"`, `"€"`, `"¥"`), via
+ * `Intl.NumberFormat`'s `narrowSymbol` so it's the bare glyph rather than a
+ * disambiguated form like `"US$"`. Falls back to the code itself.
+ */
+export function currencySymbol(code: string, locale?: string): string {
+  try {
+    const parts = new Intl.NumberFormat(locale, {
+      style: 'currency',
+      currency: code,
+      currencyDisplay: 'narrowSymbol',
+    }).formatToParts(0)
+    return parts.find((part) => part.type === 'currency')?.value ?? code
+  } catch {
+    return code
+  }
+}
+
+export type CurrencySymbolSide = 'prefix' | 'suffix'
+
+/**
+ * Currencies whose symbol conventionally TRAILS the amount (with a space) —
+ * e.g. `"1.234,56 €"`, `"100 kr"`, `"100 zł"`. Everything else prefixes the
+ * symbol with no space — e.g. `"$1,234.56"`, `"¥100"`.
+ *
+ * This is deliberately currency-driven, NOT locale-driven: `Intl` would place
+ * the symbol per the *viewer's* locale, but we want a dollar to always read
+ * `"$100"` and a euro `"100 €"` regardless of who's looking. Extend this set as
+ * needed — it's the single source of truth for symbol placement.
+ */
+const SUFFIX_SYMBOL_CURRENCIES = new Set<string>([
+  'EUR',
+  'PLN',
+  'CZK',
+  'HUF',
+  'RON',
+  'BGN',
+  'HRK',
+  'SEK',
+  'NOK',
+  'DKK',
+  'ISK',
+  'RSD',
+  'RUB',
+  'UAH',
+  'GEL',
+  'MKD',
+  'ALL',
+  'AMD',
+  'AZN',
+  'VND',
+])
+
+/**
+ * Which side of the amount a currency's symbol sits on. The well-defined rule:
+ * a currency in {@link SUFFIX_SYMBOL_CURRENCIES} suffixes (`"100 €"`), every
+ * other currency prefixes (`"$100"`). Pure and deterministic.
+ */
+export function currencySymbolSide(code: string): CurrencySymbolSide {
+  return SUFFIX_SYMBOL_CURRENCIES.has(code) ? 'suffix' : 'prefix'
+}
+
+const separatorCache = new Map<string, { group: string; decimal: string }>()
+
+/**
+ * The grouping (thousands) and decimal separators for a locale — e.g. `de-DE`
+ * → `{ group: ".", decimal: "," }`, `en-US` → `{ group: ",", decimal: "." }`.
+ * Derived from `Intl.NumberFormat.formatToParts` and memoized per locale.
+ */
+export function localeNumberSeparators(locale?: string): { group: string; decimal: string } {
+  const key = locale ?? '__default__'
+  const cached = separatorCache.get(key)
+  if (cached) return cached
+  let group = ','
+  let decimal = '.'
+  try {
+    const parts = new Intl.NumberFormat(locale).formatToParts(11111.1)
+    group = parts.find((part) => part.type === 'group')?.value ?? group
+    decimal = parts.find((part) => part.type === 'decimal')?.value ?? decimal
+  } catch {
+    /* keep the en-US-ish defaults */
+  }
+  const result = { group, decimal }
+  separatorCache.set(key, result)
+  return result
+}
+
+const DECIMAL_RE = /^-?\d+(\.\d+)?$/
+
+function groupDigits(intDigits: string, groupSeparator: string): string {
+  return intDigits.replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator)
+}
+
+/**
+ * Render a canonical decimal string in a locale's notation — e.g. `"1234.56"`
+ * → `"1.234,56"` (de) / `"1,234.56"` (en). `grouped: false` omits the thousands
+ * separator (useful while a field is being edited). Precision-preserving: it
+ * splits the string and substitutes separators, never `Number()`.
+ */
+export function formatAmount(
+  canonical: string,
+  locale?: string,
+  options?: { grouped?: boolean },
+): string {
+  if (canonical === '') return ''
+  if (!DECIMAL_RE.test(canonical)) return canonical
+  const grouped = options?.grouped !== false
+  const { group, decimal } = localeNumberSeparators(locale)
+  const negative = canonical.startsWith('-')
+  const body = negative ? canonical.slice(1) : canonical
+  const dotIndex = body.indexOf('.')
+  const intPart = dotIndex === -1 ? body : body.slice(0, dotIndex)
+  const fracPart = dotIndex === -1 ? undefined : body.slice(dotIndex + 1)
+  const intOut = grouped ? groupDigits(intPart, group) : intPart
+  const out = fracPart !== undefined ? `${intOut}${decimal}${fracPart}` : intOut
+  return negative ? `-${out}` : out
+}
+
+/**
+ * Parse locale-formatted user input back to a canonical decimal string — e.g.
+ * `"1.234,56"` (de) → `"1234.56"`. Strips the locale group separator,
+ * normalizes the locale decimal to `.`, and drops stray characters (symbols,
+ * spaces). Returns `""` for empty/invalid input.
+ */
+export function parseAmount(input: string, locale?: string): string {
+  const trimmed = input.trim()
+  if (trimmed === '') return ''
+  const { group, decimal } = localeNumberSeparators(locale)
+  const negative = trimmed.startsWith('-')
+  let normalized = trimmed.split(group).join('') // strip thousands separators
+  normalized = normalized.split(decimal).join('.') // locale decimal → '.'
+  normalized = normalized.replace(/[^\d.]/g, '') // drop symbols, spaces, stray chars
+  const firstDot = normalized.indexOf('.')
+  if (firstDot !== -1) {
+    // Collapse to a single decimal point.
+    normalized =
+      normalized.slice(0, firstDot + 1) + normalized.slice(firstDot + 1).replace(/\./g, '')
+  }
+  if (normalized === '' || normalized === '.') return ''
+  return negative ? `-${normalized}` : normalized
+}
+
+/**
+ * Format a currency value for read-only display: the symbol placed by currency
+ * convention ({@link currencySymbolSide}) around the amount grouped per the
+ * viewer's locale ({@link formatAmount}). E.g. USD → `"$1,234.56"`, EUR (de
+ * viewer) → `"1.234,56 €"`. Returns a plain `"amount code"` string when the
+ * value can't be formatted.
+ */
+export function formatMoney(value: CurrencyValue, locale?: string): string {
+  const { amount, currency_code: code } = value
+  if (!amount || !code) return [amount, code].filter(Boolean).join(' ')
+  if (!DECIMAL_RE.test(amount)) return `${amount} ${code}`
+  const number = formatAmount(amount, locale, { grouped: true })
+  const symbol = currencySymbol(code, locale)
+  return currencySymbolSide(code) === 'suffix' ? `${number} ${symbol}` : `${symbol}${number}`
+}

package/src/meta/entities.ts

@@ -0,0 +1,193 @@
+import type { ProteosClient } from '../client.js'
+import { PageIterator } from '../iterator.js'
+import type { ListResult } from '../types/common.js'
+import type {
+  CreateEntityRequest,
+  Entity,
+  EntityWithSchema,
+  ListEntitiesOptions,
+  UpdateEntityRequest,
+} from './types.js'
+
+const ENTITIES_BASE_PATH = '/meta/v1/entities'
+
+/**
+ * Service for managing entity definitions.
+ * Entities define the structure of business objects in the system.
+ */
+export interface EntityService {
+  /**
+   * Lists entities with optional filtering.
+   * Returns an async iterator that automatically handles pagination.
+   *
+   * @param options - Filter and pagination options
+   * @returns Async iterator over entities
+   *
+   * @example
+   * ```ts
+   * // Iterate over all entities
+   * for await (const entity of service.list()) {
+   *   console.log(entity.slug);
+   * }
+   *
+   * // With filtering
+   * for await (const entity of service.list({ module_slug: 'my-module' })) {
+   *   console.log(entity.name);
+   * }
+   * ```
+   */
+  list(options?: ListEntitiesOptions): PageIterator<Entity, ListEntitiesOptions>
+
+  /**
+   * Fetches a single page of entities.
+   *
+   * @param options - Filter and pagination options (including `page`)
+   * @returns A single page of entities with pagination metadata
+   */
+  listPage(options?: ListEntitiesOptions): Promise<ListResult<Entity>>
+
+  /**
+   * Lists entities including their JSON Schema representation.
+   *
+   * @param options - Filter and pagination options
+   * @returns Async iterator over entities with schema
+   */
+  listWithSchema(options?: ListEntitiesOptions): PageIterator<EntityWithSchema, ListEntitiesOptions>
+
+  /**
+   * Fetches a single page of entities with their JSON Schema representation.
+   * Useful for integrating with paginated UI frameworks (e.g. React Query's
+   * useInfiniteQuery) that need direct access to a page's meta and data.
+   *
+   * @param options - Filter and pagination options
+   * @returns A single page of entities with schema
+   */
+  listPageWithSchema(options?: ListEntitiesOptions): Promise<ListResult<EntityWithSchema>>
+
+  /**
+   * Gets a single entity by slug.
+   *
+   * @param slug - Entity slug
+   * @returns The entity
+   * @throws {ProteosError} If entity not found (404)
+   */
+  get(slug: string): Promise<Entity>
+
+  /**
+   * Gets an entity with its JSON Schema representation.
+   *
+   * @param slug - Entity slug
+   * @returns The entity with schema
+   * @throws {ProteosError} If entity not found (404)
+   */
+  getWithSchema(slug: string): Promise<EntityWithSchema>
+
+  /**
+   * Creates a new entity.
+   *
+   * @param request - Entity creation request
+   * @returns The created entity
+   * @throws {ProteosError} If validation fails (400) or conflict (409)
+   *
+   * @example
+   * ```ts
+   * const entity = await service.create({
+   *   slug: 'customers',
+   *   name: 'Customer',
+   *   description: 'Customer records',
+   *   is_remote: false,
+   *   module_slug: 'crm',
+   *   attributes: [
+   *     { name: 'id', type: 'string', meta: { format: 'uuid' }, label: 'ID', is_required: true, is_unique: true },
+   *     { name: 'name', type: 'string', label: 'Name', is_required: true, is_unique: false },
+   *   ],
+   * });
+   * ```
+   */
+  create(request: CreateEntityRequest): Promise<Entity>
+
+  /**
+   * Creates or updates an entity idempotently by slug. The URL slug wins on
+   * mismatch with the body's slug field. Backs the CLI/admin idempotent deploy
+   * path (`PUT /meta/v1/entities/:slug`).
+   *
+   * @param slug - Entity slug
+   * @param request - Full entity body
+   * @returns The created or updated entity
+   */
+  upsert(slug: string, request: CreateEntityRequest): Promise<Entity>
+
+  /**
+   * Updates an existing entity.
+   *
+   * @param slug - Entity slug
+   * @param request - Fields to update
+   * @returns The updated entity
+   * @throws {ProteosError} If entity not found (404) or validation fails (400)
+   */
+  update(slug: string, request: UpdateEntityRequest): Promise<Entity>
+
+  /**
+   * Deletes an entity.
+   *
+   * @param slug - Entity slug
+   * @throws {ProteosError} If entity not found (404)
+   */
+  delete(slug: string): Promise<void>
+}
+
+/**
+ * Implementation of EntityService.
+ */
+export class EntityServiceImpl implements EntityService {
+  constructor(private readonly client: ProteosClient) {}
+
+  list(options: ListEntitiesOptions = {}): PageIterator<Entity, ListEntitiesOptions> {
+    return new PageIterator((opts) => this.listPage(opts), options)
+  }
+
+  async listPage(options: ListEntitiesOptions = {}): Promise<ListResult<Entity>> {
+    return this.client.requestWithQuery<ListResult<Entity>>('GET', ENTITIES_BASE_PATH, options)
+  }
+
+  listWithSchema(
+    options: ListEntitiesOptions = {},
+  ): PageIterator<EntityWithSchema, ListEntitiesOptions> {
+    return new PageIterator((opts) => this.listPageWithSchema(opts), options)
+  }
+
+  async listPageWithSchema(
+    options: ListEntitiesOptions = {},
+  ): Promise<ListResult<EntityWithSchema>> {
+    return this.client.requestWithQuery<ListResult<EntityWithSchema>>('GET', ENTITIES_BASE_PATH, {
+      ...options,
+      with_schema: true,
+    })
+  }
+
+  async get(slug: string): Promise<Entity> {
+    return this.client.request<Entity>('GET', `${ENTITIES_BASE_PATH}/${slug}`)
+  }
+
+  async getWithSchema(slug: string): Promise<EntityWithSchema> {
+    return this.client.requestWithQuery<EntityWithSchema>('GET', `${ENTITIES_BASE_PATH}/${slug}`, {
+      with_schema: true,
+    })
+  }
+
+  async create(request: CreateEntityRequest): Promise<Entity> {
+    return this.client.request<Entity>('POST', ENTITIES_BASE_PATH, request)
+  }
+
+  async upsert(slug: string, request: CreateEntityRequest): Promise<Entity> {
+    return this.client.request<Entity>('PUT', `${ENTITIES_BASE_PATH}/${slug}`, { ...request, slug })
+  }
+
+  async update(slug: string, request: UpdateEntityRequest): Promise<Entity> {
+    return this.client.request<Entity>('PATCH', `${ENTITIES_BASE_PATH}/${slug}`, request)
+  }
+
+  async delete(slug: string): Promise<void> {
+    await this.client.request<void>('DELETE', `${ENTITIES_BASE_PATH}/${slug}`)
+  }
+}

package/src/meta/filters.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod'
+
+/**
+ * Logical operator used to combine filter elements/groups.
+ */
+export type LogicalOperator = 'and' | 'or'
+
+/**
+ * Comparison operator for a single filter element. Mirrors
+ * `ComparisonOperator` in `packages/go/model/comparison-operator.go`.
+ */
+export type ComparisonOperator =
+  | 'eq'
+  | 'gt'
+  | 'lt'
+  | 'gte'
+  | 'lte'
+  | 'ne'
+  | 'in'
+  | 'not_in'
+  | 'contains'
+  | 'starts_with'
+  | 'ends_with'
+  | 'empty'
+  | 'not_empty'
+
+/**
+ * Single filter element (atomic predicate).
+ *
+ * `value` is a string at the wire level — pipe-joined for `in` / `not_in`,
+ * ignored for `empty` / `not_empty`. This matches the data-service URL query
+ * convention so the same predicate flows through both the GET-with-filters
+ * path and the layout `visible_when` JSONB path without a translation layer.
+ */
+export interface FilterElement {
+  field: string
+  value: string
+  operator: ComparisonOperator
+}
+
+/**
+ * Filter group with logical operator. Groups can be nested.
+ */
+export interface FilterGroup {
+  logical_operator: LogicalOperator
+  elements?: FilterElement[]
+  groups?: FilterGroup[]
+}
+
+export const FilterElementSchema = z.object({
+  field: z.string(),
+  value: z.string(),
+  operator: z.enum([
+    'eq',
+    'gt',
+    'lt',
+    'gte',
+    'lte',
+    'ne',
+    'in',
+    'not_in',
+    'contains',
+    'starts_with',
+    'ends_with',
+    'empty',
+    'not_empty',
+  ]),
+})
+
+export const FilterGroupSchema: z.ZodType<FilterGroup> = z.lazy(() =>
+  z.object({
+    logical_operator: z.enum(['and', 'or']),
+    elements: z.array(FilterElementSchema).optional(),
+    groups: z.array(FilterGroupSchema).optional(),
+  }),
+) as unknown as z.ZodType<FilterGroup>