@orthacms/content-server 0.4.3 → 0.5.0

package/dist/lib/entries/controllers/bulk-entries.controller.d.ts

@@ -1,26 +0,0 @@
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-import { EntryWriterService } from '../services/entry-writer.service';
-import { BulkIdsDto } from '../dto/bulk-ids.dto';
-import type { BulkActionResult, BulkPublishPreview, BulkPublishResult } from '../types/bulk-publish';
-/**
- * Bulk entry actions over a set of `{ ids }`. **Registered before the
- * single-item controllers** (see `content.module.ts`): the literal `bulk`
- * segment sits in the same slot as those controllers' `:id`, so it must match
- * first — otherwise `/bulk/publish` would resolve as `:id='bulk'` (and trip the
- * single-item `ParseUUIDPipe`). `WorkspaceGuard` scopes every action to a
- * workspace the caller belongs to. Per-route permissions: publish/unpublish need
- * `content:publish`, delete/restore need `content:delete`.
- */
-export declare class BulkEntriesController {
-    private readonly registry;
-    private readonly writer;
-    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
-    /** Dry run: validate each id and report a per-entry verdict. Writes nothing. */
-    previewPublish(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkPublishPreview>;
-    publish(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkPublishResult>;
-    unpublish(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkActionResult>;
-    remove(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkActionResult>;
-    restore(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkActionResult>;
-    purge(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkActionResult>;
-}
-//# sourceMappingURL=bulk-entries.controller.d.ts.map

package/dist/lib/entries/controllers/bulk-entries.controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bulk-entries.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/bulk-entries.controller.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EACR,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACpB,MAAM,uBAAuB,CAAC;AAG/B;;;;;;;;GAQG;AACH,qBAEa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAG/C,gFAAgF;IAIhF,cAAc,CACS,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,kBAAkB,CAAC;IAQ9B,OAAO,CACgB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,iBAAiB,CAAC;IAQ7B,SAAS,CACc,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;IAQ5B,MAAM,CACiB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;IAQ5B,OAAO,CACgB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;IAQ5B,KAAK,CACkB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;CAI/B"}

package/dist/lib/entries/controllers/create-entry.controller.d.ts

@@ -1,20 +0,0 @@
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-import { EntryWriterService } from '../services/entry-writer.service';
-import { SaveEntryDto } from '../dto/save-entry.dto';
-import type { EntryRecord } from '../types/entry-list-view';
-/**
- * `POST /api/content/:typeName` — create a draft entry from a validated values
- * bag. The `:typeName` resolves via the registry (404 if unknown); the body is
- * validated against the type's field specs (422 with the issue list on failure).
- * `OriginGuard` defends this state-changing POST (CSRF); `WorkspaceGuard` scopes
- * it to a workspace the caller belongs to; `content:create` gates it. The
- * synchronous CSRF + permission guards run before `WorkspaceGuard` so a rejected
- * request never incurs its membership DB probe.
- */
-export declare class CreateEntryController {
-    private readonly registry;
-    private readonly writer;
-    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
-    create(typeName: string, body: SaveEntryDto, workspaceId: string): Promise<EntryRecord>;
-}
-//# sourceMappingURL=create-entry.controller.d.ts.map

package/dist/lib/entries/controllers/create-entry.controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/create-entry.controller.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;;;GAQG;AACH,qBAGa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,MAAM,CACiB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,YAAY,EACN,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;CAW1B"}

package/dist/lib/entries/controllers/delete-entry.controller.d.ts

@@ -1,24 +0,0 @@
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-import { EntryWriterService } from '../services/entry-writer.service';
-import type { EntryRecord } from '../types/entry-list-view';
-/**
- * Single-entry removal lifecycle, all gated on `content:delete`:
- * - `DELETE /api/content/:typeName/:id` — soft delete (stamp `deleted_at`) for a
- *   paranoid type, hard delete otherwise; 204.
- * - `POST   /api/content/:typeName/:id/restore` — clear the tombstone (paranoid
- *   only); returns the restored record.
- * - `DELETE /api/content/:typeName/:id/permanent` — permanently remove a
- *   tombstoned row (paranoid only); 204.
- *
- * `OriginGuard` defends these state-changing writes; `WorkspaceGuard` scopes them
- * to a workspace the caller belongs to.
- */
-export declare class DeleteEntryController {
-    private readonly registry;
-    private readonly writer;
-    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
-    remove(typeName: string, id: string, workspaceId: string): Promise<void>;
-    restore(typeName: string, id: string, workspaceId: string): Promise<EntryRecord>;
-    purge(typeName: string, id: string, workspaceId: string): Promise<void>;
-}
-//# sourceMappingURL=delete-entry.controller.d.ts.map

package/dist/lib/entries/controllers/delete-entry.controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delete-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/delete-entry.controller.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;;;;;;GAWG;AACH,qBAGa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAKzC,MAAM,CACW,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,IAAI,CAAC;IAMhB,OAAO,CACgB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;IAOjB,KAAK,CACY,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,IAAI,CAAC;CAInB"}

package/dist/lib/entries/controllers/get-entry.controller.d.ts

@@ -1,34 +0,0 @@
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-import { EntryWriterService } from '../services/entry-writer.service';
-import type { EntryRecord, EntryRelationsView, RelationFieldView } from '../types/entry-list-view';
-/**
- * `GET /api/content/:typeName/:id` — one live entry by id (404 if unknown or
- * soft-deleted), so the editor can open an entry by deep link without relying on
- * the records-list cache. `WorkspaceGuard` scopes it to a workspace the caller
- * belongs to; gated on `content:read`.
- */
-export declare class GetEntryController {
-    private readonly registry;
-    private readonly writer;
-    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
-    getOne(typeName: string, id: string, workspaceId: string): Promise<EntryRecord>;
-    /**
-     * `GET /api/content/:typeName/:id/relations` — one entry's relation links,
-     * keyed by field name. Every relation field (owning single/many **and**
-     * inverse back-references) resolved to display-ready refs (id + title) in a
-     * bounded set of queries, so the editor can render assigned relations by
-     * title and seed the form value with their ids without a round-trip per
-     * link. 404 when the entry is missing or soft-deleted in this workspace.
-     */
-    getRelations(typeName: string, id: string, workspaceId: string): Promise<EntryRelationsView>;
-    /**
-     * `GET /api/content/:typeName/:id/relations/:field` — one page of a single
-     * relation field's links (`{ items, total }`), ordered by position. Drives
-     * the editor's infinite-scroll of a many/inverse relation, so a field with
-     * thousands of links is paged, never loaded whole. `?page=&pageSize=`
-     * (1-based; clamped). 400 if `field` isn't a relation; 404 if the entry is
-     * missing. `content:read`.
-     */
-    getRelationField(typeName: string, id: string, field: string, workspaceId: string, page?: string, pageSize?: string): Promise<RelationFieldView>;
-}
-//# sourceMappingURL=get-entry.controller.d.ts.map

package/dist/lib/entries/controllers/get-entry.controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/get-entry.controller.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EACR,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACpB,MAAM,0BAA0B,CAAC;AAIlC;;;;;GAKG;AACH,qBAGa,kBAAkB;IAGvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,MAAM,CACiB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;IAKvB;;;;;;;OAOG;IAEG,YAAY,CACK,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,kBAAkB,CAAC;IAO9B;;;;;;;OAOG;IAEH,gBAAgB,CACO,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,EACT,WAAW,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,MAAM,EACT,QAAQ,CAAC,EAAE,MAAM,GACrC,OAAO,CAAC,iBAAiB,CAAC;CAWhC"}

package/dist/lib/entries/controllers/list-entries.controller.d.ts

@@ -1,20 +0,0 @@
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-import { EntriesService } from '../services/entries.service';
-import { ListEntriesQueryDto } from '../dto/list-entries-query.dto';
-import type { EntryListView } from '../types/entry-list-view';
-/**
- * `GET /api/content/:typeName` — one page of a collection's entries, filtered/
- * searched/sorted via query params (`?search=`, `?filter=`, `?sort=`, `?page=`,
- * `?pageSize=`). The `:typeName` is resolved from the registry (404 if unknown),
- * so this single route serves every collection; the service runs the generic SQL
- * pipeline against the type's generated table. Authentication is enforced by the
- * app-wide AuthGuard; `WorkspaceGuard` scopes the request to a workspace the
- * caller belongs to; read access is gated on `content:read`.
- */
-export declare class ListEntriesController {
-    private readonly registry;
-    private readonly entries;
-    constructor(registry: ContentTypeRegistry, entries: EntriesService);
-    list(typeName: string, query: ListEntriesQueryDto, workspaceId: string): Promise<EntryListView>;
-}
-//# sourceMappingURL=list-entries.controller.d.ts.map

package/dist/lib/entries/controllers/list-entries.controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list-entries.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/list-entries.controller.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D;;;;;;;;GAQG;AACH,qBAGa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,cAAc;IAI5C,IAAI,CACmB,QAAQ,EAAE,MAAM,EAC1B,KAAK,EAAE,mBAAmB,EACf,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,aAAa,CAAC;CAO5B"}

package/dist/lib/entries/controllers/publish-entry.controller.d.ts

@@ -1,19 +0,0 @@
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-import { EntryWriterService } from '../services/entry-writer.service';
-import type { EntryRecord } from '../types/entry-list-view';
-/**
- * `POST /api/content/:typeName/:id/publish` and `.../unpublish` — the publish
- * workflow for a single entry. Publish revalidates the stored row (a 422 if the
- * draft no longer passes), then stamps `status='published'` + `published_at`;
- * unpublish reverts to draft. Both 400 on a non-publishable type and 404 on a
- * missing live row. `OriginGuard` defends the writes; `WorkspaceGuard` scopes
- * them to a workspace the caller belongs to; `content:publish` gates them.
- */
-export declare class PublishEntryController {
-    private readonly registry;
-    private readonly writer;
-    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
-    publish(typeName: string, id: string, workspaceId: string): Promise<EntryRecord>;
-    unpublish(typeName: string, id: string, workspaceId: string): Promise<EntryRecord>;
-}
-//# sourceMappingURL=publish-entry.controller.d.ts.map

package/dist/lib/entries/controllers/publish-entry.controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"publish-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/publish-entry.controller.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;;GAOG;AACH,qBAGa,sBAAsB;IAG3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,OAAO,CACgB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;IAMvB,SAAS,CACc,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;CAI1B"}

package/dist/lib/entries/controllers/resolve-type.d.ts

@@ -1,9 +0,0 @@
-import type { AnyContentType } from '../../types/content-type';
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-/**
- * Resolve a `:typeName` route param to a registered content type, or throw 404.
- * Every entries controller routes one path per HTTP verb against the registry,
- * so this single lookup keeps them thin and consistent.
- */
-export declare function resolveType(registry: ContentTypeRegistry, typeName: string): AnyContentType;
-//# sourceMappingURL=resolve-type.d.ts.map

package/dist/lib/entries/controllers/resolve-type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-type.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/resolve-type.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,WAAW,CACvB,QAAQ,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,MAAM,GACjB,cAAc,CAMhB"}

package/dist/lib/entries/controllers/update-entry.controller.d.ts

@@ -1,18 +0,0 @@
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-import { EntryWriterService } from '../services/entry-writer.service';
-import { SaveEntryDto } from '../dto/save-entry.dto';
-import type { EntryRecord } from '../types/entry-list-view';
-/**
- * `PATCH /api/content/:typeName/:id` — replace a live entry's values with a
- * validated bag (the editor always submits the full document). 404 if there's no
- * live row; 422 with the issue list on validation failure. `OriginGuard` defends
- * this state-changing write; `WorkspaceGuard` scopes it to a workspace the caller
- * belongs to; `content:update` gates it.
- */
-export declare class UpdateEntryController {
-    private readonly registry;
-    private readonly writer;
-    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
-    update(typeName: string, id: string, body: SaveEntryDto, workspaceId: string): Promise<EntryRecord>;
-}
-//# sourceMappingURL=update-entry.controller.d.ts.map

package/dist/lib/entries/controllers/update-entry.controller.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"update-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/update-entry.controller.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;GAMG;AACH,qBAGa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,MAAM,CACiB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAC9B,IAAI,EAAE,YAAY,EACN,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;CAU1B"}

package/dist/lib/entries/dto/bulk-ids.dto.d.ts

@@ -1,11 +0,0 @@
-/**
- * Body for the bulk endpoints (`/bulk/publish`, `/bulk/unpublish`,
- * `/bulk/delete`, `/bulk/restore`, and the publish dry run): the set of entry
- * ids to act on. Non-empty, uuid-typed, and capped at {@link BULK_MAX_IDS} so a
- * single request can't fan out unbounded work.
- */
-export declare class BulkIdsDto {
-    /** Entry ids to act on. */
-    ids: string[];
-}
-//# sourceMappingURL=bulk-ids.dto.d.ts.map

package/dist/lib/entries/dto/bulk-ids.dto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bulk-ids.dto.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/dto/bulk-ids.dto.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,qBAAa,UAAU;IACnB,2BAA2B;IAK3B,GAAG,EAAG,MAAM,EAAE,CAAC;CAClB"}

package/dist/lib/entries/dto/list-entries-query.dto.d.ts

@@ -1,46 +0,0 @@
-/** `?deleted=only` flips the list to the trash view (soft-deleted rows). */
-export declare const DELETED_ONLY = "only";
-/**
- * Query parameters for `GET /api/content/:typeName`. Pagination is 1-based; the
- * service applies the defaults (page 1, {@link DEFAULT_PAGE_SIZE}) so the
- * contract has one source of truth. `@Type` coerces the raw query strings — the
- * host's global `ValidationPipe` transforms but does not implicitly convert.
- */
-export declare class ListEntriesQueryDto {
-    /** Free-text search across the type's text-like columns (text/richtext/select). */
-    search?: string;
-    /**
-     * Structured filter tree as a JSON string (`?filter=<json>`), produced by
-     * the admin query builder and validated against the type's derived filter
-     * schema by `parseFilterTree`. Length-capped here as a first line of
-     * defence; the engine's node/depth caps bound the parsed shape.
-     */
-    filter?: string;
-    /** Sort spec: a column id (ascending) or `-`-prefixed (descending). */
-    sort?: string;
-    /** 1-based page number. */
-    page?: number;
-    /** Rows per page, capped at {@link MAX_PAGE_SIZE}. */
-    pageSize?: number;
-    /**
-     * `only` lists soft-deleted rows (the trash view) instead of live ones.
-     * Meaningful only for paranoid types; ignored otherwise. Absent (the
-     * default) lists live rows.
-     */
-    deleted?: typeof DELETED_ONLY;
-    /**
-     * Locale slug the list targets — an **extension-owned** param this package
-     * declares (the strict ValidationPipe rejects undeclared keys) but never
-     * interprets: it's forwarded to the bound `CONTENT_ENTRY_EXTENSION`, which
-     * validates and applies it. Ignored when no extension is bound or the type
-     * isn't localized.
-     */
-    locale?: string;
-    /**
-     * `default` widens the locale scope to fall back to the default locale
-     * where the requested one is missing (the relation picker's mode).
-     * Extension-owned, like {@link locale}.
-     */
-    localeFallback?: string;
-}
-//# sourceMappingURL=list-entries-query.dto.d.ts.map

package/dist/lib/entries/dto/list-entries-query.dto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list-entries-query.dto.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/dto/list-entries-query.dto.ts"],"names":[],"mappings":"AAYA,4EAA4E;AAC5E,eAAO,MAAM,YAAY,SAAS,CAAC;AAEnC;;;;;GAKG;AACH,qBAAa,mBAAmB;IAC5B,mFAAmF;IAInF,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;OAKG;IAIH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,uEAAuE;IAIvE,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,2BAA2B;IAK3B,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,sDAAsD;IAMtD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IAGH,OAAO,CAAC,EAAE,OAAO,YAAY,CAAC;IAE9B;;;;;;OAMG;IAIH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IAGH,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B"}

package/dist/lib/entries/dto/relation-delta-map.validator.d.ts

@@ -1,19 +0,0 @@
-import { type ValidationOptions, type ValidatorConstraintInterface } from 'class-validator';
-/**
- * Validates the `relations` bag of {@link SaveEntryDto}: a map from field name to
- * `{ link?, unlink?, order? }`, each an array of uuid strings. class-validator
- * can't decorate a `Record`'s dynamic keys, so this constraint checks the shape
- * of every value — turning a malformed delta (a non-array `unlink`, a non-uuid
- * id, an unknown inner key, or an over-large array) into a clean **400** instead
- * of letting it reach `inArray(...)` against a `uuid` column and surface as a
- * 500. Unknown inner keys are rejected so the nested `Record` can't slip past
- * the app's `forbidNonWhitelisted` posture, and the id arrays and the map itself
- * are size-bounded so a single request can't carry an unbounded payload.
- */
-export declare class RelationDeltaMapConstraint implements ValidatorConstraintInterface {
-    validate(value: unknown): boolean;
-    defaultMessage(): string;
-}
-/** Property decorator applying {@link RelationDeltaMapConstraint}. */
-export declare function IsRelationDeltaMap(options?: ValidationOptions): (object: object, propertyName: string) => void;
-//# sourceMappingURL=relation-delta-map.validator.d.ts.map

package/dist/lib/entries/dto/relation-delta-map.validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"relation-delta-map.validator.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/dto/relation-delta-map.validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,iBAAiB,EACtB,KAAK,4BAA4B,EACpC,MAAM,iBAAiB,CAAC;AAmCzB;;;;;;;;;;GAUG;AACH,qBACa,0BACT,YAAW,4BAA4B;IAEvC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAwBjC,cAAc,IAAI,MAAM;CAG3B;AAED,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,iBAAiB,IAClD,QAAQ,MAAM,EAAE,cAAc,MAAM,KAAG,IAAI,CAOtD"}

package/dist/lib/entries/dto/save-entry.dto.d.ts

@@ -1,46 +0,0 @@
-import type { RelationDelta } from '../types/entry-list-view';
-/**
- * Body for `POST /api/content/:typeName` (create) and
- * `PATCH /api/content/:typeName/:id` (update). The field `values` bag crosses the
- * wire, plus optional per-field relation **deltas** (`relations`) — the editor
- * stages its many-to-many / inverse link changes locally and sends them here
- * with the rest of the document, so a save persists everything in **one
- * transaction** without ever transmitting a huge relation whole.
- *
- * Reserved envelope columns (`status`/`published_at`/`deleted_at`) are owned by
- * the service and can't be set from here: `toColumns` projects only keys
- * declared on the type, so a reserved (or otherwise unknown) key in the bag is
- * silently dropped before storage; on a non-publishable type
- * `EntryValidationService` additionally flags unknown keys as a 422. The bag's
- * *contents* are validated against the type's field specs by that same service
- * (a dynamic, per-type contract class-validator can't express); the relation
- * deltas' ids are validated as existing workspace entries by
- * `RelationLinkService`. `values` is structurally only "an object" (its contents
- * are the per-type contract); the `relations` bag's *shape* — each value a
- * `{ link?, unlink?, order? }` of uuid arrays — is enforced here so a malformed
- * delta is a clean 400, not a 500 from a bad id hitting the query.
- */
-export declare class SaveEntryDto {
-    /** Field values keyed by field name. */
-    values: Record<string, unknown>;
-    /**
-     * Per-field relation deltas (`{ <field>: { link?, unlink?, order? } }`) —
-     * many/inverse relations only; a single relation is set through `values`.
-     */
-    relations?: Record<string, RelationDelta>;
-    /**
-     * Locale slug the entry is created in — an **extension-owned** param this
-     * package declares but never interprets (forwarded to the bound
-     * `CONTENT_ENTRY_EXTENSION`, which validates it and stamps the envelope
-     * column). Read on create only; an update never re-homes a row's locale.
-     */
-    locale?: string;
-    /**
-     * The existing translation group a created row joins (making it a sibling)
-     * — an **extension-owned**, opaque param, like {@link locale}. Absent → the
-     * row starts its own fresh group. The bound extension validates it against
-     * the workspace. Read on create only.
-     */
-    localeGroupId?: string;
-}
-//# sourceMappingURL=save-entry.dto.d.ts.map

package/dist/lib/entries/dto/save-entry.dto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"save-entry.dto.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/dto/save-entry.dto.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,YAAY;IACrB,wCAAwC;IAExC,MAAM,EAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjC;;;OAGG;IAIH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAE1C;;;;;OAKG;IAIH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;OAKG;IAGH,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/lib/entries/infrastructure/persistence/field-selection.d.ts

@@ -1,24 +0,0 @@
-import type { AnyContentType } from '../../../types/content-type';
-/**
- * The set of field names a `?fields=` list selects, or `undefined` when the
- * caller asked for none (the default — the whole record).
- */
-export type FieldSelection = ReadonlySet<string> | undefined;
-/**
- * Parse `?fields=title,slug` into the set {@link toRecord} projects `values`
- * down to. Only fields that carry a column are selectable — a many-relation or
- * an inverse back-reference has no value on the row (its links live in a join
- * table), so naming one is a client error, not a silently empty key.
- *
- * **Unknown names are rejected with a 400**, deliberately unlike
- * `?relationFields=`, which drops them. That list is an internal rendering hint
- * where a hidden column legitimately vanishes; this one is an external API
- * contract, where silently honouring `?fields=titel` would return records with
- * no fields and no explanation. Failing loudly makes the typo obvious.
- *
- * Envelope data (`id`, timestamps, `status`/`publishedAt`, `locale`) is **not**
- * selectable and is always returned — it identifies the record rather than
- * describing it, and callers can ignore what they don't need.
- */
-export declare function parseFieldSelection(type: AnyContentType, raw: string | undefined): FieldSelection;
-//# sourceMappingURL=field-selection.d.ts.map

package/dist/lib/entries/infrastructure/persistence/field-selection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"field-selection.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/persistence/field-selection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAGlE;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AAE7D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,GAAG,SAAS,GACxB,cAAc,CAiBhB"}

package/dist/lib/entries/infrastructure/queries/entry-filter-schema.d.ts

@@ -1,40 +0,0 @@
-import { type FieldSchema, type FilterSchema, type ScalarFieldSchema } from '@ortha-cms/utils-server';
-import { type AnyContentType } from '../../../types/content-type';
-import { type AnyFieldSpec } from '../../../types/fields';
-/**
- * The filter scalar type for one content field, or `null` to leave it
- * unfilterable. Mirrors the admin's `filterFieldsFromSchema`: text-like fields
- * filter as strings, `select` as an enum of its options, numerics as numbers,
- * dates as dates. `json`/`multiselect` have no scalar editor, and `relation`
- * filtering (by raw FK uuid) has no UI yet — all skipped.
- */
-export declare function scalarTypeFor(spec: AnyFieldSpec): ScalarFieldSchema | null;
-/**
- * Whether a field is backed by a comparable scalar column — the single source of
- * truth for "can this field be filtered or sorted". `json`/`multiselect` (jsonb)
- * and `relation` (FK uuid / join table) are not: they have no scalar editor and
- * ordering them is meaningless. The sort whitelist and the filter schema both
- * derive from this, so the two can't drift apart.
- */
-export declare function isScalarField(spec: AnyFieldSpec): boolean;
-/**
- * Build the query-builder `FilterSchema` for one content type at request time.
- * Whitelists the always-present envelope columns (`createdAt`/`updatedAt`),
- * plus `status`/`publishedAt` only on publishable types, plus `locale` on i18n
- * types, plus every filterable field (those `isScalarField` admits — the same
- * set the admin's `filterFieldsFromSchema` offers), keyed by the property
- * names the engine resolves to table columns. (`status` has a matching admin
- * filter; the timestamp envelopes like `publishedAt` are filterable via the
- * API but have no UI control yet.) This is the security boundary: only listed
- * fields/ops reach SQL, and the engine's depth/node caps bound payload
- * blow-up.
- *
- * `extensionFields` are **virtual** fields contributed by the bound
- * `CONTENT_ENTRY_EXTENSION` (e.g. locale aggregates): their declarations merge
- * into `fields` (so the parser can coerce values) and their names are
- * registered on the schema's `extensionFields` set, routing them to the
- * extension's own SQL resolver instead of a table column. A field column
- * always wins a name collision — an extension cannot shadow real data.
- */
-export declare function buildEntryFilterSchema(type: AnyContentType, extensionFields?: FieldSchema): FilterSchema;
-//# sourceMappingURL=entry-filter-schema.d.ts.map

package/dist/lib/entries/infrastructure/queries/entry-filter-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-filter-schema.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/queries/entry-filter-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAChF,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE9E;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,iBAAiB,GAAG,IAAI,CAsB1E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,cAAc,EACpB,eAAe,CAAC,EAAE,WAAW,GAC9B,YAAY,CAmCd"}

package/dist/lib/entries/services/entries.service.d.ts

@@ -1,59 +0,0 @@
-import { type Database } from '@ortha-cms/database';
-import { type ContentEntryExtension } from '../../extension/entry-extension';
-import type { AnyContentType } from '../../types/content-type';
-import { type ListEntriesQueryDto } from '../dto/list-entries-query.dto';
-import type { EntryListView } from '../types/entry-list-view';
-/**
- * Reads a collection's entries. Generic over the content type: the physical
- * table, the filterable columns, the searchable columns, and the sort whitelist
- * are all derived from `type` at request time, so one service backs every
- * collection. Owns no schema of its own — it queries the HOST-owned generated
- * `content_<name>` tables through the shared Drizzle client.
- */
-export declare class EntriesService {
-    private readonly db;
-    private readonly extension?;
-    constructor(db: Database, extension?: ContentEntryExtension | undefined);
-    /**
-     * One page of a collection's entries: search → filter → sort → paginate, run
-     * in SQL against the type's generated table, returned as the
-     * `{ items, total, page, pageSize }` envelope the admin records table renders.
-     * Scoped to `workspaceId` — only the calling workspace's entries are counted
-     * or listed.
-     */
-    list(type: AnyContentType, query: ListEntriesQueryDto, workspaceId: string): Promise<EntryListView>;
-    /**
-     * The full WHERE: the workspace scope AND free-text search AND the
-     * query-builder `?filter=` tree AND (for paranoid types) the not-deleted
-     * guard. `and(undefined, …)` collapses empties, so an unfiltered list still
-     * scans the workspace's whole table. The workspace predicate is always
-     * present, so an entry never leaks across workspaces. A malformed filter
-     * throws a `FilterException` (HTTP 400).
-     */
-    private listWhere;
-    /**
-     * The soft-delete guard for paranoid types: the default list excludes
-     * tombstoned rows (`deleted_at IS NULL`); `?deleted=only` flips to the trash
-     * view (`deleted_at IS NOT NULL`). A non-paranoid type has no `deleted_at`,
-     * so the predicate collapses to `undefined`.
-     */
-    private deletedPredicate;
-    /**
-     * Case-insensitive `ILIKE` across the type's text-like columns, OR-ed
-     * together; `undefined` when there's no search term. The needle's LIKE
-     * metacharacters are escaped so a literal `%`/`_` searches literally.
-     */
-    private searchPredicate;
-    /**
-     * Translate the `?sort=` spec (`col` asc, `-col` desc) into an ORDER BY,
-     * always with an `id` tiebreaker so pagination is stable across requests.
-     * Sortable = the always-present envelope columns + `status` (publishable
-     * only) + the type's **scalar** fields. Non-scalar fields (`json`/
-     * `multiselect`, single/many `relation`) are excluded — a many-relation has
-     * no column on the main table at all, so ordering by it would pass
-     * `undefined` to `asc`/`desc`; the others have no meaningful order. An
-     * unknown or excluded column falls back to `updatedAt` desc.
-     */
-    private orderBy;
-}
-//# sourceMappingURL=entries.service.d.ts.map

package/dist/lib/entries/services/entries.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entries.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/services/entries.service.ts"],"names":[],"mappings":"AAcA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,EAEH,KAAK,qBAAqB,EAC7B,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EAEH,KAAK,mBAAmB,EAC3B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAiB9D;;;;;;GAMG;AACH,qBACa,cAAc;IAED,OAAO,CAAC,QAAQ,CAAC,EAAE;IAKrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;gBALQ,EAAE,EAAE,QAAQ,EAK9B,SAAS,CAAC,EAAE,qBAAqB,YAAA;IAGtD;;;;;;OAMG;IACG,IAAI,CACN,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,mBAAmB,EAC1B,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC;IA8BzB;;;;;;;OAOG;YACW,SAAS;IAqCvB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAcvB;;;;;;;;;OASG;IACH,OAAO,CAAC,OAAO;CAsBlB"}

package/dist/lib/entries/services/entry-counter.service.d.ts

@@ -1,31 +0,0 @@
-import { type Database } from '@ortha-cms/database';
-import type { ContentEntryCounter } from '@ortha-cms/identity-server';
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-/**
- * Implements identity's {@link ContentEntryCounter} port over the generated
- * `content_<name>` tables: counts how many entries of a content type a
- * workspace holds. Bound to `CONTENT_ENTRY_COUNTER` in {@link ContentModule},
- * so identity's "revoke a content-type grant only when empty" rule resolves
- * against the real stored entries.
- */
-export declare class EntryCounterService implements ContentEntryCounter {
-    private readonly db;
-    private readonly registry;
-    constructor(db: Database, registry: ContentTypeRegistry);
-    /**
-     * Every stored row of content type `slug` in `workspaceId`. Counts the
-     * whole workspace slice of the type's table — including soft-deleted rows
-     * for paranoid types (data that still exists must keep the grant). An
-     * unknown slug (no such content type) counts as `0`.
-     */
-    countEntries(workspaceId: string, slug: string): Promise<number>;
-    /**
-     * Every stored row the workspace holds across **all** content types —
-     * summed over each type's table. Backs the workspace-delete guard (delete is
-     * refused until this is zero). The per-type counts run concurrently.
-     */
-    countWorkspaceEntries(workspaceId: string): Promise<number>;
-    /** Counts a single content type's rows in a workspace. */
-    private countTable;
-}
-//# sourceMappingURL=entry-counter.service.d.ts.map

package/dist/lib/entries/services/entry-counter.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-counter.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/services/entry-counter.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAMhF;;;;;;GAMG;AACH,qBACa,mBAAoB,YAAW,mBAAmB;IAErC,OAAO,CAAC,QAAQ,CAAC,EAAE;IACZ,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBADf,EAAE,EAAE,QAAQ,EACL,QAAQ,EAAE,mBAAmB;IAG3E;;;;;OAKG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAMtE;;;;OAIG;IACG,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASjE,0DAA0D;YAC5C,UAAU;CAW3B"}

package/dist/lib/entries/services/entry-filter-schema.d.ts

@@ -1,32 +0,0 @@
-import { type FieldSchema, type FilterSchema } from '@ortha-cms/utils-server';
-import { type AnyContentType } from '../../types/content-type';
-import { type AnyFieldSpec } from '../../types/fields';
-/**
- * Whether a field is backed by a comparable scalar column — the single source of
- * truth for "can this field be filtered or sorted". `json`/`multiselect` (jsonb)
- * and `relation` (FK uuid / join table) are not: they have no scalar editor and
- * ordering them is meaningless. The sort whitelist and the filter schema both
- * derive from this, so the two can't drift apart.
- */
-export declare function isScalarField(spec: AnyFieldSpec): boolean;
-/**
- * Build the query-builder `FilterSchema` for one content type at request time.
- * Whitelists the always-present envelope columns (`createdAt`/`updatedAt`),
- * plus `status`/`publishedAt` only on publishable types, plus `locale` on i18n
- * types, plus every filterable field (those `isScalarField` admits — the same
- * set the admin's `filterFieldsFromSchema` offers), keyed by the property
- * names the engine resolves to table columns. (`status` has a matching admin
- * filter; the timestamp envelopes like `publishedAt` are filterable via the
- * API but have no UI control yet.) This is the security boundary: only listed
- * fields/ops reach SQL, and the engine's depth/node caps bound payload
- * blow-up.
- *
- * `extensionFields` are **virtual** fields contributed by the bound
- * `CONTENT_ENTRY_EXTENSION` (e.g. locale aggregates): their declarations merge
- * into `fields` (so the parser can coerce values) and their names are
- * registered on the schema's `extensionFields` set, routing them to the
- * extension's own SQL resolver instead of a table column. A field column
- * always wins a name collision — an extension cannot shadow real data.
- */
-export declare function buildEntryFilterSchema(type: AnyContentType, extensionFields?: FieldSchema): FilterSchema;
-//# sourceMappingURL=entry-filter-schema.d.ts.map

package/dist/lib/entries/services/entry-filter-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-filter-schema.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/services/entry-filter-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,WAAW,EAChB,KAAK,YAAY,EAEpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAiC3E;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,cAAc,EACpB,eAAe,CAAC,EAAE,WAAW,GAC9B,YAAY,CAmCd"}