@antelopejs/interface-dms 0.9.1 → 0.10.0

package/dist/component-options/action-target.d.ts

@@ -0,0 +1,304 @@
+import type { Component, ComponentInfoSerialized } from "../component";
+export type ModalSize = "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl"
+/** The whole window: a near full-screen modal, a drawer as wide as the window. */
+ | "full";
+/** The edge of the window a `drawer` action target slides in from. */
+export type DrawerDirection = "top" | "right" | "bottom" | "left";
+/**
+ * What a side panel says when the row its link names is gone: the `?record=`
+ * of a deep link, or a `fetchRowUrl` / `get` route answering 404. Texts are
+ * `$`-prefixed i18n keys or literals.
+ */
+export interface SidePanelNotFoundTexts {
+    /**
+     * Title of the state, e.g. `"$api.request.not_found_title"` for "This
+     * request is no longer stored". Defaults to the DMS's generic "This entry
+     * is no longer available".
+     */
+    title?: string;
+    /**
+     * Text under it, e.g. "It was pruned by the log retention, or the link is
+     * wrong." Defaults to the DMS's generic one.
+     */
+    description?: string;
+}
+/**
+ * What a `sidePanel` action target sets besides its component, shared by the
+ * declared and the serialized target.
+ */
+export interface SidePanelTargetOptions {
+    /**
+     * Title of the panel header. `$`-prefixed: an i18n key. Defaults to the
+     * action's label.
+     */
+    title?: string;
+    /**
+     * Title of the header while a row is open, in place of `title`: an i18n key
+     * (`$`-prefixed) or a literal receiving the row's fields, as a
+     * confirmation's texts do. `"$api.request.heading"` translated "{method}
+     * {path}" reads "POST /api/orders". `title` stays the header of a panel
+     * showing no row (a missing one).
+     * @example "{method} {path}"
+     */
+    rowTitle?: string;
+    /**
+     * Position of the open row among all the rows the table lists (its count,
+     * not the page loaded), drawn under the title: an i18n key (`$`-prefixed)
+     * receiving `{ index }` (from 1) and `{ total }`, both written with the
+     * locale's digit grouping ("26 120"), e.g.
+     * `"$api.request.position"` for "Request {index} of {total}". Defaults to
+     * the DMS's generic "{index} of {total}".
+     */
+    positionLabel?: string;
+    /**
+     * The open row is kept in the URL (`?record=<id>`, `?<tableId>.record=<id>`
+     * on a page with several table views): a link or a reload opens the panel
+     * again on that row, and closing it removes the key. On by default for a
+     * side panel: `false` opts out. The action's own `deepLink` wins when set.
+     */
+    deepLink?: boolean;
+    /**
+     * The words of the panel opened on a row that no longer exists (a deep link
+     * to a deleted row): the DMS draws the state and a close button under the
+     * header, in place of the component. See {@link SidePanelNotFoundTexts}.
+     * @example { title: "$api.request.not_found_title", description: "$api.request.not_found_description" }
+     */
+    notFound?: SidePanelNotFoundTexts;
+}
+/**
+ * What a `drawer` action target sets besides its component and texts, shared
+ * by the declared and the serialized target. A drawer opened on a row takes
+ * the row options of a side panel, so a detail panel moves from `sidePanel`
+ * to `drawer` without losing any of them.
+ */
+export interface DrawerTargetOptions extends Omit<SidePanelTargetOptions, "title" | "deepLink"> {
+    /**
+     * Width a `left` or `right` drawer opens at from `lg`, before the user
+     * resizes it: a modal's width at that size (`sm` 384px … `5xl` 1024px),
+     * `full` the whole window. Without one it opens at 600px. Capped to the window; below `lg` an
+     * unsized one is 440px wide, and on a phone every side drawer, sized or
+     * not, leaves a 2rem strip of backdrop (only `full` fills the screen).
+     * A `top` or `bottom` drawer ignores it.
+     */
+    size?: ModalSize;
+    /**
+     * The DMS draws the row header, as a side panel's: the title naming the
+     * open row (`rowTitle`), its position (`positionLabel`), previous and next
+     * buttons next to the close button. On when `rowTitle` or `positionLabel`
+     * is set; `false` leaves the header to the drawer's title, `true` draws it
+     * with the defaults. A drawer opened on no row, or on a selection, never
+     * draws it.
+     */
+    rowHeader?: boolean;
+    /**
+     * The open row is kept in the URL (`?record=<id>`), as the action's own
+     * `deepLink` does (which wins when set). Off by default for a drawer.
+     */
+    deepLink?: boolean;
+}
+/**
+ * A `download` action target: the file is fetched with the user's session and
+ * saved, the page left as it is.
+ */
+export interface DownloadActionTarget {
+    type: "download";
+    /**
+     * The file to fetch, with the user's session: takes the same
+     * `{{row.field}}` and page URL tokens (`{{params.X}}`, `{{query.X}}`) as a `page` target, a
+     * query pair whose token the page has no value for being left out.
+     * @example "/api/lang/translations/export?workspace={{query.workspace}}&locale={{query.locale}}"
+     */
+    url: string;
+    /**
+     * The saved file's name, same tokens (written as they are, not encoded).
+     * Else, or while a token is left without a value, the server's
+     * `Content-Disposition` name, else the URL's last path segment.
+     * @example "{{query.locale}}.json"
+     */
+    filename?: string;
+}
+export type ActionTarget = ({
+    /**
+     * A drawer: a modal sheet sliding in from an edge of the window. The
+     * container for a detail or record panel: from `lg` the user resizes it
+     * by its inner edge, and it opens again at that size. Opened on a row,
+     * it steps through the rows (J and K) and takes the row options of a
+     * side panel (see {@link DrawerTargetOptions}).
+     */
+    type: "drawer";
+    component: Component;
+    title?: string;
+    description?: string;
+    /**
+     * Edge the drawer slides in from (`bottom` by default). A `left` or
+     * `right` drawer is a side sheet spanning the window's height, 600px
+     * wide from `lg` unless `size` says otherwise.
+     */
+    direction?: DrawerDirection;
+} & DrawerTargetOptions) | {
+    type: "modal";
+    size?: ModalSize;
+    component: Component;
+    title?: string;
+    description?: string;
+} | ({
+    /**
+     * A non-modal panel docked on the right of the page, next to the table,
+     * which stays usable. Meant for global, page-independent panels (an
+     * assistant dock): a detail or record panel opens in a `drawer`, which
+     * takes the same row options. The DMS draws its header: the title, the row's
+     * position among all the rows the table lists ("3 of 87", past the
+     * page loaded), previous and next buttons (J and K too, turning the
+     * table's page past it) and a close button (Esc too). Its component receives the
+     * same props as a drawer's (`rowData`, `navigation`…), and is mounted
+     * anew on each row, its options' `{{row.X}}` tokens filled with that
+     * row (a `ResourceForm` reading `rowId: "{{row._id}}"`). A container
+     * block (a `Card` holding blocks) is drawn with its children, their
+     * options filled likewise, as in a drawer or a modal. One panel is open
+     * at a time: opening it closes a module's side panel, and the other way
+     * round.
+     */
+    type: "sidePanel";
+    component: Component;
+} & SidePanelTargetOptions) | {
+    type: "page";
+    /**
+     * The page to open. On a row action the row's fields fill
+     * `{{row.field}}`;
+     * `{{params.X}}` and `{{query.X}}` name the page the action sits on, a
+     * query pair whose token the page has no value for being left out.
+     */
+    url: string;
+} | {
+    type: "external";
+    /** Takes the same `{{row.field}}` and page URL tokens as `page`. */
+    url: string;
+    newTab?: boolean;
+} | DownloadActionTarget | {
+    type: "quickAction";
+    /**
+     * Key of the quick action to run: `category:id`, or the bare id when no
+     * other category uses it. The action is left out for users the quick
+     * action is not served to.
+     */
+    id: string;
+} | {
+    type: "api";
+    /** Takes the page URL tokens and `{{row.field}}`, as a `page` target. */
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    /**
+     * JSON body sent with the request. The values of the action's confirm
+     * `fields` are merged into it, the input winning.
+     */
+    body?: Record<string, unknown>;
+    /**
+     * Field of the JSON response copied to the clipboard on success (a
+     * share link, a token).
+     */
+    copy?: string;
+    successMessage: string;
+} | {
+    type: "exportJob";
+    /** Takes the page URL tokens and `{{row.field}}`, as a `page` target. */
+    url: string;
+    method?: "GET" | "POST";
+    /** As `url`, plus `{{job.id}}`: the id of the job the start answered. */
+    statusUrl?: string;
+    /** As `url`, plus `{{job.id}}`: the id of the job the start answered. */
+    downloadUrl?: string;
+    labels?: {
+        title?: string;
+        exporting?: string;
+        downloading?: string;
+        successTitle?: string;
+        successMessage?: string;
+        errorTitle?: string;
+        retry?: string;
+    };
+};
+export type ActionTargetSerialized = ({
+    /**
+     * A drawer: a modal sheet sliding in from an edge of the window. The
+     * container for a detail or record panel: from `lg` the user resizes it
+     * by its inner edge, and it opens again at that size. Opened on a row,
+     * it steps through the rows (J and K) and takes the row options of a
+     * side panel (see {@link DrawerTargetOptions}).
+     */
+    type: "drawer";
+    component: ComponentInfoSerialized;
+    title?: string;
+    description?: string;
+    /**
+     * Edge the drawer slides in from (`bottom` by default). A `left` or
+     * `right` drawer is a side sheet spanning the window's height, 600px
+     * wide from `lg` unless `size` says otherwise.
+     */
+    direction?: DrawerDirection;
+} & DrawerTargetOptions) | {
+    type: "modal";
+    size?: ModalSize;
+    component: ComponentInfoSerialized;
+    title?: string;
+    description?: string;
+} | ({
+    /**
+     * A non-modal panel docked on the right of the page, next to the table,
+     * which stays usable. Meant for global, page-independent panels (an
+     * assistant dock): a detail or record panel opens in a `drawer`, which
+     * takes the same row options. The DMS draws its header: the title, the row's
+     * position among all the rows the table lists ("3 of 87", past the
+     * page loaded), previous and next buttons (J and K too, turning the
+     * table's page past it) and a close button (Esc too). Its component receives the
+     * same props as a drawer's (`rowData`, `navigation`…), and is mounted
+     * anew on each row. One panel is open at a time: opening it closes a
+     * module's side panel, and the other way round.
+     */
+    type: "sidePanel";
+    component: ComponentInfoSerialized;
+} & SidePanelTargetOptions) | {
+    type: "page";
+    url: string;
+} | {
+    type: "external";
+    url: string;
+    newTab?: boolean;
+} | DownloadActionTarget | {
+    type: "quickAction";
+    /**
+     * Key of the quick action to run: `category:id`, or the bare id when no
+     * other category uses it. The action is left out for users the quick
+     * action is not served to.
+     */
+    id: string;
+} | {
+    type: "api";
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    /**
+     * JSON body sent with the request. The values of the action's confirm
+     * `fields` are merged into it, the input winning.
+     */
+    body?: Record<string, unknown>;
+    /**
+     * Field of the JSON response copied to the clipboard on success (a
+     * share link, a token).
+     */
+    copy?: string;
+    successMessage: string;
+} | {
+    type: "exportJob";
+    url: string;
+    method?: "GET" | "POST";
+    statusUrl?: string;
+    downloadUrl?: string;
+    labels?: {
+        title?: string;
+        exporting?: string;
+        downloading?: string;
+        successTitle?: string;
+        successMessage?: string;
+        errorTitle?: string;
+        retry?: string;
+    };
+};

package/dist/component-options/action-target.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=action-target.js.map

package/dist/component-options/action-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-target.js","sourceRoot":"","sources":["../../src/component-options/action-target.ts"],"names":[],"mappings":""}

package/dist/component-options/button.d.ts

@@ -0,0 +1,93 @@
+import type { ButtonPermission, ComponentFilterContext } from "../component";
+import type { MaybePromise } from "../types";
+import type { Tone } from "../tones";
+import type { ActionTarget, ActionTargetSerialized } from "./action-target";
+import type { ActionConfirm, ActionConfirmSerialized } from "./confirm-dialog";
+export declare enum ButtonVariant {
+    solid = "solid",
+    outline = "outline",
+    soft = "soft",
+    ghost = "ghost",
+    link = "link"
+}
+/** The `color` of a button or an action: one of the semantic tones. */
+export type ButtonColor = Tone;
+/** Where a table's button is drawn: its toolbar, or its page's header. */
+export type ButtonPlacement = "toolbar" | "header";
+/** Why a button cannot be pressed right now. */
+export interface CustomButtonUnavailability {
+    /**
+     * Shown next to the disabled button: what blocks it, and how to lift the
+     * block when the user can. A `$`-prefixed value resolves as an i18n key.
+     */
+    reason: string;
+}
+/**
+ * The button is left out of what a request is served, as if its permission
+ * were missing: for a button that makes no sense in the current scope (an
+ * "Add key" on a read-only workspace), where a disabled one would only be
+ * noise.
+ */
+export interface CustomButtonHidden {
+    hidden: true;
+}
+/**
+ * Decides, per request, whether a button can be pressed. Runs server-side
+ * while the page layout is filtered, so the button reaches the client already
+ * disabled, or not at all. Returning `undefined` leaves it enabled, `{ reason
+ * }` disables it with that reason, and `{ hidden: true }` leaves it out.
+ *
+ * In a page header, `context.query` holds the query of the page URL and
+ * `context.params` its route parameters (`:id`), and the header asks again
+ * whenever that query changes: a button can depend on the record `?id=` or
+ * `/:id` names, and hide itself when that record does not exist. A table's
+ * toolbar button gets neither.
+ *
+ * It only shapes the UI: whatever the button triggers must still refuse the
+ * operation on its own.
+ */
+export type CustomButtonAvailability = (context: ComponentFilterContext) => MaybePromise<CustomButtonUnavailability | CustomButtonHidden | undefined>;
+export interface CustomButton {
+    /**
+     * Names the button so a quick action can press it (`type: "button"`); the
+     * action then inherits the button's `permission`. Unique within its table.
+     */
+    id?: string;
+    label: string;
+    icon?: string;
+    variant?: ButtonVariant;
+    color?: ButtonColor;
+    target: ActionTarget;
+    /** Asked before the button's target runs: a fixed dialog, or `{ from }`. */
+    confirm?: ActionConfirm;
+    /**
+     * Gate the button behind a permission: one of the owning table's actions by
+     * name (e.g. `"add"`) — in a page header (`DefaultLayout({ headerActions
+     * })`), an action of the page, relative to its permission id — or an
+     * `Action` of any component (e.g. another table's `add`). The button is
+     * stripped from the served options when the caller lacks the permission.
+     */
+    permission?: ButtonPermission;
+    /** Absolute permission id the button requires; wins over `permission`. */
+    permissionId?: string;
+    /**
+     * Disables the button for a request it answers with a reason, or leaves it
+     * out for one it answers `{ hidden: true }`. A button the caller lacks the
+     * permission for is stripped before this runs.
+     */
+    availability?: CustomButtonAvailability;
+    /**
+     * Where the button is drawn: in the table's toolbar (the default), or in
+     * the header of the page carrying the table, which the server adds it to —
+     * the table still runs it. Either way a quick action can press it by `id`.
+     */
+    placement?: ButtonPlacement;
+}
+export interface CustomButtonSerialized extends Omit<CustomButton, "target" | "permission" | "permissionId" | "availability" | "confirm"> {
+    target: ActionTargetSerialized;
+    confirm?: ActionConfirmSerialized;
+    /** Set when the button's `availability` refused this request. */
+    disabled?: boolean;
+    /** The reason `availability` gave, shown next to the disabled button. */
+    disabledReason?: string;
+}

package/dist/component-options/button.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ButtonVariant = void 0;
+var ButtonVariant;
+(function (ButtonVariant) {
+    ButtonVariant["solid"] = "solid";
+    ButtonVariant["outline"] = "outline";
+    ButtonVariant["soft"] = "soft";
+    ButtonVariant["ghost"] = "ghost";
+    ButtonVariant["link"] = "link";
+})(ButtonVariant || (exports.ButtonVariant = ButtonVariant = {}));
+//# sourceMappingURL=button.js.map

package/dist/component-options/button.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"button.js","sourceRoot":"","sources":["../../src/component-options/button.ts"],"names":[],"mappings":";;;AAMA,IAAY,aAMX;AAND,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,oCAAmB,CAAA;IACnB,8BAAa,CAAA;IACb,gCAAe,CAAA;IACf,8BAAa,CAAA;AACf,CAAC,EANW,aAAa,6BAAb,aAAa,QAMxB"}

package/dist/component-options/confirm-dialog.d.ts

@@ -0,0 +1,132 @@
+import type { Component, ComponentInfoSerialized } from "../component";
+import type { ActionTarget } from "./action-target";
+import type { ButtonColor } from "./button";
+import type { FormField, FormFieldSerialized } from "./form-field";
+/** One dependent a confirmed action affects, listed in its dialog. */
+export interface ConfirmDialogImpact {
+    icon: string;
+    /** `$`-prefixed: an i18n key, receiving the dialog's `params`. */
+    label: string;
+    count?: number | string;
+}
+/**
+ * A file a dialog's secondary action downloads, the dialog staying open. The
+ * URL is fetched with the user's session, like an `api` target: a path is
+ * read from the DMS API, an absolute URL as it is.
+ */
+export interface ConfirmDialogDownloadTarget {
+    type: "download";
+    /**
+     * Takes the page URL tokens (`{{params.X}}`, `{{query.X}}`), then the
+     * dialog's parameters and the row's fields (`{{row.field}}`).
+     */
+    url: string;
+    /**
+     * Name the file is saved under, with the same tokens as `url`, written as
+     * they are. Defaults to the name the response's
+     * `Content-Disposition` gives, else the URL's last path segment.
+     */
+    filename?: string;
+}
+/**
+ * Where a dialog's secondary action leads: a link (`external`, as on an
+ * action), or a file to download.
+ */
+export type ConfirmDialogSecondaryTarget = Extract<ActionTarget, {
+    type: "external";
+}> | ConfirmDialogDownloadTarget;
+/**
+ * A button drawn next to cancel and confirm that neither answers the
+ * dialog: it runs its target and leaves the dialog open ("Download a backup"
+ * before removing).
+ */
+export interface ConfirmDialogSecondaryAction {
+    /** Text of the button, interpolated like the dialog's other texts. */
+    label: string;
+    icon?: string;
+    /**
+     * Its URL is filled in with the dialog's `params` and, on a row action,
+     * the row's fields (`{name}`).
+     */
+    target: ConfirmDialogSecondaryTarget;
+}
+/**
+ * The dialog an action asks in before it runs, the same for every action:
+ * built-in (delete, archive, edit…) and custom, whatever its target. Texts
+ * are i18n keys (with `$`) or literals, both interpolated with `params` —
+ * and, on a row action, with the row's fields ("Remove {name}?").
+ */
+export interface ConfirmDialog {
+    title: string;
+    description?: string;
+    /** Values the texts are interpolated with, besides the row's fields. */
+    params?: Record<string, unknown>;
+    /** Header icon. */
+    icon?: string;
+    /** Color of the confirm button and the header icon well. */
+    color?: ButtonColor;
+    /** Text of the confirm button. */
+    confirmLabel?: string;
+    /** Text of the cancel button. */
+    cancelLabel?: string;
+    /** What the action takes with it, listed above the buttons. */
+    impact?: ConfirmDialogImpact[];
+    /**
+     * A button next to cancel and confirm, leaving the dialog open: a link,
+     * or a file to download first.
+     */
+    secondaryAction?: ConfirmDialogSecondaryAction;
+    /**
+     * The action cannot run (the last owner, a locked row): the dialog only
+     * explains why, with a close button.
+     */
+    blocked?: boolean;
+    /**
+     * Text the user must type to confirm (type-to-confirm). A `$`-prefixed i18n
+     * key is translated, and `{field}` reads the row like the other texts
+     * (`"{name}"`: the row's name).
+     */
+    confirmText?: string;
+    /**
+     * Compares the typed text with `confirmText` ignoring case (`acme` matches
+     * `ACME`): for a name the user reads but would not care to retype exactly.
+     */
+    confirmTextCaseInsensitive?: boolean;
+    /**
+     * Fields the user fills in before confirming. Their values are sent with
+     * the action's request — merged into an `api` target's `body`, the input
+     * winning — and a field error the server answers shows under its field.
+     */
+    fields?: FormField[];
+    /**
+     * Escape hatch: a frontend component drawn in the dialog's body, resolved
+     * by name from the global registry.
+     */
+    component?: Component;
+}
+/**
+ * A confirmation the server words for the row an action targets: a URL
+ * answering a {@link ConfirmDialogSerialized}. On a row action, built-in or
+ * custom, `{{row.id}}` is filled in with the row's id (read through the
+ * table's `rowIdKey`) and `{{row.<field>}}` with any of the row's fields;
+ * a bulk custom action appends its selection to the query instead.
+ * The page URL's `{{params.X}}` / `{{query.X}}` are filled first, as in an
+ * action's target URL.
+ */
+export interface ConfirmDialogFrom {
+    from: string;
+}
+/** The confirmation of an action: a fixed dialog, or one the server words. */
+export type ActionConfirm = ConfirmDialog | ConfirmDialogFrom;
+/** A confirmation dialog as it reaches the client. */
+export interface ConfirmDialogSerialized extends Omit<ConfirmDialog, "fields" | "component"> {
+    fields?: FormFieldSerialized[];
+    component?: ComponentInfoSerialized;
+}
+/** The confirmation of an action as it reaches the client. */
+export type ActionConfirmSerialized = ConfirmDialogSerialized | ConfirmDialogFrom;
+/**
+ * A confirmation dialog as the client reads it: its fields and component
+ * serialized. A route answering a `confirm: { from }` request returns this.
+ */
+export declare function serializeConfirmDialog(dialog: ConfirmDialog): ConfirmDialogSerialized;

package/dist/component-options/confirm-dialog.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeConfirmDialog = serializeConfirmDialog;
+const form_field_1 = require("./internal/form-field");
+/**
+ * A confirmation dialog as the client reads it: its fields and component
+ * serialized. A route answering a `confirm: { from }` request returns this.
+ */
+function serializeConfirmDialog(dialog) {
+    const { fields, component, ...texts } = dialog;
+    const serialized = texts;
+    if (fields)
+        serialized.fields = fields.map(form_field_1.serializeFormField);
+    if (component)
+        serialized.component = component.serializeSync();
+    return serialized;
+}
+//# sourceMappingURL=confirm-dialog.js.map

package/dist/component-options/confirm-dialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirm-dialog.js","sourceRoot":"","sources":["../../src/component-options/confirm-dialog.ts"],"names":[],"mappings":";;AAoJA,wDAQC;AA3JD,sDAA2D;AA+I3D;;;GAGG;AACH,SAAgB,sBAAsB,CACpC,MAAqB;IAErB,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,KAAK,EAAE,GAAG,MAAM,CAAC;IAC/C,MAAM,UAAU,GAA4B,KAAK,CAAC;IAClD,IAAI,MAAM;QAAE,UAAU,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,+BAAkB,CAAC,CAAC;IAC/D,IAAI,SAAS;QAAE,UAAU,CAAC,SAAS,GAAG,SAAS,CAAC,aAAa,EAAE,CAAC;IAChE,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/component-options/data-type.d.ts

@@ -0,0 +1,101 @@
+import type { RequestContext } from "@antelopejs/interface-api";
+import { type Class, type ClassDecorator } from "@antelopejs/interface-core/decorators";
+import type { ValueProxy, ValueProxyOrValue } from "@antelopejs/interface-database";
+import type { ComponentInfoSerialized } from "../component";
+import type { z } from "zod";
+export type FilterComponent = ComponentInfoSerialized | "noInput";
+export interface DataCompareMode {
+    filter(context: RequestContext, proxy: ValueProxy<unknown>, key: string, value: unknown, row: ValueProxy<Record<string, unknown>>): ValueProxyOrValue<boolean>;
+}
+export declare abstract class DataType {
+    readonly compareModes: Class<DataCompareMode>[];
+    readonly defaultCompareMode?: Class<DataCompareMode> | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    constructor(compareModes?: Class<DataCompareMode>[], defaultCompareMode?: Class<DataCompareMode> | undefined, options?: Record<string, unknown> | undefined);
+    filter(context: RequestContext, proxy: ValueProxy<unknown>, key: string, value: string, mode: string, row: ValueProxy<Record<string, unknown>>): ValueProxyOrValue<boolean>;
+    /**
+     * Returns the default input component for this data type.
+     * Override this method in subclasses to provide a custom input component.
+     *
+     * @returns The default input component for this data type
+     */
+    protected abstract defaultInputComponent(): ComponentInfoSerialized;
+    /**
+     * Returns filters components for this data type.
+     * This component is used in filters for filtering values of this data type.
+     * Must include a 'default' component, and can optionally include
+     * mode-specific components for different compare modes.
+     * Override this method in subclasses for custom filter components per mode.
+     *
+     * @returns A record of filter components with at least a 'default' key
+     */
+    filterComponents(): Record<string, ComponentInfoSerialized> & {
+        default: ComponentInfoSerialized;
+    };
+    /**
+     * Returns the form input component for this data type.
+     * This component is used in forms for editing values of this data type.
+     *
+     * @returns The input component for this data type
+     */
+    inputComponent(): ComponentInfoSerialized;
+    /**
+     * The input component a value of this type is described with where
+     * nothing is entered through it: a table column's type, whose cells, cards
+     * and quick filters read its options, and a read-only form field. Defaults
+     * to {@link inputComponent}; a type whose input carries what only an
+     * editable control uses (a relation's inline "add" form) leaves it out, so
+     * a page does not ship it once per column.
+     *
+     * @returns The input component, without what only editing uses
+     */
+    describedInputComponent(): ComponentInfoSerialized;
+    /**
+     * Returns a Zod schema for validating values of this data type.
+     * This schema is used in the edit or new process in data-api to validate values
+     * before saving to the database.
+     *
+     * @returns A Zod schema for this data type
+     */
+    abstract getValidation(): z.ZodType;
+    /**
+     * Called to add additional decorators on the field using this data type.
+     *
+     * @param target Class prototype
+     * @param key Property name
+     * @param descriptor Property descriptor
+     */
+    decorateField?(target: unknown, key: PropertyKey, descriptor?: PropertyDescriptor): void;
+}
+/**
+ * Register a new data type
+ * @param id - The id of the data type
+ * @returns The data type class decorator
+ */
+export declare const RegisterDataType: (id: string) => ClassDecorator<Class<DataType>>;
+/**
+ * Register a new data compare mode
+ * @param id - The id of the data compare mode
+ * @param noInput - Whether this compare mode requires no input (default: false)
+ * @returns The data compare mode class decorator
+ */
+export declare const RegisterDataCompareMode: (id: string, noInput?: boolean) => ClassDecorator<Class<DataCompareMode>>;
+/**
+ * Create a new data type instance
+ * @param id - The id of the data type
+ * @param options - The options for the data type
+ * @returns The data type instance
+ */
+export declare function CreateDataType(id: string, options?: unknown): DataType;
+/**
+ * Get the ID of a DataType instance
+ */
+export declare function getDataTypeId(instance: DataType): string | undefined;
+export interface DataTypeSerialized {
+    id: string;
+    compareModes: string[];
+    defaultCompareMode?: string;
+    filterComponents: Record<string, FilterComponent>;
+    inputComponent: ComponentInfoSerialized;
+}
+export declare function serializeType(instance?: DataType): DataTypeSerialized | undefined;