@dinoxx/dinox-cli 2.1.1 → 2.3.0

package/dist/vendor/electron/rpc.d.ts

@@ -0,0 +1,22 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { z } from 'zod';
+import type { PowerSyncCommandRunResponse } from './shared/index.js';
+export type SqlExecutor = {
+    execute(sql: string, params?: unknown[]): Promise<unknown>;
+    getAll<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+    getOptional<T = unknown>(sql: string, params?: unknown[]): Promise<T | null | undefined>;
+};
+export type ReadModelDefinition<TInput = any, TRow = unknown> = {
+    readonly name: string;
+    readonly inputSchema: z.ZodType<TInput>;
+    readonly fetch: (db: AbstractPowerSyncDatabase, input: TInput) => Promise<TRow[]>;
+    readonly tables: (input: TInput) => string[];
+};
+export type CommandDefinition<TInput = any, TResult = unknown> = {
+    readonly name: string;
+    readonly inputSchema: z.ZodType<TInput>;
+    readonly run: (db: AbstractPowerSyncDatabase, input: TInput) => Promise<PowerSyncCommandRunResponse<TResult>>;
+};
+export declare function defineReadModel<TInput, TRow>(definition: ReadModelDefinition<TInput, TRow>): ReadModelDefinition<TInput, TRow>;
+export declare function defineCommand<TInput, TResult>(definition: CommandDefinition<TInput, TResult>): CommandDefinition<TInput, TResult>;
+export declare function rowsFromResult(result: unknown): Array<Record<string, unknown>>;

package/dist/vendor/electron/rpc.js

@@ -0,0 +1,27 @@
+export function defineReadModel(definition) {
+    return definition;
+}
+export function defineCommand(definition) {
+    return definition;
+}
+// Mirrors desktop PowerSyncTransportUtils.rowsFromResult.
+export function rowsFromResult(result) {
+    if (!result)
+        return [];
+    if (Array.isArray(result))
+        return result;
+    const value = result;
+    if (value.rows?._array)
+        return value.rows._array;
+    const rows = value.rows;
+    if (rows && typeof rows.length === 'number' && typeof rows.item === 'function') {
+        const item = rows.item;
+        const values = [];
+        for (let index = 0; index < rows.length; index += 1)
+            values.push(item.call(rows, index));
+        return values;
+    }
+    if (value.value !== undefined)
+        return value.value;
+    return [result];
+}

package/dist/vendor/electron/shared/ai-errors.d.ts

@@ -0,0 +1,11 @@
+export declare const AI_ERROR_CODE_AUTH_REQUIRED = "AUTH_REQUIRED";
+export declare const AI_ERROR_CODE_FORBIDDEN = "FORBIDDEN";
+export declare const AI_ERROR_CODE_SESSION_CHANGED = "SESSION_CHANGED";
+export declare const AI_ERROR_CODE_INSUFFICIENT_POINTS = "INSUFFICIENT_POINTS";
+export declare const AI_ERROR_CODE_INVALID_STRUCTURED_OUTPUT = "INVALID_STRUCTURED_OUTPUT";
+export type AiErrorCode = typeof AI_ERROR_CODE_AUTH_REQUIRED | typeof AI_ERROR_CODE_FORBIDDEN | typeof AI_ERROR_CODE_SESSION_CHANGED | typeof AI_ERROR_CODE_INSUFFICIENT_POINTS | typeof AI_ERROR_CODE_INVALID_STRUCTURED_OUTPUT;
+export type AgentOperationErrorKind = 'aborted' | 'auth' | 'rate_limit' | 'context_overflow' | 'transient_transport' | 'invalid_tool_input' | 'unknown_effect' | 'provider' | 'tool' | 'internal';
+export declare function isContextOverflowErrorMessage(message: string, options?: {
+    provider?: string | null;
+}): boolean;
+export declare function classifyAgentOperationError(error: unknown, fallback?: Extract<AgentOperationErrorKind, 'provider' | 'tool' | 'internal'>): AgentOperationErrorKind;

package/dist/vendor/electron/shared/ai-errors.js

@@ -0,0 +1,107 @@
+// Generated by scripts/sync-electron-domain.ts from dinox-electron/packages/shared/src/ai-errors.ts. Do not edit manually.
+export const AI_ERROR_CODE_AUTH_REQUIRED = 'AUTH_REQUIRED';
+export const AI_ERROR_CODE_FORBIDDEN = 'FORBIDDEN';
+export const AI_ERROR_CODE_SESSION_CHANGED = 'SESSION_CHANGED';
+export const AI_ERROR_CODE_INSUFFICIENT_POINTS = 'INSUFFICIENT_POINTS';
+export const AI_ERROR_CODE_INVALID_STRUCTURED_OUTPUT = 'INVALID_STRUCTURED_OUTPUT';
+// Mirrors pi-ai 1.0 `utils/overflow.ts` OVERFLOW_PATTERNS; re-diff on pi upgrades.
+const CONTEXT_OVERFLOW_ERROR_PATTERNS = [
+    /prompt (?:is )?too long/i,
+    /prompt exceeds max length/i,
+    /request_too_large/i,
+    /input is too long for requested model/i,
+    /exceeds the context window/i,
+    /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
+    /input token count.*exceeds the maximum/i,
+    /maximum prompt length is \d+/i,
+    /reduce the length of the messages/i,
+    /maximum context length is \d+ tokens/i,
+    /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+    /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+    /exceeds the limit of \d+/i,
+    /exceeds the available context size/i,
+    /greater than the context length/i,
+    /context window exceeds limit/i,
+    /exceeded model token limit/i,
+    /too large for model with \d+ maximum context length/i,
+    /model_context_window_exceeded/i,
+    /prompt too long; exceeded (?:max )?context length/i,
+    /range of input length should be/i,
+    /context[_ ]length[_ ]exceeded/i,
+    /too many tokens/i,
+    /token limit exceeded/i,
+];
+// Cerebras reports overflow as a bodyless 400/413. Other providers send the same
+// shape for unrelated failures, so it only counts for Cerebras (pi-ai 0.86).
+const CEREBRAS_BODYLESS_OVERFLOW_PATTERN = /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i;
+const NON_CONTEXT_OVERFLOW_ERROR_PATTERNS = [
+    /^(Throttling error|Service unavailable):/i,
+    /rate limit/i,
+    /too many requests/i,
+];
+export function isContextOverflowErrorMessage(message, options = {}) {
+    if (!message.trim()) {
+        return false;
+    }
+    if (NON_CONTEXT_OVERFLOW_ERROR_PATTERNS.some((pattern) => pattern.test(message))) {
+        return false;
+    }
+    if (CONTEXT_OVERFLOW_ERROR_PATTERNS.some((pattern) => pattern.test(message))) {
+        return true;
+    }
+    return Boolean(options.provider?.toLowerCase().includes('cerebras'))
+        && CEREBRAS_BODYLESS_OVERFLOW_PATTERN.test(message);
+}
+export function classifyAgentOperationError(error, fallback = 'internal') {
+    const record = error && typeof error === 'object' && !Array.isArray(error)
+        ? error
+        : null;
+    const status = readErrorStatus(record);
+    const message = collectErrorText(error).toLowerCase();
+    if (record?.name === 'AbortError' || /\b(abort(?:ed)?|cancelled|canceled)\b|已中断/.test(message)) {
+        return 'aborted';
+    }
+    if (status === 401 || status === 403 || /\b(unauthorized|forbidden|invalid api key|authentication)\b|登录|鉴权/.test(message)) {
+        return 'auth';
+    }
+    if (status === 429 || /\b(rate.?limit|too many requests|quota exceeded)\b|限流/.test(message)) {
+        return 'rate_limit';
+    }
+    if (/context.{0,16}(length|window|limit)|maximum context|too many tokens|上下文.{0,8}(超|过长)/.test(message)) {
+        return 'context_overflow';
+    }
+    if (/invalid.{0,12}(tool|argument|input)|tool.{0,12}(schema|validation)|工具.{0,8}(参数|输入).{0,8}(无效|错误)/.test(message)) {
+        return 'invalid_tool_input';
+    }
+    if (/unknown.?effect|副作用.{0,8}(未知|不确定)/.test(message)) {
+        return 'unknown_effect';
+    }
+    if ((status != null && status >= 500)
+        || /\b(timeout|timed out|econnreset|econnrefused|enotfound|network|socket|fetch failed|service unavailable|bad gateway)\b/.test(message)) {
+        return 'transient_transport';
+    }
+    return fallback;
+}
+function readErrorStatus(record) {
+    if (!record)
+        return null;
+    for (const key of ['status', 'statusCode', 'httpStatus']) {
+        const value = record[key];
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+    }
+    return null;
+}
+function collectErrorText(error) {
+    if (error instanceof Error) {
+        return `${error.name} ${error.message} ${error.cause ? collectErrorText(error.cause) : ''}`;
+    }
+    if (typeof error === 'string')
+        return error;
+    if (!error || typeof error !== 'object')
+        return String(error ?? '');
+    const record = error;
+    return [record.name, record.message, record.code, record.error]
+        .filter((value) => typeof value === 'string')
+        .join(' ');
+}

package/dist/vendor/electron/shared/external-types.d.ts

@@ -0,0 +1,2 @@
+export type ChatMessageAnchorFields = Record<string, unknown>;
+export type SystemAgentKey = string;

package/dist/vendor/electron/shared/external-types.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/electron/shared/index.d.ts

@@ -0,0 +1,9 @@
+export * from './ai-errors.js';
+export * from './note-properties.js';
+export * from './saved-views.js';
+export * from './note-templates.js';
+export * from './powersync-read-models.js';
+export type PowerSyncCommandRunResponse<T = unknown> = {
+    result: T;
+    affectedTables: string[];
+};

package/dist/vendor/electron/shared/index.js

@@ -0,0 +1,7 @@
+// Hand-written barrel standing in for desktop's `@app/shared` package entry. Only the
+// vendored modules are re-exported; everything else stays desktop-only.
+export * from './ai-errors.js';
+export * from './note-properties.js';
+export * from './saved-views.js';
+export * from './note-templates.js';
+export * from './powersync-read-models.js';

package/dist/vendor/electron/shared/note-properties.d.ts

@@ -0,0 +1,312 @@
+/**
+ * Note Properties domain types + pure helpers.
+ *
+ * Property values live on `c_note.properties` as a JSON map (key -> value), while
+ * `c_property_def` provides the account-owned semantic catalog (key/name/type/
+ * options). Unknown keys remain readable and degrade to untyped text.
+ *
+ * This module is pure (no DB, no React) so it can be shared by the main-process
+ * command handlers and the renderer UI.
+ */
+/**
+ * Shape of the note's properties JSON: key -> raw value. Arrays are allowed
+ * (multi-value); the type semantics come from the c_property_def catalog.
+ */
+export interface FilePropertyRef {
+    resourceId: string;
+    path?: string;
+}
+export interface PlacePropertyValue {
+    lat: number;
+    lon: number;
+    name?: string;
+}
+export interface UniqueIdPropertyConfig {
+    prefix: string;
+    next: number;
+}
+export type NotePropertyValue = string | number | boolean | string[] | FilePropertyRef[] | PlacePropertyValue;
+export type NoteProperties = Record<string, NotePropertyValue>;
+/**
+ * Lossless JSON-object representation used by read-modify-write paths. Unknown
+ * values are preserved so an older client cannot erase fields written by a
+ * newer client while updating an unrelated property.
+ */
+export type RawNoteProperties = Record<string, unknown>;
+/**
+ * Supported current-client view of `c_note.properties`.
+ *
+ * A missing key means the property is not declared on the note, while an
+ * explicit `null` keeps a durable empty slot created manually or by a template.
+ * Raw read-modify-write paths use `RawNoteProperties` so future value shapes
+ * remain intact even when this typed view cannot render them yet.
+ */
+export type StoredNotePropertyValue = NotePropertyValue | null;
+export type StoredNoteProperties = Record<string, StoredNotePropertyValue>;
+/**
+ * Legacy value patch. Non-null values set a property; `null` removes the key.
+ * New callers use the explicit slot operation for clear/remove semantics.
+ */
+export type NotePropertiesPatch = Record<string, NotePropertyValue | null>;
+export type NotePropertySlotOperation = 'declare' | 'clear' | 'remove';
+export declare const NOTE_PROPERTY_LIMITS: {
+    readonly keyLength: 64;
+    readonly textLength: 2000;
+    readonly arrayLength: 50;
+    readonly mutationKeys: 100;
+};
+/** Property types with a stable value contract and public editing support. */
+export declare const ACTIVE_PROPERTY_TYPES: readonly ["text", "number", "date", "select", "multi_select", "status", "url", "email", "phone", "checkbox", "files", "relation", "unique_id", "place"];
+/** Types whose storage format is locked but not yet editable. None remain. */
+export declare const RESERVED_PROPERTY_TYPES: readonly [];
+export type ActivePropertyType = (typeof ACTIVE_PROPERTY_TYPES)[number];
+export type PropertyType = ActivePropertyType | (typeof RESERVED_PROPERTY_TYPES)[number];
+export type PropertyDefSource = 'manual' | 'ai';
+export declare const PROPERTY_OPTION_COLORS: readonly ["gray", "red", "orange", "yellow", "green", "blue", "purple", "pink"];
+export type PropertyOptionColor = (typeof PROPERTY_OPTION_COLORS)[number];
+export declare const STATUS_PROPERTY_GROUPS: readonly ["todo", "in_progress", "complete"];
+export type StatusPropertyGroup = (typeof STATUS_PROPERTY_GROUPS)[number];
+export interface PropertyOption {
+    id: string;
+    label: string;
+    color: PropertyOptionColor;
+    sortRank: number;
+    archived: boolean;
+    /** Status workflow bucket. Omitted for ordinary select options. */
+    group?: StatusPropertyGroup;
+}
+/** Command input: existing options carry their id; main assigns ids to new items. */
+export interface PropertyOptionInput {
+    id?: string;
+    label: string;
+    color?: PropertyOptionColor;
+    sortRank?: number;
+    archived?: boolean;
+    group?: StatusPropertyGroup;
+}
+export declare const DEFAULT_STATUS_OPTION_INPUTS: readonly PropertyOptionInput[];
+export interface PropertyOptionsEnvelopeV1 {
+    version: 1;
+    items: PropertyOption[];
+}
+export declare const PROPERTY_OPTION_LIMITS: {
+    readonly items: 200;
+    readonly labelLength: 120;
+};
+export declare const PROPERTY_OPTION_LABEL_MAX_LENGTH: 120;
+export declare const PROPERTY_NUMBER_PRECISION_MAX = 12;
+export declare const PROPERTY_DEF_CONFIG_KEY_PREFIX = "property_def.config.v1.";
+export type PropertyDefOptionsParseResult = {
+    status: 'empty';
+} | {
+    status: 'valid';
+    options: PropertyOption[];
+} | {
+    status: 'legacy';
+    labels: string[];
+} | {
+    status: 'invalid';
+} | {
+    status: 'unsupported';
+    version: unknown;
+};
+export type PropertyDefConfigParseResult = {
+    status: 'empty';
+} | {
+    status: 'valid';
+    config: PropertyDefConfig;
+} | {
+    status: 'invalid';
+} | {
+    status: 'unsupported';
+    version: unknown;
+};
+export type PropertyDefConfigDefaults = 'legacy' | 'new';
+export declare function buildPropertyDefConfigKey(definitionId: string): string;
+export type DatePropertyDefConfig = {
+    version: 1;
+    type: 'date';
+    mode: 'date' | 'datetime';
+};
+export type NumberPropertyDefConfig = {
+    version: 1;
+    type: 'number';
+    format: 'number' | 'percent' | 'currency';
+    precision?: number;
+    currency?: string;
+    unit?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+};
+export type SelectPropertyDefConfig = {
+    version: 1;
+    type: 'select';
+    mode: 'open' | 'closed';
+};
+export type MultiSelectPropertyDefConfig = {
+    version: 1;
+    type: 'multi_select';
+    mode: 'open' | 'closed';
+    maxSelections?: number;
+};
+export type UrlPropertyDefConfig = {
+    version: 1;
+    type: 'url';
+    schemes?: Array<'http' | 'https'>;
+};
+export type PropertyDefConfig = DatePropertyDefConfig | NumberPropertyDefConfig | SelectPropertyDefConfig | MultiSelectPropertyDefConfig | UrlPropertyDefConfig;
+export declare function isPropertyDefSource(value: unknown): value is PropertyDefSource;
+/** Domain form of a synced property-definition catalog entry (camelCase). */
+export interface PropertyDef {
+    id: string;
+    /** Stable key written into the note properties JSON. Immutable after creation. */
+    key: string;
+    /** Display name. Renamable without migrating note data. */
+    name: string;
+    type: PropertyType;
+    /** Stable options for select / multi_select / status; note values store option ids. */
+    options?: PropertyOption[];
+    /** Counter stored in `c_property_def.options` for `unique_id` (not the select envelope). */
+    uniqueId?: UniqueIdPropertyConfig;
+    /** Effective type configuration, including legacy defaults when no companion row exists. */
+    config?: PropertyDefConfig;
+    /** Explicit companion config exists but is malformed, unsupported, or type-mismatched. */
+    configInvalid: boolean;
+    /** True until a legacy string-array definition has been migrated to stable option ids. */
+    optionsMigrationPending: boolean;
+    /** Stable option storage exists but is malformed or uses an unsupported version. */
+    optionsInvalid: boolean;
+    /** Semantic description (AI disambiguation anchor). */
+    description?: string;
+    icon?: string;
+    /** Whether compact note summaries should surface this property by default. */
+    showOnCard: boolean;
+    source: PropertyDefSource;
+    sortRank: number;
+}
+/** Raw catalog row shape returned by the PowerSync read model (snake_case, nullable). */
+export interface PropertyDefRow {
+    id: string;
+    user_id: string | null;
+    key: string | null;
+    name: string | null;
+    type: string | null;
+    options: string | null;
+    /** Companion c_config_property.c_value selected by the catalog read model. */
+    config_json: string | null;
+    description: string | null;
+    icon: string | null;
+    sort_rank: number | null;
+    show_on_card: number | null;
+    source: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+    is_del: number | null;
+}
+/**
+ * Property key validity: non-empty, <=64 chars, no newlines/tabs. A key is one
+ * flat name. Field refs keep a single `prop.` prefix and take the remainder as
+ * that name, so dots inside the name stay part of the name. `__proto__` is
+ * reserved because common object validators cannot round-trip it safely.
+ */
+export declare function isPropertyKeyValid(key: unknown): key is string;
+export declare function isFilePropertyPathValid(path: unknown): path is string;
+export declare function isFilePropertyRef(value: unknown): value is FilePropertyRef;
+/** Reject a malformed file list instead of dropping attachments. An empty list is `[]`. */
+export declare function normalizeFilePropertyValue(value: unknown): FilePropertyRef[] | null;
+export declare function normalizePlacePropertyValue(value: unknown): PlacePropertyValue | null;
+export declare function isPlacePropertyValue(value: unknown): value is PlacePropertyValue;
+export declare function formatPlaceProperty(value: PlacePropertyValue): string;
+export declare function normalizeUniqueIdPrefix(raw: string | null | undefined, fallbackName?: string | null): string;
+export declare function isIssuedUniqueId(value: unknown): value is number;
+export declare function parseUniqueIdPropertyConfig(raw: string | null | undefined): UniqueIdPropertyConfig | undefined;
+export declare function serializeUniqueIdPropertyConfig(config: UniqueIdPropertyConfig): string;
+export declare function formatUniqueIdProperty(value: number, config?: Pick<UniqueIdPropertyConfig, 'prefix'> | null): string;
+/**
+ * Strictly parse the raw JSON object. `null` means the stored value is present
+ * but malformed or uses an unsupported top-level shape.
+ */
+export declare function tryParseRawNoteProperties(raw: string | null | undefined): RawNoteProperties | null;
+/** Forgiving read projection used by UI/read paths; malformed storage appears empty. */
+export declare function parseRawNoteProperties(raw: string | null | undefined): RawNoteProperties;
+/** Parse the supported three-state view; unknown values are omitted from the UI. */
+export declare function parseStoredNoteProperties(raw: string | null | undefined): StoredNoteProperties;
+/** Read only committed values; declared-but-empty slots are intentionally omitted. */
+export declare function parseNoteProperties(raw: string | null | undefined): NoteProperties;
+/** Serialize persisted values + empty slots; an empty object normalizes to NULL. */
+export declare function serializeStoredNoteProperties(properties: Readonly<Record<string, unknown>>): string | null;
+/** Serialize a lossless raw property object; an empty object normalizes to NULL. */
+export declare function serializeRawNoteProperties(properties: Readonly<RawNoteProperties>): string | null;
+/** Serialize the non-empty value view. */
+export declare function serializeNoteProperties(properties: NoteProperties): string | null;
+export interface MergePropertiesResult {
+    next: RawNoteProperties;
+    changedKeys: string[];
+}
+export interface FillEmptyPropertiesResult extends MergePropertiesResult {
+    skippedKeys: string[];
+}
+/**
+ * Legacy value merge: null removes a key, non-null values overwrite, and all
+ * unrelated JSON entries are preserved. Returns the list of changed keys.
+ */
+export declare function mergeNotePropertiesPatch(current: Readonly<RawNoteProperties>, patch: NotePropertiesPatch): MergePropertiesResult;
+/**
+ * Fill only fields that are still explicitly declared as empty. Missing fields
+ * and fields with any current value are skipped, allowing AI/review flows to
+ * avoid overwriting a concurrent user edit in the same transaction.
+ */
+export declare function fillEmptyNoteProperties(current: Readonly<RawNoteProperties>, values: NoteProperties): FillEmptyPropertiesResult;
+/**
+ * Apply an explicit field-slot operation: declare adds only missing slots, clear
+ * makes every target explicitly empty, and remove deletes the slot entirely.
+ */
+export declare function applyNotePropertySlotOperation(current: Readonly<RawNoteProperties>, operation: NotePropertySlotOperation, keys: readonly string[]): MergePropertiesResult;
+/** Normalize accepted date input and reject ISO-like strings with impossible calendar dates. */
+export declare function normalizeDateValueToIso(value: unknown): string | null;
+/** Normalize a configured date value without conflating a calendar date with an instant. */
+export declare function normalizeDatePropertyValue(value: unknown, mode: DatePropertyDefConfig['mode']): string | null;
+/** Validate a number against its semantic constraints without rounding the stored value. */
+export declare function normalizeNumberPropertyValue(value: unknown, config: NumberPropertyDefConfig): number | null;
+/** Validate and canonicalize an absolute URL under the definition's allowed schemes. */
+export declare function normalizeUrlPropertyValue(value: unknown, config?: UrlPropertyDefConfig): string | null;
+/**
+ * Coerce a candidate value into the legal shape for a target type; returns null
+ * when it cannot be coerced. Only does shape coercion — the select-option
+ * whitelist belongs to the validation/policy layer.
+ */
+export declare function coercePropertyValue(type: PropertyType, value: unknown): NotePropertyValue | null;
+/** UI display value -> chip text (arrays joined with "、"). */
+export declare function formatPropertyValue(value: NotePropertyValue): string;
+/** Infer a type from the value shape when the catalog is missing (orphan keys). */
+export declare function inferPropertyTypeFromValue(value: NotePropertyValue): ActivePropertyType;
+export declare function isPropertyType(value: unknown): value is PropertyType;
+export declare function isPropertyOptionColor(value: unknown): value is PropertyOptionColor;
+/** Normalize the user-visible option identity used for display and uniqueness. */
+export declare function normalizePropertyOptionLabel(value: unknown): string | null;
+/** Case-insensitive uniqueness key. Callers should reject an empty result. */
+export declare function propertyOptionLabelKey(value: string): string;
+export declare function findPropertyOptionById(options: readonly PropertyOption[], id: string): PropertyOption | undefined;
+export declare function findPropertyOptionByLabel(options: readonly PropertyOption[], label: string): PropertyOption | undefined;
+/** Validate, deduplicate, and put options in their canonical `(sortRank,id)` order. */
+export declare function normalizePropertyOptions(values: readonly unknown[]): PropertyOption[] | undefined;
+/** Parse both the stable v1 envelope and legacy label arrays without conflating them. */
+export declare function parsePropertyDefOptionsEnvelope(raw: string | null | undefined): PropertyDefOptionsParseResult;
+/** Read only migrated stable options. Legacy labels remain migration-only data. */
+export declare function parsePropertyDefOptions(raw: string | null | undefined): PropertyOption[] | undefined;
+/** Read legacy label options for the explicit migration command only. */
+export declare function parseLegacyPropertyDefOptions(raw: string | null | undefined): string[] | undefined;
+export declare function serializePropertyDefOptions(options: readonly PropertyOption[]): string;
+/** Validate and canonicalize a structured property-definition config object. */
+export declare function normalizePropertyDefConfig(value: unknown): PropertyDefConfig | undefined;
+/** Parse a companion config without hiding malformed or future-version rows. */
+export declare function parsePropertyDefConfigEnvelope(raw: string | null | undefined): PropertyDefConfigParseResult;
+/** Parse only an explicit valid companion config; other states return undefined. */
+export declare function parsePropertyDefConfig(raw: string | null | undefined): PropertyDefConfig | undefined;
+/** Option definitions stay open so unmatched input can create options inline. */
+export declare function getDefaultPropertyDefConfig(type: PropertyType, _defaults?: PropertyDefConfigDefaults): PropertyDefConfig | undefined;
+export declare function resolvePropertyDefConfig(type: PropertyType, raw: string | null | undefined): PropertyDefConfig | undefined;
+export declare function serializePropertyDefConfig(config: PropertyDefConfig): string;
+/** Map a raw c_property_def row into the domain object (unknown type -> text). */
+export declare function mapPropertyDef(record: PropertyDefRow): PropertyDef;