@cosmicdrift/kumiko-bundled-features 0.399.0 → 0.401.0

package/dist/documents/queries/list-page.d.ts

@@ -0,0 +1,19 @@
+import type { HandlerContext } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+declare const pageSchema: z.ZodObject<{
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    nextCursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    total: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ListPage = z.infer<typeof pageSchema>;
+export type ListFilter = {
+    readonly field: string;
+    readonly op: string;
+    readonly value: unknown;
+};
+export declare function listDocuments(ctx: Pick<HandlerContext, "dispatch">, payload: Record<string, unknown>): Promise<ListPage>;
+export declare function linkedDocumentIds(ctx: Pick<HandlerContext, "dispatch">, target: {
+    readonly entityType: string;
+    readonly entityId: string;
+}): Promise<string[]>;
+export {};

package/dist/documents/queries/list-page.js

@@ -0,0 +1,36 @@
+import * as z from "zod";
+import { DocumentsQueries } from "../constants.js";
+const LINK_LIST = "documents:query:filed-document-link:list";
+const LINK_PAGE_SIZE = 200;
+const pageSchema = z.object({
+    rows: z.array(z.record(z.string(), z.unknown())),
+    nextCursor: z.string().nullable().optional(),
+    total: z.number().optional(),
+});
+export async function listDocuments(ctx, payload) {
+    return pageSchema.parse(await ctx.dispatch.query(DocumentsQueries.list, payload));
+}
+// Goes through the link list, so a record the caller cannot read yields no ids (the link's
+// parentRef gate), and a document is then fetched through the document list, which applies the
+// document's own read gate again.
+export async function linkedDocumentIds(ctx, target) {
+    const ids = [];
+    let cursor;
+    do {
+        const page = pageSchema.parse(await ctx.dispatch.query(LINK_LIST, {
+            filters: [
+                { field: "entityType", op: "eq", value: target.entityType },
+                { field: "entityId", op: "eq", value: target.entityId },
+            ],
+            limit: LINK_PAGE_SIZE,
+            ...(cursor !== undefined && { cursor }),
+        }));
+        for (const row of page.rows) {
+            const documentId = row["documentId"];
+            if (typeof documentId === "string")
+                ids.push(documentId);
+        }
+        cursor = page.nextCursor ?? undefined;
+    } while (cursor !== undefined);
+    return ids;
+}

package/dist/documents/queries/overview.query.d.ts

@@ -0,0 +1,32 @@
+import { type AccessRule } from "@cosmicdrift/kumiko-framework/engine";
+export declare function createOverviewQuery(access: AccessRule, expiringWithinDays: number): import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"overview", import("zod").ZodObject<{
+    limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+    offset: import("zod").ZodOptional<import("zod").ZodNumber>;
+    search: import("zod").ZodOptional<import("zod").ZodString>;
+    sort: import("zod").ZodOptional<import("zod").ZodString>;
+    sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    totalCount: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    filters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        field: import("zod").ZodString;
+        op: import("zod").ZodEnum<{
+            eq: "eq";
+            gt: "gt";
+            gte: "gte";
+            in: "in";
+            lt: "lt";
+            lte: "lte";
+            ne: "ne";
+        }>;
+        value: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strip>>>;
+}, import("zod/v4/core").$strip>, {
+    nextCursor?: string | null | undefined;
+    total?: number | undefined;
+    rows: {
+        expiry: "expired" | "expiring" | "none" | "valid";
+    }[];
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/documents/queries/overview.query.js

@@ -0,0 +1,41 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { EXPIRING_FACET_VALUE } from "../constants.js";
+import { expiryStateOf, expiryWindow } from "../expiry.js";
+import { overviewPayloadSchema } from "../schemas.js";
+import { listDocuments } from "./list-page.js";
+const EXPIRY_FILTER_FIELD = "expiry";
+// The "expiring" facet is a moving date window, which a facet on a stored field cannot
+// express; it becomes a validUntil bound here, expired documents included. A document
+// without a date never matches it.
+function toDocumentFilters(filters, horizon) {
+    return filters.flatMap((clause) => {
+        if (clause.field !== EXPIRY_FILTER_FIELD)
+            return [clause];
+        const wantsExpiring = Array.isArray(clause.value) && clause.value.includes(EXPIRING_FACET_VALUE);
+        return wantsExpiring ? [{ field: "validUntil", op: "lte", value: horizon }] : [];
+    });
+}
+export function createOverviewQuery(access, expiringWithinDays) {
+    return defineQueryHandler({
+        name: "overview",
+        schema: overviewPayloadSchema,
+        access,
+        liveEntities: ["filed-document", "filed-document-link"],
+        description: "Lists the documents the caller can read with an expiry state per row (expired, expiring, valid, none); the expiring filter returns expired and soon-expiring documents. Powers the documents list screen.",
+        handler: async (query, ctx) => {
+            const { filters, ...paging } = query.payload;
+            const window = expiryWindow(ctx, expiringWithinDays);
+            const page = await listDocuments(ctx, {
+                ...paging,
+                filters: toDocumentFilters(filters ?? [], window.horizon),
+            });
+            return {
+                ...page,
+                rows: page.rows.map((row) => ({
+                    ...row,
+                    expiry: expiryStateOf(row["validUntil"], window),
+                })),
+            };
+        },
+    });
+}

package/dist/documents/schemas.d.ts

@@ -0,0 +1,93 @@
+import * as z from "zod";
+export declare const documentLinkPayloadSchema: z.ZodObject<{
+    documentId: z.ZodUUID;
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+}, z.core.$strip>;
+export type DocumentLinkPayload = z.infer<typeof documentLinkPayloadSchema>;
+export declare const importDocumentPayloadSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    title: z.ZodString;
+    category: z.ZodString;
+    issuedAt: z.ZodOptional<z.ZodISODate>;
+    validUntil: z.ZodOptional<z.ZodISODate>;
+    fileRefId: z.ZodUUID;
+    links: z.ZodArray<z.ZodObject<{
+        entityType: z.ZodString;
+        entityId: z.ZodString;
+    }, z.core.$strip>>;
+    deleted: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ImportDocumentPayload = z.infer<typeof importDocumentPayloadSchema>;
+export declare const forRecordPayloadSchema: z.ZodObject<{
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    search: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodString>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    totalCount: z.ZodOptional<z.ZodBoolean>;
+    filter: z.ZodOptional<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            eq: "eq";
+            gt: "gt";
+            gte: "gte";
+            in: "in";
+            lt: "lt";
+            lte: "lte";
+            ne: "ne";
+        }>;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            eq: "eq";
+            gt: "gt";
+            gte: "gte";
+            in: "in";
+            lt: "lt";
+            lte: "lte";
+            ne: "ne";
+        }>;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ForRecordPayload = z.infer<typeof forRecordPayloadSchema>;
+export declare const overviewPayloadSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    search: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodString>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    totalCount: z.ZodOptional<z.ZodBoolean>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            eq: "eq";
+            gt: "gt";
+            gte: "gte";
+            in: "in";
+            lt: "lt";
+            lte: "lte";
+            ne: "ne";
+        }>;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type OverviewPayload = z.infer<typeof overviewPayloadSchema>;
+export declare const expiryOverviewPayloadSchema: z.ZodObject<{
+    entityType: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ExpiryOverviewPayload = z.infer<typeof expiryOverviewPayloadSchema>;

package/dist/documents/schemas.js

@@ -0,0 +1,51 @@
+import * as z from "zod";
+export const documentLinkPayloadSchema = z.object({
+    documentId: z.uuid(),
+    entityType: z.string().min(1).max(64),
+    entityId: z.string().min(1).max(128),
+});
+const isoDate = z.iso.date();
+export const importDocumentPayloadSchema = z.object({
+    id: z.uuid(),
+    title: z.string().trim().min(1).max(200),
+    category: z.string().min(1),
+    issuedAt: isoDate.optional(),
+    validUntil: isoDate.optional(),
+    fileRefId: z.uuid(),
+    links: z.array(z.object({ entityType: z.string().min(1).max(64), entityId: z.string().min(1).max(128) })),
+    deleted: z.boolean().optional(),
+});
+export const forRecordPayloadSchema = z.object({
+    entityType: z.string().min(1).max(64),
+    entityId: z.string().min(1).max(128),
+    limit: z.number().int().nonnegative().max(200).optional(),
+    cursor: z.string().optional(),
+    offset: z.number().int().nonnegative().optional(),
+    search: z.string().optional(),
+    sort: z.string().optional(),
+    sortDirection: z.enum(["asc", "desc"]).optional(),
+    totalCount: z.boolean().optional(),
+    filter: z
+        .object({
+        field: z.string(),
+        op: z.enum(["eq", "ne", "lt", "gt", "lte", "gte", "in"]),
+        value: z.unknown(),
+    })
+        .optional(),
+    filters: z
+        .array(z.object({
+        field: z.string(),
+        op: z.enum(["eq", "ne", "lt", "gt", "lte", "gte", "in"]),
+        value: z.unknown(),
+    }))
+        .optional(),
+});
+export const overviewPayloadSchema = forRecordPayloadSchema.omit({
+    entityType: true,
+    entityId: true,
+    filter: true,
+});
+export const expiryOverviewPayloadSchema = z.object({
+    entityType: z.string().min(1).max(64).optional(),
+    entityId: z.string().min(1).max(128).optional(),
+});

package/dist/documents/screens.d.ts

@@ -0,0 +1,3 @@
+import { type AccessRule, type ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/engine";
+export declare const DOCUMENT_COLUMNS: readonly ["title", "category", "validUntil", "file"];
+export declare function createDocumentListScreen(access: AccessRule, categories: readonly string[]): ProjectionListScreenDefinition;

package/dist/documents/screens.js

@@ -0,0 +1,76 @@
+import { i18nKey, } from "@cosmicdrift/kumiko-framework/engine";
+import { DOCUMENTS_LIST_SCREEN_ID, DocumentsQueries, EXPIRING_FACET_VALUE } from "./constants.js";
+// The columns every document list shows; the tab and the standalone screen stay alike.
+export const DOCUMENT_COLUMNS = ["title", "category", "validUntil", "file"];
+const FIELD_PREFIX = "documents:entity:filed-document:field:";
+const CATEGORY_OPTION_PREFIX = `${FIELD_PREFIX}category:option:`;
+// A projectionList, not an entityList: the expiry state and its "expiring" filter are computed
+// per request from a moving date window, which an entityList's facets on stored fields cannot
+// express. The overview query still reads through the document list, so the read gate holds.
+export function createDocumentListScreen(access, categories) {
+    return {
+        id: DOCUMENTS_LIST_SCREEN_ID,
+        type: "projectionList",
+        query: DocumentsQueries.overview,
+        columns: [
+            { field: "title", label: `${FIELD_PREFIX}title` },
+            {
+                field: "category",
+                label: `${FIELD_PREFIX}category`,
+                renderer: { format: "enumOption", keyPrefix: CATEGORY_OPTION_PREFIX },
+            },
+            {
+                field: "validUntil",
+                label: `${FIELD_PREFIX}validUntil`,
+                renderer: { format: "date", dateStyle: "medium" },
+            },
+            {
+                field: "expiry",
+                label: "documents:list.facet.expiry",
+                sortable: false,
+                hideOnNarrow: true,
+                renderer: { format: "enumOption", keyPrefix: "documents:list.expiry." },
+            },
+            {
+                field: "file",
+                label: `${FIELD_PREFIX}file`,
+                sortable: false,
+                renderer: { format: "file" },
+            },
+        ],
+        pagination: "pages",
+        defaultSort: { field: "validUntil", dir: "asc" },
+        searchable: true,
+        facets: [
+            {
+                field: "category",
+                type: "select",
+                label: `${FIELD_PREFIX}category`,
+                options: categories.map((value) => ({
+                    value,
+                    label: `${CATEGORY_OPTION_PREFIX}${value}`,
+                })),
+            },
+            {
+                field: "expiry",
+                type: "select",
+                label: "documents:list.facet.expiry",
+                options: [{ value: EXPIRING_FACET_VALUE, label: "documents:list.facet.expiring" }],
+            },
+        ],
+        rowActions: [
+            {
+                kind: "writeHandler",
+                id: "delete",
+                label: i18nKey("kumiko.actions.delete"),
+                handler: "documents:write:filed-document:delete",
+                payload: { pick: ["id"] },
+                confirm: i18nKey("kumiko.actions.delete-confirm"),
+                style: "danger",
+            },
+        ],
+        access,
+        // The app places it with r.nav("documents:screen:list").
+        dormant: true,
+    };
+}

package/dist/documents/tab.d.ts

@@ -0,0 +1,4 @@
+import type { EditRelatedListSection } from "@cosmicdrift/kumiko-framework/engine";
+import type { DashboardStatPanel } from "@cosmicdrift/kumiko-framework/ui-types";
+export declare function documentsTab(entityType: string): EditRelatedListSection;
+export declare function documentExpiryPanels(): readonly DashboardStatPanel[];

package/dist/documents/tab.js

@@ -0,0 +1,42 @@
+import { DOCUMENT_ENTITY, DOCUMENTS_FEATURE_NAME, DocumentsQueries } from "./constants.js";
+import { forTypeQueryQn } from "./queries/for-record.query.js";
+// "Documents" tab for the edit screen of a link target. The tab id is the same on every screen,
+// so deep links like ?tab=documents work across hosts.
+export function documentsTab(entityType) {
+    return {
+        id: "documents",
+        kind: "relatedList",
+        title: "documents:tab.title",
+        query: forTypeQueryQn(entityType),
+        entity: `${DOCUMENTS_FEATURE_NAME}:${DOCUMENT_ENTITY}`,
+        columns: [
+            { field: "title", sortable: true },
+            { field: "category", sortable: true },
+            { field: "validUntil", sortable: true },
+            { field: "file" },
+        ],
+        searchable: true,
+        count: true,
+    };
+}
+// Stat tiles for a dashboard: how many readable documents are expired or about to expire.
+export function documentExpiryPanels() {
+    return [
+        {
+            kind: "stat",
+            id: "documents-expired",
+            label: "documents:overview.expired",
+            query: DocumentsQueries.expiryOverview,
+            valueField: "expired",
+            tone: "negative",
+        },
+        {
+            kind: "stat",
+            id: "documents-expiring",
+            label: "documents:overview.expiring",
+            query: DocumentsQueries.expiryOverview,
+            valueField: "expiring",
+            tone: "warn",
+        },
+    ];
+}

package/dist/documents/target-write-check.d.ts

@@ -0,0 +1,3 @@
+import type { TenantDb } from "@cosmicdrift/kumiko-framework/db";
+import { type Registry, type SessionUser } from "@cosmicdrift/kumiko-framework/engine";
+export declare function canWriteLinkTarget(registry: Registry, entityType: string, entityId: string, user: SessionUser, db: TenantDb): Promise<boolean>;

package/dist/documents/target-write-check.js

@@ -0,0 +1,32 @@
+import { createEntityExecutor, hasAccess, toKebab, userCanWriteFieldRow, } from "@cosmicdrift/kumiko-framework/engine";
+import { parentRowIsVisible } from "../shared/index.js";
+function updateHandlerAccessOf(registry, entityType) {
+    const suffix = `:write:${toKebab(entityType)}:update`;
+    for (const [qn, handler] of registry.getAllWriteHandlers()) {
+        if (qn.endsWith(suffix) && registry.getHandlerEntity(qn) === entityType)
+            return handler.access;
+    }
+    return undefined;
+}
+// Linking a document changes what readers of the target see, so it needs what saving the target
+// needs: read visibility, a write gate and its row-level write rule. The gate is the entity's
+// update handler; an entity saved only through custom handlers has none, so its declared write
+// roles stand in, and without either the target stays unlinkable. A target that is not visible
+// answers like a missing one.
+export async function canWriteLinkTarget(registry, entityType, entityId, user, db) {
+    if (!(await parentRowIsVisible(registry, entityType, entityId, user, db)))
+        return false;
+    const entity = registry.getEntity(entityType);
+    if (entity === undefined)
+        return false;
+    const updateAccess = updateHandlerAccessOf(registry, entityType);
+    if (updateAccess !== undefined) {
+        if (!hasAccess(user, updateAccess))
+            return false;
+    }
+    else if (!hasAccess(user, { roles: Object.keys(entity.access?.write ?? {}) })) {
+        return false;
+    }
+    const row = await createEntityExecutor(entityType, entity).executor.detail({ id: entityId }, user, db);
+    return row !== null && userCanWriteFieldRow(user, entity.access?.write, row, row);
+}

package/dist/documents/write-guard.d.ts

@@ -0,0 +1,6 @@
+import { type DeleteContext, type HandlerContext, type PreSaveHookFn } from "@cosmicdrift/kumiko-framework/engine";
+import type { DocumentExecutors } from "./executor.ts";
+export declare function createDocumentWriteGuard(executors: DocumentExecutors, adminRoles: readonly string[]): {
+    beforeUpdate: PreSaveHookFn;
+    beforeDelete: (payload: DeleteContext, ctx: HandlerContext) => Promise<void>;
+};

package/dist/documents/write-guard.js

@@ -0,0 +1,46 @@
+import { SYSTEM_ROLE, } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
+import { DOCUMENT_ENTITY } from "./constants.js";
+import { canWriteLinkTarget } from "./target-write-check.js";
+const LINK_PAGE_SIZE = 200;
+// Editing or deleting a document changes what every reader of its hosts sees, so it needs what
+// unlink needs: write access to at least one host it is linked to. Admin roles see unlinked
+// documents too and must be able to clean them up, and SYSTEM jobs (import, capture) write on
+// their own authority. A refused caller gets "not found", like a document they cannot read.
+export function createDocumentWriteGuard(executors, adminRoles) {
+    async function assertMayWrite(documentId, ctx) {
+        const { user } = ctx;
+        if (user.roles.includes(SYSTEM_ROLE) || user.roles.some((role) => adminRoles.includes(role))) {
+            // skip: exempt roles write on their own authority
+            return;
+        }
+        let offset = 0;
+        for (;;) {
+            const page = await executors.link.list({
+                filters: [{ field: "documentId", op: "eq", value: documentId }],
+                limit: LINK_PAGE_SIZE,
+                offset,
+            }, user, ctx.db);
+            for (const row of page.rows) {
+                const entityType = String(row["entityType"]);
+                const entityId = String(row["entityId"]);
+                // skip: one writable host is enough
+                if (await canWriteLinkTarget(ctx.registry, entityType, entityId, user, ctx.db))
+                    return;
+            }
+            if (page.rows.length < LINK_PAGE_SIZE)
+                break;
+            offset += LINK_PAGE_SIZE;
+        }
+        throw new NotFoundError(DOCUMENT_ENTITY, documentId);
+    }
+    const beforeUpdate = async (changes, ctx) => {
+        if (!ctx.isNew)
+            await assertMayWrite(String(ctx.previous["id"]), ctx);
+        return changes;
+    };
+    const beforeDelete = async (payload, ctx) => {
+        await assertMayWrite(String(payload.id), ctx);
+    };
+    return { beforeUpdate, beforeDelete };
+}

package/dist/inbound-mail-foundation/entities.d.ts

@@ -41,7 +41,7 @@ export declare const mailAccountEntity: import("@cosmicdrift/kumiko-types/fields
         readonly min?: string;
         readonly max?: string;
         readonly locale?: string;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
 }, "tenant">;
@@ -89,7 +89,7 @@ export declare const inboundMessageEntity: import("@cosmicdrift/kumiko-types/fie
         readonly min?: string;
         readonly max?: string;
         readonly locale?: string;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
     readonly bodyRef: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
@@ -101,7 +101,17 @@ export declare const inboundMessageEntity: import("@cosmicdrift/kumiko-types/fie
     readonly bodyText: import("@cosmicdrift/kumiko-types/fields").EntityLongTextFieldDef & {
         required: false;
     };
-    readonly bodyTextTruncated: import("@cosmicdrift/kumiko-types/fields").BooleanFieldDef & {
+    readonly bodyTextTruncated: {
+        readonly type: "boolean";
+        readonly description?: string;
+        readonly required?: boolean;
+        readonly sortable?: boolean;
+        readonly sortNulls?: import("@cosmicdrift/kumiko-types/fields").SortNulls;
+        readonly filterable?: boolean;
+        readonly sensitive?: boolean;
+        readonly default?: boolean;
+        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
+    } & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: false;
         default: boolean;
     };
@@ -141,7 +151,7 @@ export declare const mailThreadEntity: import("@cosmicdrift/kumiko-types/fields"
         readonly min?: string;
         readonly max?: string;
         readonly locale?: string;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
     readonly messageCount: {
@@ -161,7 +171,7 @@ export declare const mailThreadEntity: import("@cosmicdrift/kumiko-types/fields"
             readonly field: string;
         };
         readonly grouping?: boolean;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
 }, "tenant">;
@@ -195,7 +205,7 @@ export declare const syncCursorEntity: import("@cosmicdrift/kumiko-types/fields"
         readonly min?: string;
         readonly max?: string;
         readonly locale?: string;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
 }, "tenant">;
@@ -223,7 +233,7 @@ export declare const seenMessageEntity: import("@cosmicdrift/kumiko-types/fields
         readonly min?: string;
         readonly max?: string;
         readonly locale?: string;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
 }, "tenant">;

package/dist/inbound-mail-foundation/ingest-failures.d.ts

@@ -25,7 +25,7 @@ export declare const ingestFailureEntity: import("@cosmicdrift/kumiko-types/fiel
             readonly field: string;
         };
         readonly grouping?: boolean;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
     readonly lastCountedBucket: {
@@ -45,7 +45,7 @@ export declare const ingestFailureEntity: import("@cosmicdrift/kumiko-types/fiel
             readonly field: string;
         };
         readonly grouping?: boolean;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
     readonly lastFailedAt: {
@@ -61,7 +61,7 @@ export declare const ingestFailureEntity: import("@cosmicdrift/kumiko-types/fiel
         readonly min?: string;
         readonly max?: string;
         readonly locale?: string;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
 }, "tenant">;

package/dist/inbound-mail-foundation/projection.d.ts

@@ -39,7 +39,7 @@ export declare const mailAccountsProjectionTable: import("@cosmicdrift/kumiko-fr
         readonly min?: string;
         readonly max?: string;
         readonly locale?: string;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
 }, "tenant">>;
@@ -84,7 +84,7 @@ export declare const inboundMessagesProjectionTable: import("@cosmicdrift/kumiko
         readonly min?: string;
         readonly max?: string;
         readonly locale?: string;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
     readonly bodyRef: import("@cosmicdrift/kumiko-types/fields").EntityTextFieldDef & {
@@ -96,7 +96,17 @@ export declare const inboundMessagesProjectionTable: import("@cosmicdrift/kumiko
     readonly bodyText: import("@cosmicdrift/kumiko-types/fields").EntityLongTextFieldDef & {
         required: false;
     };
-    readonly bodyTextTruncated: import("@cosmicdrift/kumiko-types/fields").BooleanFieldDef & {
+    readonly bodyTextTruncated: {
+        readonly type: "boolean";
+        readonly description?: string;
+        readonly required?: boolean;
+        readonly sortable?: boolean;
+        readonly sortNulls?: import("@cosmicdrift/kumiko-types/fields").SortNulls;
+        readonly filterable?: boolean;
+        readonly sensitive?: boolean;
+        readonly default?: boolean;
+        readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
+    } & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: false;
         default: boolean;
     };
@@ -134,7 +144,7 @@ export declare const mailThreadsProjectionTable: import("@cosmicdrift/kumiko-fra
         readonly min?: string;
         readonly max?: string;
         readonly locale?: string;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
     readonly messageCount: {
@@ -154,7 +164,7 @@ export declare const mailThreadsProjectionTable: import("@cosmicdrift/kumiko-fra
             readonly field: string;
         };
         readonly grouping?: boolean;
-    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
+    } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & import("@cosmicdrift/kumiko-types/fields").FieldStateConditions & {
         required: true;
     };
 }, "tenant">>;