@stndrds/schema 1.0.0-alpha.277 → 1.0.0-alpha.279

package/dist/index-C3P5Dnwt.d.mts

@@ -0,0 +1,790 @@
+import { z } from 'zod';
+import { A as Attribute, f as AttributeType, e as RollupAttribute } from './attributes--M1ifW8_.mjs';
+import { IconName } from '@stndrds/constants';
+import { L as ListViewTabVisibility } from './objects-DmMqHn3L.mjs';
+
+/** Operators for text-based attributes */
+type TextFilterOperator = "is" | "is_not" | "contains" | "not_contains" | "starts_with" | "ends_with" | "is_empty" | "is_not_empty";
+/** Operators for number-based attributes */
+type NumberFilterOperator = "is" | "is_not" | "less_than" | "greater_than" | "less_or_equal" | "greater_or_equal" | "is_empty" | "is_not_empty";
+/** Operators for checkbox — `is` with a boolean rule value (a checkbox always has a value) */
+type CheckboxFilterOperator = "is";
+/** Operators for date-based attributes (ordering shares the numeric vocabulary) */
+type DateFilterOperator = "is" | "is_not" | "less_than" | "greater_than" | "less_or_equal" | "greater_or_equal" | "is_within" | "on_day_month" | "is_empty" | "is_not_empty";
+/** Operators for select-based attributes (supports single or multi-value filtering) */
+type SelectFilterOperator = "is" | "is_not" | "any_of" | "none_of" | "is_empty" | "is_not_empty";
+/** Operators for multiselect-based attributes — set membership only */
+type MultiselectFilterOperator = "any_of" | "none_of" | "is_empty" | "is_not_empty";
+/**
+ * Operators for relation-based attributes (covers single, multi-value, and
+ * reference-shaped filtering — user, relation, document share the same
+ * edge-backed operator set). Membership is `any_of`/`none_of` only.
+ */
+type RelationFilterOperator = "is" | "is_not" | "any_of" | "none_of" | "is_empty" | "is_not_empty";
+/**
+ * All possible filter operators — the canonical set of 16.
+ * Short input codes (`lt`, `gte`, `eq`, `in`, …) are accepted at entry only
+ * and normalized via SYNONYM_ALIASES; they are never stored and never typed.
+ */
+type FilterOperator = TextFilterOperator | NumberFilterOperator | CheckboxFilterOperator | DateFilterOperator | SelectFilterOperator | MultiselectFilterOperator | RelationFilterOperator;
+/** Relative date value for "is_within" operator */
+interface RelativeDateValue {
+    amount: number;
+    unit: "days" | "weeks" | "months" | "years";
+    direction: "past" | "future";
+}
+/** Currency filter value with amount and optional currency codes
+ * - code: undefined or [] = any currency
+ * - code: string[] = filter by specific currencies
+ */
+interface CurrencyFilterValue {
+    value: number | null;
+    code?: string[];
+}
+/** Phone filter value with number and optional country code */
+interface PhoneFilterValue {
+    phoneNumber: string | null;
+    countryCode?: string;
+}
+/**
+ * A filter value resolved at query time from the execution context.
+ * Stored verbatim in a view's filter; replaced with a concrete value by the
+ * runtime before reaching any query layer. Discriminated by the `dynamic` key —
+ * no static FilterValue carries it.
+ */
+type DynamicValue = {
+    dynamic: "actor";
+    ref: "current";
+} | {
+    dynamic: "date";
+    anchor: "today";
+} | {
+    dynamic: "date";
+    anchor: "now";
+};
+/**
+ * The value `on_day_month` ("is on") takes: a calendar day without a year.
+ *
+ * Postgres matches it with `LIKE '%-MM-DD'` and Meili with `CONTAINS "-MM-DD"`,
+ * both reading these two members off the stored value, and the filter UI renders
+ * a dedicated input producing exactly this shape. It was the one operator whose
+ * value had no member in the union below, so the same shape had to be cast in
+ * at every site that used it (#2469).
+ */
+interface DayMonthValue {
+    month: number;
+    day: number;
+}
+/** Filter value can be various types depending on the attribute */
+type FilterValue = string | number | boolean | string[] | RelativeDateValue | CurrencyFilterValue | PhoneFilterValue | DayMonthValue | DynamicValue | null;
+/** Existence quantifier for qualified edge rules. Maps to SQL EXISTS / NOT EXISTS. */
+type EdgeQuantifier = "any" | "none";
+/** A single filter rule */
+interface FilterRule {
+    /** Root attribute name (scalar attribute, or a reference attribute when `property` is set). */
+    attribute: string;
+    /**
+     * If set, this rule filters on a qualified edge property.
+     * Requires `attribute` to be a reference attribute (today: `relation` or `document`) that has `.qualifyWith()`.
+     * The `operator` must be valid for the property's type, not the root attribute's type.
+     */
+    property?: string;
+    /**
+     * Existence quantifier for qualified edge rules ("at least one" vs "none").
+     * Only valid when `property` is set. Maps to SQL EXISTS / NOT EXISTS.
+     * Defaults to the operator-derived polarity when omitted.
+     */
+    quantifier?: EdgeQuantifier;
+    /** Filter operator */
+    operator: FilterOperator;
+    /** Filter value (null for operators like is_empty) */
+    value: FilterValue;
+}
+/**
+ * Extended filter rule with optional attribute definition.
+ * When provided, enables smarter type-aware filtering (e.g., array operators for multiselect).
+ */
+interface ExtendedFilterRule extends FilterRule {
+    /** Full attribute definition for type-aware filtering */
+    attributeDef?: Attribute;
+}
+/** Combinator for filter rules */
+type FilterCombinator = "and" | "or";
+/** Complete filter state (simple mode) */
+interface FilterState {
+    /** How to combine rules */
+    combinator: FilterCombinator;
+    /** List of filter rules */
+    rules: FilterRule[];
+}
+/**
+ * A filter group containing rules (used in advanced mode)
+ * Groups can be nested up to 2 levels deep
+ */
+interface FilterGroup {
+    /** Unique identifier for this group */
+    id: string;
+    /** How to combine rules within this group */
+    combinator: FilterCombinator;
+    /** List of filter rules in this group */
+    rules: FilterRule[];
+}
+/**
+ * Advanced filter state with nested groups
+ * Structure: AdvancedFilterState -> FilterGroup[] -> FilterRule[]
+ * Maximum 2 levels of nesting
+ */
+interface AdvancedFilterState {
+    /** How to combine groups at the top level */
+    combinator: FilterCombinator;
+    /** List of filter groups */
+    groups: FilterGroup[];
+}
+/** Sort direction */
+type SortDirection = "asc" | "desc";
+/** A single sort rule */
+interface SortRule {
+    /** Attribute name to sort by */
+    attribute: string;
+    /** Sort direction */
+    direction: SortDirection;
+}
+/** Complete query state with search, filters, sorts, and pagination */
+interface QueryState {
+    /** Full-text search query */
+    search?: string;
+    /** Filter configuration (simple mode) */
+    filters?: FilterState;
+    /** Advanced filter configuration (grouped mode) */
+    advancedFilters?: AdvancedFilterState;
+    /** Sort configuration (multiple sorts supported) */
+    sorts?: SortRule[];
+    /** Pagination */
+    limit?: number;
+    offset?: number;
+}
+/** Mapping of attribute types to their valid operators (rollup excluded — use getRollupFilterOperators()) */
+declare const OPERATORS_BY_TYPE: Record<Exclude<AttributeType, "rollup">, readonly FilterOperator[]>;
+/** Check if an operator requires a value */
+type NoValueOperator = "is_empty" | "is_not_empty";
+/** Operators that don't require a value */
+declare const NO_VALUE_OPERATORS: readonly NoValueOperator[];
+/**
+ * Check if an operator requires a value
+ */
+declare function isNoValueOperator(operator: FilterOperator): operator is NoValueOperator;
+/**
+ * Get the filter operators for a rollup attribute based on its aggregation function and target type.
+ *
+ * - earliest / latest → date operators
+ * - original → operators matching targetAttributeType (falls back to numeric if unknown)
+ * - all other functions → numeric operators (sum, avg, count, percent, etc.)
+ */
+declare function getRollupFilterOperators(attr: RollupAttribute): readonly FilterOperator[];
+
+/**
+ * Type of view - determines the config structure
+ */
+type ViewType = "detail" | "list";
+/**
+ * Creation behavior when clicking the "+" button
+ * - `redirect`: Create the record then navigate to its detail page
+ * - `inline`: Insert an empty row in the table (no navigation)
+ * - `peek`: Create a draft immediately and open it in the record stack side panel
+ */
+type CreateMode = "redirect" | "inline" | "peek";
+/**
+ * Inline attribute group configuration
+ * Groups multiple attributes into a single composite field with dropdown editing
+ */
+interface AttributeGroupField {
+    /** Unique identifier for the group */
+    id: string;
+    /** Display label for the composite field */
+    label: string;
+    /** Description shown in the dropdown */
+    description?: string;
+    /** Attribute names to include in this group */
+    attributes: string[];
+    /**
+     * Template for the display value
+     * Uses {attributeName} syntax for interpolation
+     * @example "{billing_street}, {billing_city} {billing_postal_code}"
+     */
+    displayTemplate?: string;
+}
+/**
+ * Field definition within a form group
+ * Can be either a single attribute or an inline attribute group
+ */
+interface Field {
+    /** Attribute name to display (for single attribute fields) */
+    attribute?: string;
+    /** Inline attribute group (groups multiple attributes into one composite field) */
+    attributeGroup?: AttributeGroupField;
+    /** Grid span (1-12 columns) */
+    span?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    /** Override label for this view (only for single attribute fields) */
+    label?: string;
+    /** Force read-only display */
+    readOnly?: boolean;
+}
+/**
+ * Base properties shared by all group types
+ */
+interface BaseGroup {
+    id: string;
+    label: string;
+    description?: string;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+}
+/**
+ * Group of fields for organizing forms (default group type)
+ */
+interface FieldGroup extends BaseGroup {
+    /** Discriminant */
+    type: "fields";
+    fields: Field[];
+}
+/**
+ * Group that displays related records for a relation attribute
+ */
+interface RelationGroup extends BaseGroup {
+    type: "relation";
+    /** Relation attribute name on the source object */
+    attribute: string;
+    /** Columns to display (auto-detected from target object if empty) */
+    columns?: string[];
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Allow creating new related records */
+    allowCreate?: boolean;
+}
+/**
+ * Discriminated union of all group types
+ */
+type Group = FieldGroup | RelationGroup;
+type TabType = "form" | "table" | "custom" | "activity" | "richtext" | "documents" | "forms" | "emails" | "meetings";
+/**
+ * Base properties shared by all tab types
+ */
+interface BaseTab {
+    id: string;
+    name: string;
+    label: string;
+    icon?: IconName;
+    order?: number;
+}
+/**
+ * Form layout density
+ */
+type FormDensity = "compact" | "comfortable" | "spacious";
+/**
+ * Form tab - displays attributes organized in groups
+ */
+interface FormTab extends BaseTab {
+    type: "form";
+    groups: Group[];
+    /** Number of grid columns (1, 2, or 3). Default: 2 */
+    formColumns?: 1 | 2 | 3;
+    /** Layout density. Default: "comfortable" */
+    density?: FormDensity;
+}
+/**
+ * Direct relation on the current object
+ *
+ * @example Contact.companies → shows Companies linked via the "companies" relation
+ */
+interface RelationSource {
+    type: "relation";
+    /** Relation attribute name on the current object */
+    attribute: string;
+}
+/**
+ * Inverse lookup — records from another object that point to us
+ *
+ * @example On Company, show Contacts where Contact.company = this Company
+ */
+interface InverseSource {
+    type: "inverse";
+    /** Object name that has the relation to us */
+    object: string;
+    /** Relation attribute name on the source object that points to us */
+    attribute: string;
+}
+/**
+ * Where table data comes from — either a direct relation or an inverse lookup
+ */
+type TableSource = RelationSource | InverseSource;
+/**
+ * Table tab - displays related records in a table
+ *
+ * The `source` field determines where data comes from.
+ *
+ * @example Direct: source = { type: "relation", attribute: "members" }
+ * @example Inverse: source = { type: "inverse", object: "contacts", attribute: "company" }
+ */
+interface TableTab extends BaseTab {
+    type: "table";
+    /** Where the data comes from */
+    source: TableSource;
+    /** Columns to display (attribute names from the resolved target object) */
+    columns: string[];
+    /** Allow creating new records */
+    allowCreate?: boolean;
+    /** Creation behavior when allowCreate is true. Default: "redirect" */
+    createMode?: CreateMode;
+    /** Allow inline editing */
+    allowEdit?: boolean;
+    /** Allow deleting records */
+    allowDelete?: boolean;
+    /** Default filters applied to the table */
+    filters?: FilterState;
+    /** Default sort rules */
+    sorts?: SortRule[];
+}
+/**
+ * Custom tab - renders a developer-defined component
+ */
+interface CustomTab extends BaseTab {
+    type: "custom";
+    /** Component identifier to render */
+    component: string;
+    /** Props to pass to the component */
+    props?: Record<string, unknown>;
+}
+/**
+ * Activity tab - displays activity feed for the current record
+ */
+interface ActivityTab extends BaseTab {
+    type: "activity";
+    limit?: number;
+}
+/**
+ * Richtext tab - displays a block editor for a richtext attribute
+ */
+interface RichtextTab extends BaseTab {
+    type: "richtext";
+    /** Richtext attribute to display in the BlockEditor */
+    attribute: string;
+    /** Optional text attribute for an editable title input above the editor */
+    titleAttribute?: string;
+}
+/**
+ * Documents tab - displays all documents attached to the record
+ */
+interface DocumentsTab extends BaseTab {
+    type: "documents";
+    allowUpload?: boolean;
+    allowRemove?: boolean;
+    hideAttachments?: boolean;
+}
+/**
+ * Forms tab - displays available forms for creating related records
+ */
+interface FormsTab extends BaseTab {
+    type: "forms";
+    /** Object name to filter forms by slot (derived from record context, but can be overridden) */
+    objectName?: string;
+}
+/**
+ * Emails tab - displays emails associated with the record at query time via the
+ * values of configured email-bearing text attributes. Config-only: no schema change.
+ */
+interface EmailsTab extends BaseTab {
+    type: "emails";
+    /** Names of text attributes whose values hold email addresses to match on. */
+    emailAttributeIds: string[];
+}
+/**
+ * Meetings tab - displays calendar meetings associated with the record at query
+ * time via the values of configured email-bearing text attributes. Config-only:
+ * no schema change. Carries the same configuration as {@link EmailsTab} because
+ * both answer "which attributes hold this record's addresses".
+ */
+interface MeetingsTab extends BaseTab {
+    type: "meetings";
+    /** Names of text attributes whose values hold email addresses to match on. */
+    emailAttributeIds: string[];
+}
+/**
+ * Union of all tab types (for detail views)
+ */
+type Tab = FormTab | TableTab | CustomTab | ActivityTab | RichtextTab | DocumentsTab | FormsTab | EmailsTab | MeetingsTab;
+/**
+ * List view layout mode
+ * - `table`: Table/grid layout
+ * - `kanban`: Kanban board layout (grouped by attribute)
+ */
+type ListViewLayout = "table" | "kanban";
+/**
+ * Tab within a list view — each tab carries its own full display configuration.
+ *
+ * @example
+ * ```typescript
+ * const tabs: ListViewTab[] = [
+ *   { id: "all", label: "All Contacts", default: true, visibility: "workspace", layout: "table", columns: ["name", "email", "status"] },
+ *   { id: "active", label: "Active", visibility: "workspace", layout: "table", columns: ["name", "email"], filters: activeFilter },
+ *   { id: "pipeline", label: "Pipeline", visibility: "workspace", layout: "kanban", columns: ["name", "amount"], groupByAttribute: "stage" },
+ * ];
+ * ```
+ */
+interface ListViewTab {
+    /** Unique identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Icon */
+    icon?: IconName;
+    /** Default tab (shown on load) */
+    default?: boolean;
+    /**
+     * Record scope this tab reads. `all` (the default) imposes no scope, so the
+     * tab shows every workspace record plus the viewer's own private ones;
+     * `workspace` and `private` narrow it to exactly one.
+     */
+    visibility: ListViewTabVisibility;
+    /** Layout mode */
+    layout: ListViewLayout;
+    /** Attribute names to display as columns */
+    columns: string[];
+    /** Column widths in pixels */
+    columnSizing?: Record<string, number>;
+    /** Filters applied to this tab */
+    filters?: FilterGroup;
+    /** Sort rules for this tab */
+    sorts?: SortRule[];
+    /** Attribute to group by (required when layout is "kanban") */
+    groupByAttribute?: string;
+    /** When true, the tab is read-only: no cell editing, no create, no delete */
+    readOnly?: boolean;
+    /** Creation behavior when clicking "+". Default: "redirect" */
+    createMode?: CreateMode;
+    /** User attribute to display on kanban cards (bottom-left) */
+    cardUserAttribute?: string;
+    /** Date attribute to display on kanban cards (bottom-right) */
+    cardDateAttribute?: string;
+    /** Order of kanban columns (by option value) - for kanban layout only */
+    kanbanColumnOrder?: string[];
+    /** Visibility of kanban columns (by option value) - for kanban layout only */
+    kanbanColumnVisibility?: Record<string, boolean>;
+    /** Pinned kanban columns (by option value) - for kanban layout only */
+    kanbanPinnedColumns?: string[];
+}
+/**
+ * Configuration for the side panel displayed alongside tab content.
+ * When present, a right-side panel shows the configured attributes as flat fields.
+ */
+interface SidePanelConfig {
+    /** Attribute names to display as flat fields in the panel */
+    attributes: string[];
+    /** Width in pixels. @default 320 */
+    width?: number;
+}
+/**
+ * Configuration for detail views (RecordEditView)
+ */
+interface DetailViewConfig {
+    /** Tabs in this view */
+    tabs: Tab[];
+    /** Optional side panel with flat attribute fields */
+    sidePanel?: SidePanelConfig;
+}
+/**
+ * Configuration for list views (RecordsView)
+ *
+ * Each tab carries its own full config (layout, columns, filters, sorts, groupBy).
+ * The view only holds shared base filters applied to ALL tabs.
+ */
+interface ListViewConfig {
+    /** Base filters applied to ALL tabs (scoping, tenant, etc.) */
+    defaultFilters?: FilterGroup;
+    /** Tabs — at least one required. Each carries its own full config. */
+    tabs: ListViewTab[];
+}
+/**
+ * Union of all view configs
+ */
+type ViewConfig = DetailViewConfig | ListViewConfig;
+/**
+ * Base view properties shared by all view types
+ */
+interface BaseViewDefinition {
+    /** Unique identifier (UUID, assigned by database) */
+    id?: string;
+    /** Technical name (kebab-case) */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Description */
+    description?: string;
+    /** Icon */
+    icon?: IconName;
+    /** Object this view belongs to (object name) */
+    object: string;
+    /** Default view for this object+type combination */
+    default?: boolean;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Detail view definition
+ */
+interface DetailViewDefinition extends BaseViewDefinition {
+    type: "detail";
+    config: DetailViewConfig;
+}
+/**
+ * List view definition
+ */
+interface ListViewDefinition extends BaseViewDefinition {
+    type: "list";
+    config: ListViewConfig;
+}
+/**
+ * Unified view definition - discriminated union by type
+ */
+type ViewDefinition = DetailViewDefinition | ListViewDefinition;
+/**
+ * Configuration overrides for user customizations
+ * Only stores the delta from the source view
+ */
+interface ConfigOverrides {
+    tabs?: ListViewTab[];
+    hiddenTabIds?: string[];
+    detailTabs?: Tab[];
+    hiddenDetailTabIds?: string[];
+}
+/**
+ * User customization overlay for a view
+ * Stored per user, merged at runtime with the source view
+ */
+interface ViewOverlay {
+    /** Unique identifier */
+    id: string;
+    /** View ID this overlay applies to (UUID or virtual ID) */
+    viewId: string;
+    /** User ID who owns this overlay */
+    userId: string;
+    /** Configuration overrides (delta only) */
+    configOverrides: ConfigOverrides;
+    /** User's default view for this object (stored in overlay) */
+    isUserDefault?: boolean;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Updated timestamp */
+    updatedAt: Date;
+}
+/**
+ * Check if a view is a detail view
+ */
+declare function isDetailView(view: ViewDefinition): view is DetailViewDefinition;
+/**
+ * Check if a view is a list view
+ */
+declare function isListView(view: ViewDefinition): view is ListViewDefinition;
+/**
+ * Check if a group is a field group (default type)
+ */
+declare function isFieldGroup(group: Group): group is FieldGroup;
+/**
+ * Check if a group is a relation group
+ */
+declare function isRelationGroup(group: Group): group is RelationGroup;
+
+interface AddAttributeInput {
+    name: string;
+    label: string;
+    type: AttributeType;
+    required?: boolean;
+    unique?: boolean;
+    description?: string;
+    placeholder?: string;
+    icon?: IconName;
+    defaultValue?: unknown;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface CreateCustomObjectInput {
+    name: string;
+    label: string;
+    pluralLabel?: string;
+    labelExpression: string;
+    embeddingExpression?: string;
+    description?: string;
+    icon?: IconName;
+    attributes?: (Attribute | {
+        build: () => Attribute;
+    })[];
+    metadata?: Record<string, unknown>;
+}
+interface UpdateObjectInput {
+    label?: string;
+    pluralLabel?: string;
+    description?: string;
+    icon?: IconName;
+    labelExpression?: string;
+    embeddingExpression?: string;
+    metadata?: Record<string, unknown>;
+}
+interface CreateViewInput {
+    objectName: string;
+    type: ViewType;
+    name: string;
+    label: string;
+    description?: string;
+    icon?: IconName;
+    config: ViewConfig;
+    default?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateViewInput {
+    label?: string;
+    description?: string;
+    icon?: IconName;
+    config?: ViewConfig;
+    default?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface RelationOption {
+    id: string;
+    objectId: string;
+    objectName: string;
+    objectLabel: string;
+    objectIcon?: string;
+    label: string;
+}
+interface RelationOptionsResponse {
+    options: RelationOption[];
+    hasMore: boolean;
+    total: number;
+    nextOffset?: number;
+}
+
+declare const statusGroupSchema: z.ZodEnum<{
+    idle: "idle";
+    in_progress: "in_progress";
+    finished: "finished";
+}>;
+declare const selectOptionWriteSchema: z.ZodObject<{
+    value: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    color: z.ZodEnum<{
+        gray: "gray";
+        slate: "slate";
+        blue: "blue";
+        sky: "sky";
+        indigo: "indigo";
+        green: "green";
+        emerald: "emerald";
+        teal: "teal";
+        red: "red";
+        rose: "rose";
+        yellow: "yellow";
+        amber: "amber";
+        orange: "orange";
+        purple: "purple";
+        violet: "violet";
+        fuchsia: "fuchsia";
+        pink: "pink";
+        cyan: "cyan";
+        lime: "lime";
+    }>;
+}, z.core.$strict>;
+declare const multiselectOptionWriteSchema: z.ZodObject<{
+    value: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    color: z.ZodEnum<{
+        gray: "gray";
+        slate: "slate";
+        blue: "blue";
+        sky: "sky";
+        indigo: "indigo";
+        green: "green";
+        emerald: "emerald";
+        teal: "teal";
+        red: "red";
+        rose: "rose";
+        yellow: "yellow";
+        amber: "amber";
+        orange: "orange";
+        purple: "purple";
+        violet: "violet";
+        fuchsia: "fuchsia";
+        pink: "pink";
+        cyan: "cyan";
+        lime: "lime";
+    }>;
+}, z.core.$strict>;
+declare const statusOptionWriteSchema: z.ZodObject<{
+    value: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inverse: z.ZodOptional<z.ZodString>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+    color: z.ZodEnum<{
+        gray: "gray";
+        slate: "slate";
+        blue: "blue";
+        sky: "sky";
+        indigo: "indigo";
+        green: "green";
+        emerald: "emerald";
+        teal: "teal";
+        red: "red";
+        rose: "rose";
+        yellow: "yellow";
+        amber: "amber";
+        orange: "orange";
+        purple: "purple";
+        violet: "violet";
+        fuchsia: "fuchsia";
+        pink: "pink";
+        cyan: "cyan";
+        lime: "lime";
+    }>;
+    group: z.ZodEnum<{
+        idle: "idle";
+        in_progress: "in_progress";
+        finished: "finished";
+    }>;
+}, z.core.$strict>;
+/**
+ * Map of attribute type to config schema
+ */
+declare const attributeConfigSchemas: Record<AttributeType, z.ZodObject<z.ZodRawShape>>;
+/**
+ * Get the config schema for a specific attribute type
+ */
+declare function getAttributeConfigSchema(type: AttributeType): z.ZodObject<z.ZodRawShape>;
+/**
+ * Validate and strip unknown properties from attribute config
+ * This ensures only allowed properties are stored in the database
+ */
+declare function parseAttributeConfig(type: AttributeType, config: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Strict parser for newly created attribute definitions.
+ *
+ * Top-level config remains strip-compatible with the historical config
+ * contract, while newly written icons and select-like option objects are
+ * validated strictly.
+ */
+declare function parseAttributeConfigForCreate(type: AttributeType, input: unknown): Record<string, unknown>;
+/**
+ * Patch-aware parser for persisted attributes.
+ *
+ * An explicit options patch owns and strictly validates the complete new
+ * list. Omission means the stored legacy list is preserved without
+ * reconstruction, including options that predate required colours/groups.
+ */
+declare function parseAttributeConfigForUpdate(stored: Attribute, patch: Partial<AddAttributeInput>): Record<string, unknown>;
+
+export { type RichtextTab as $, type AttributeGroupField as A, type FilterCombinator as B, type ConfigOverrides as C, type DetailViewConfig as D, type EmailsTab as E, type FilterState as F, type Group as G, type FilterGroup as H, type FormDensity as I, type FormTab as J, type FormsTab as K, type ListViewConfig as L, type MeetingsTab as M, type InverseSource as N, type ListViewLayout as O, NO_VALUE_OPERATORS as P, type NoValueOperator as Q, type RelationGroup as R, type SortRule as S, type TableTab as T, OPERATORS_BY_TYPE as U, type ViewType as V, type PhoneFilterValue as W, type QueryState as X, type RelationOption as Y, type RelationOptionsResponse as Z, type RelationSource as _, type ViewConfig as a, type SortDirection as a0, type TabType as a1, type TableSource as a2, type UpdateObjectInput as a3, type UpdateViewInput as a4, type ViewOverlay as a5, getRollupFilterOperators as a6, isDetailView as a7, isFieldGroup as a8, isListView as a9, isNoValueOperator as aa, isRelationGroup as ab, multiselectOptionWriteSchema as ac, parseAttributeConfig as ad, parseAttributeConfigForCreate as ae, parseAttributeConfigForUpdate as af, selectOptionWriteSchema as ag, statusGroupSchema as ah, statusOptionWriteSchema as ai, attributeConfigSchemas as aj, getAttributeConfigSchema as ak, type FilterOperator as b, type DetailViewDefinition as c, type SidePanelConfig as d, type Field as e, type FieldGroup as f, type CreateMode as g, type Tab as h, type ListViewDefinition as i, type ViewDefinition as j, type ListViewTab as k, type FilterValue as l, type FilterRule as m, type DynamicValue as n, type RelativeDateValue as o, type ActivityTab as p, type AddAttributeInput as q, type AdvancedFilterState as r, type CreateCustomObjectInput as s, type CreateViewInput as t, type CurrencyFilterValue as u, type CustomTab as v, type DayMonthValue as w, type DocumentsTab as x, type EdgeQuantifier as y, type ExtendedFilterRule as z };