@e-llm-studio/instant-learning 1.3.2 → 1.3.4

package/dist/types/src/schema-driven/types.d.ts

@@ -1,223 +1,223 @@
-import React from 'react';
-export type TableColumnType = 'text' | 'number' | 'checkbox' | 'dropdown' | 'readonly' | 'badge' | 'badgeSelect' | 'tags' | 'fileType';
-/** Configuration consumed by the schema-driven TableComponent. */
-export interface TableColumnSchema {
-    key: string;
-    header: string;
-    type: TableColumnType;
-    options?: (string | {
-        label: string;
-        value: string;
-    })[];
-    editable?: boolean;
-    width?: string;
-    placeholder?: string;
-    defaultValue?: unknown;
-    info?: string;
-    badgeMap?: Record<string, {
-        label?: string;
-        tone?: string;
-        color?: string;
-        background?: string;
-    }>;
-    tagOptions?: string[];
-}
-/**
- * Shape of a single node in the `learningMetadataComponents` JSON schema.
- * Mirrors `LMSMetadataField` (useLMSConfigStore) plus the `data_key` field,
- * which is reserved for the upcoming state-binding phase.
- */
-export interface SchemaFieldNode {
-    type?: 'string' | 'array' | 'object' | 'boolean';
-    title?: string;
-    placeholder?: string;
-    /** Optional character limit. Omit for unlimited input. */
-    maxLength?: number;
-    tooltip?: string;
-    description?: string;
-    /** Optional helper copy rendered under the field's title in the UI — the schema
-     *  equivalent of the hardcoded `wtaInformation` / `ruleDescriptionInformation`
-     *  strings the non-dynamic templates read from their renderer config. Every
-     *  registry component receives this via BPARenderer. */
-    subtitle?: string;
-    ui_position?: number;
-    bpa_ui_component?: string;
-    data_key?: string;
-    options?: {
-        label: string;
-        value: string;
-        parentValue?: string;
-    }[];
-    enum?: Array<string | {
-        label: string;
-        value: string;
-        parentValue?: string;
-    }>;
-    dynamic_options_key?: string;
-    depends_on_global_key?: string;
-    core_field?: boolean;
-    ui_only?: boolean;
-    ai_generated?: boolean;
-    is_required?: boolean;
-    read_only?: boolean;
-    /** Frozen-after-creation flag (defaults to false). In the EDIT flow the field can
-     *  never be opened for editing — not even inside a parent edit session — while it
-     *  stays fully editable during creation. On a wrapper node it freezes the whole
-     *  subtree and removes that section's Edit button. See utils/editLock.ts. */
-    read_only_in_edit_flow?: boolean;
-    hidden?: boolean;
-    default_open?: boolean;
-    is_repeatable_variant?: boolean;
-    /** Variant wrapper only: set false to hide the "Variant N" pill in each variant
-     *  accordion header. Defaults to true (pill shown). */
-    show_variant_pill?: boolean;
-    /** Section-level editing. On an `Accordion` or `VariantListWrapper` node, the
-     *  section's fields are drafted together behind ONE Edit (with a single combined
-     *  Save) and their individual inline pencils are suppressed. Omit it to keep
-     *  per-field inline editing. */
-    parent_edit?: boolean;
-    group_edit?: boolean;
-    group_title?: string;
-    /** TableComponent column definitions. Row data is stored under `data_key`. */
-    columns?: TableColumnSchema[];
-    /** Optional schema-level initial rows; host/API values take precedence. */
-    rows?: Record<string, unknown>[];
-    /** Show row drag handles and allow rows to be reordered. */
-    reorderable?: boolean;
-    /** Show the interactive per-row lock control. */
-    lockable?: boolean;
-    /** Row property used to persist the interactive lock state. */
-    lockedKey?: string;
-    properties?: Record<string, SchemaFieldNode>;
-}
-/** Root shape of `learningMetadataComponents` itself. */
-export interface SchemaRoot {
-    type?: string;
-    title?: string;
-    properties?: Record<string, SchemaFieldNode>;
-}
-/**
- * Uniform prop contract every registry-resolved component must accept.
- * Container components (`isContainer: true` in the registry) receive the
- * recursively rendered subtree as `children`; leaf components ignore it.
- */
-export interface SchemaComponentProps {
-    id?: string;
-    schema: SchemaFieldNode;
-    value?: any;
-    onChange?: (val: any) => void;
-    readOnly?: boolean;
-    errorMessage?: string;
-    isAiStreaming?: boolean;
-    children?: React.ReactNode;
-    title?: string;
-    [key: string]: any;
-}
-export type ColumnType = 'text' | 'number' | 'checkbox' | 'dropdown' | 'readonly' | 'badge' | 'badgeSelect' | 'tags' | 'fileType';
-export type BadgeTone = 'success' | 'warning' | 'danger' | 'info' | 'neutral';
-export interface BadgeConfig {
-    /** text shown in the pill; falls back to the raw value */
-    label?: string;
-    /** built-in color scheme */
-    tone?: BadgeTone;
-    /** explicit overrides, take precedence over tone */
-    color?: string;
-    background?: string;
-}
-export interface ColumnDef<T> {
-    /** key into the row object this column reads/writes */
-    key: Extract<keyof T, string>;
-    /** column header label */
-    header: string;
-    /** which kind of control renders each cell in this column */
-    type: ColumnType;
-    /** options for type === 'dropdown' */
-    options?: string[];
-    /** can the user edit this cell? defaults to true (forced false for 'readonly') */
-    editable?: boolean;
-    /** css width, e.g. '140px' or '1fr' */
-    width?: string;
-    /** placeholder for text/number inputs */
-    placeholder?: string;
-    /** value a new row gets for this column when "Add" is clicked */
-    defaultValue?: T[Extract<keyof T, string>];
-    /** custom renderer for a readonly cell's value, e.g. icon + label */
-    renderReadonly?: (value: any, row: T) => React.ReactNode;
-    /** for type === 'badge' or 'badgeSelect': maps a raw value to a label + color scheme */
-    badgeMap?: Record<string, BadgeConfig>;
-    /** for type === 'tags': the value is a string[]; these are the choices offered in the "+ Add" control */
-    tagOptions?: string[];
-    /** small (i) tooltip icon shown next to the header label */
-    info?: string;
-}
-export interface TableComponentProps<T extends Record<string, any>> {
-    /** column configuration — defines both header and how each cell edits */
-    columns?: ColumnDef<T>[];
-    /** current row data (fully controlled). Used by standalone consumers. */
-    rows?: T[];
-    /** called with the next rows array whenever anything changes. */
-    onRowsChange?: (rows: T[]) => void;
-    /** Schema-driven renderer contract: table configuration lives on `schema`. */
-    schema?: {
-        columns?: ColumnDef<T>[];
-        rows?: T[];
-        reorderable?: boolean;
-        lockable?: boolean;
-        lockedKey?: Extract<keyof T, string>;
-        orderKey?: Extract<keyof T, string>;
-    };
-    /** Schema-driven renderer contract: the current array value. */
-    value?: T[];
-    /** Schema-driven renderer contract: receives the next array value. */
-    onChange?: (rows: T[]) => void;
-    /** Disables all table mutations when supplied by the schema-driven renderer. */
-    readOnly?: boolean;
-    /** unique id field on each row; falls back to array index if omitted */
-    rowKey?: Extract<keyof T, string>;
-    /** show the "+ Add" button and allow appending blank rows. default: true */
-    addable?: boolean;
-    /** show a delete icon per row. default: true */
-    deletable?: boolean;
-    /** allow drag-handle reordering of rows. default: false */
-    reorderable?: boolean;
-    addButtonLabel?: string;
-    emptyStateMessage?: string;
-    /** rows matching this predicate are PERMANENTLY locked — shown with a static lock icon, never toggleable */
-    isRowLocked?: (row: T) => boolean;
-    /**
-     * Turns on an interactive lock column. Rows not covered by `isRowLocked`
-     * can be locked/unlocked by clicking the icon; state is stored on
-     * `row[lockedKey]` unless `onToggleLock` is supplied.
-     * default: false
-     */
-    lockable?: boolean;
-    /** row field used to persist the toggleable lock state. default: 'locked' */
-    lockedKey?: Extract<keyof T, string>;
-    /** override the default toggle-in-place behavior for the lock icon */
-    onToggleLock?: (row: T, rowIndex: number) => void;
-    /**
-     * When set, every row is stamped with its 1-based position in this field
-     * (`row[orderKey] = index + 1`) any time the array's order or length
-     * changes — after add, delete, or drag reorder. This mirrors the visible
-     * "Sr No" column but persists it into the row data so it's included in
-     * whatever payload is built from `rows`/`value`. Omit to leave rows
-     * untouched (no field is added or written).
-     */
-    orderKey?: Extract<keyof T, string>;
-    className?: string;
-    /** quick accent-color override without writing a full stylesheet */
-    accentColor?: string;
-    /**
-     * Raw CSS for the table. Target the et-* class names below (see
-     * buildDefaultCss / DEFAULT_TABLE_CSS_TEMPLATE for the full list) to
-     * restyle specific parts, or pass a whole stylesheet to replace the
-     * look entirely. Omit it to get the built-in default look.
-     * Each table instance is scoped automatically, so two tables on the
-     * same page can be given different css props without colliding.
-     */
-    css?: string;
-}
-export declare const FILE_ICON_COLOR: Record<string, string>;
-export declare const BADGE_TONE_DEFAULT: BadgeTone;
-export declare const DEFAULT_FILE_TYPES: string[];
+import React from 'react';
+export type TableColumnType = 'text' | 'number' | 'checkbox' | 'dropdown' | 'readonly' | 'badge' | 'badgeSelect' | 'tags' | 'fileType';
+/** Configuration consumed by the schema-driven TableComponent. */
+export interface TableColumnSchema {
+    key: string;
+    header: string;
+    type: TableColumnType;
+    options?: (string | {
+        label: string;
+        value: string;
+    })[];
+    editable?: boolean;
+    width?: string;
+    placeholder?: string;
+    defaultValue?: unknown;
+    info?: string;
+    badgeMap?: Record<string, {
+        label?: string;
+        tone?: string;
+        color?: string;
+        background?: string;
+    }>;
+    tagOptions?: string[];
+}
+/**
+ * Shape of a single node in the `learningMetadataComponents` JSON schema.
+ * Mirrors `LMSMetadataField` (useLMSConfigStore) plus the `data_key` field,
+ * which is reserved for the upcoming state-binding phase.
+ */
+export interface SchemaFieldNode {
+    type?: 'string' | 'array' | 'object' | 'boolean';
+    title?: string;
+    placeholder?: string;
+    /** Optional character limit. Omit for unlimited input. */
+    maxLength?: number;
+    tooltip?: string;
+    description?: string;
+    /** Optional helper copy rendered under the field's title in the UI — the schema
+     *  equivalent of the hardcoded `wtaInformation` / `ruleDescriptionInformation`
+     *  strings the non-dynamic templates read from their renderer config. Every
+     *  registry component receives this via BPARenderer. */
+    subtitle?: string;
+    ui_position?: number;
+    bpa_ui_component?: string;
+    data_key?: string;
+    options?: {
+        label: string;
+        value: string;
+        parentValue?: string;
+    }[];
+    enum?: Array<string | {
+        label: string;
+        value: string;
+        parentValue?: string;
+    }>;
+    dynamic_options_key?: string;
+    depends_on_global_key?: string;
+    core_field?: boolean;
+    ui_only?: boolean;
+    ai_generated?: boolean;
+    is_required?: boolean;
+    read_only?: boolean;
+    /** Frozen-after-creation flag (defaults to false). In the EDIT flow the field can
+     *  never be opened for editing — not even inside a parent edit session — while it
+     *  stays fully editable during creation. On a wrapper node it freezes the whole
+     *  subtree and removes that section's Edit button. See utils/editLock.ts. */
+    read_only_in_edit_flow?: boolean;
+    hidden?: boolean;
+    default_open?: boolean;
+    is_repeatable_variant?: boolean;
+    /** Variant wrapper only: set false to hide the "Variant N" pill in each variant
+     *  accordion header. Defaults to true (pill shown). */
+    show_variant_pill?: boolean;
+    /** Section-level editing. On an `Accordion` or `VariantListWrapper` node, the
+     *  section's fields are drafted together behind ONE Edit (with a single combined
+     *  Save) and their individual inline pencils are suppressed. Omit it to keep
+     *  per-field inline editing. */
+    parent_edit?: boolean;
+    group_edit?: boolean;
+    group_title?: string;
+    /** TableComponent column definitions. Row data is stored under `data_key`. */
+    columns?: TableColumnSchema[];
+    /** Optional schema-level initial rows; host/API values take precedence. */
+    rows?: Record<string, unknown>[];
+    /** Show row drag handles and allow rows to be reordered. */
+    reorderable?: boolean;
+    /** Show the interactive per-row lock control. */
+    lockable?: boolean;
+    /** Row property used to persist the interactive lock state. */
+    lockedKey?: string;
+    properties?: Record<string, SchemaFieldNode>;
+}
+/** Root shape of `learningMetadataComponents` itself. */
+export interface SchemaRoot {
+    type?: string;
+    title?: string;
+    properties?: Record<string, SchemaFieldNode>;
+}
+/**
+ * Uniform prop contract every registry-resolved component must accept.
+ * Container components (`isContainer: true` in the registry) receive the
+ * recursively rendered subtree as `children`; leaf components ignore it.
+ */
+export interface SchemaComponentProps {
+    id?: string;
+    schema: SchemaFieldNode;
+    value?: any;
+    onChange?: (val: any) => void;
+    readOnly?: boolean;
+    errorMessage?: string;
+    isAiStreaming?: boolean;
+    children?: React.ReactNode;
+    title?: string;
+    [key: string]: any;
+}
+export type ColumnType = 'text' | 'number' | 'checkbox' | 'dropdown' | 'readonly' | 'badge' | 'badgeSelect' | 'tags' | 'fileType';
+export type BadgeTone = 'success' | 'warning' | 'danger' | 'info' | 'neutral';
+export interface BadgeConfig {
+    /** text shown in the pill; falls back to the raw value */
+    label?: string;
+    /** built-in color scheme */
+    tone?: BadgeTone;
+    /** explicit overrides, take precedence over tone */
+    color?: string;
+    background?: string;
+}
+export interface ColumnDef<T> {
+    /** key into the row object this column reads/writes */
+    key: Extract<keyof T, string>;
+    /** column header label */
+    header: string;
+    /** which kind of control renders each cell in this column */
+    type: ColumnType;
+    /** options for type === 'dropdown' */
+    options?: string[];
+    /** can the user edit this cell? defaults to true (forced false for 'readonly') */
+    editable?: boolean;
+    /** css width, e.g. '140px' or '1fr' */
+    width?: string;
+    /** placeholder for text/number inputs */
+    placeholder?: string;
+    /** value a new row gets for this column when "Add" is clicked */
+    defaultValue?: T[Extract<keyof T, string>];
+    /** custom renderer for a readonly cell's value, e.g. icon + label */
+    renderReadonly?: (value: any, row: T) => React.ReactNode;
+    /** for type === 'badge' or 'badgeSelect': maps a raw value to a label + color scheme */
+    badgeMap?: Record<string, BadgeConfig>;
+    /** for type === 'tags': the value is a string[]; these are the choices offered in the "+ Add" control */
+    tagOptions?: string[];
+    /** small (i) tooltip icon shown next to the header label */
+    info?: string;
+}
+export interface TableComponentProps<T extends Record<string, any>> {
+    /** column configuration — defines both header and how each cell edits */
+    columns?: ColumnDef<T>[];
+    /** current row data (fully controlled). Used by standalone consumers. */
+    rows?: T[];
+    /** called with the next rows array whenever anything changes. */
+    onRowsChange?: (rows: T[]) => void;
+    /** Schema-driven renderer contract: table configuration lives on `schema`. */
+    schema?: {
+        columns?: ColumnDef<T>[];
+        rows?: T[];
+        reorderable?: boolean;
+        lockable?: boolean;
+        lockedKey?: Extract<keyof T, string>;
+        orderKey?: Extract<keyof T, string>;
+    };
+    /** Schema-driven renderer contract: the current array value. */
+    value?: T[];
+    /** Schema-driven renderer contract: receives the next array value. */
+    onChange?: (rows: T[]) => void;
+    /** Disables all table mutations when supplied by the schema-driven renderer. */
+    readOnly?: boolean;
+    /** unique id field on each row; falls back to array index if omitted */
+    rowKey?: Extract<keyof T, string>;
+    /** show the "+ Add" button and allow appending blank rows. default: true */
+    addable?: boolean;
+    /** show a delete icon per row. default: true */
+    deletable?: boolean;
+    /** allow drag-handle reordering of rows. default: false */
+    reorderable?: boolean;
+    addButtonLabel?: string;
+    emptyStateMessage?: string;
+    /** rows matching this predicate are PERMANENTLY locked — shown with a static lock icon, never toggleable */
+    isRowLocked?: (row: T) => boolean;
+    /**
+     * Turns on an interactive lock column. Rows not covered by `isRowLocked`
+     * can be locked/unlocked by clicking the icon; state is stored on
+     * `row[lockedKey]` unless `onToggleLock` is supplied.
+     * default: false
+     */
+    lockable?: boolean;
+    /** row field used to persist the toggleable lock state. default: 'locked' */
+    lockedKey?: Extract<keyof T, string>;
+    /** override the default toggle-in-place behavior for the lock icon */
+    onToggleLock?: (row: T, rowIndex: number) => void;
+    /**
+     * When set, every row is stamped with its 1-based position in this field
+     * (`row[orderKey] = index + 1`) any time the array's order or length
+     * changes — after add, delete, or drag reorder. This mirrors the visible
+     * "Sr No" column but persists it into the row data so it's included in
+     * whatever payload is built from `rows`/`value`. Omit to leave rows
+     * untouched (no field is added or written).
+     */
+    orderKey?: Extract<keyof T, string>;
+    className?: string;
+    /** quick accent-color override without writing a full stylesheet */
+    accentColor?: string;
+    /**
+     * Raw CSS for the table. Target the et-* class names below (see
+     * buildDefaultCss / DEFAULT_TABLE_CSS_TEMPLATE for the full list) to
+     * restyle specific parts, or pass a whole stylesheet to replace the
+     * look entirely. Omit it to get the built-in default look.
+     * Each table instance is scoped automatically, so two tables on the
+     * same page can be given different css props without colliding.
+     */
+    css?: string;
+}
+export declare const FILE_ICON_COLOR: Record<string, string>;
+export declare const BADGE_TONE_DEFAULT: BadgeTone;
+export declare const DEFAULT_FILE_TYPES: string[];
 //# sourceMappingURL=types.d.ts.map

package/dist/types/src/schema-driven/utils/PayloadUtils.d.ts

@@ -1,81 +1,81 @@
-export declare const getVariantPrefilledData: (jsonSchema: any, prefilledData: Record<string, any>) => Record<string, Record<number, Record<string, any>>>;
-/**
- * A core leaf's value may arrive under a looser name than the property key:
- *  - from the AI's `updated_fields` (e.g. `title` for `rule_title`), or
- *  - from the rule-fetch API on load, which uses its own fixed field names
- *    (`ruleTitle`, `description`, `whenToApply`, `whenNotToApply`).
- * Read those aliases without changing the canonical wire key we emit. Keys here
- * are the conventional property keys; a schema using different keys would extend this.
- * Shared by `applyResponseToStore` (store hydration) and `buildFieldLabelMap`
- * (chat labels) so both resolve the AI's key names the same way.
- */
-export declare const CORE_KEY_ALIASES: Record<string, string[]>;
-/**
- * Build the AI-key → user-facing-label map for the schema-driven flow.
- *
- * The C.A.R.E. response echoes schema PROPERTY KEYS (or their `CORE_KEY_ALIASES`)
- * in `updated_fields` / `identified_fields`. The chat renderer must label those
- * with the same title the RHS form shows, and the JSON owns that title
- * (`rule_title` → "Template Title", `rule_description` → "Template Goal", …),
- * so it is derived here instead of being hardcoded in the renderer.
- *
- * Every leaf that carries a `title` contributes an entry under its property key
- * plus each of its aliases, so `title`, `rule_title` and `ruleTitle` all resolve
- * to the same label. Only the schema-driven modal passes this map down; the
- * legacy flow keeps the renderer's built-in defaults.
- */
-export declare const buildFieldLabelMap: (jsonSchema: any) => Record<string, string>;
-export declare const generatePayloadFromSchema: (jsonSchema: any, tierKey: string, variantIndex: number) => {
-    rootPayload: any;
-    learningMetadata: {
-        properties: any;
-        required: string[];
-    };
-    variantScopedMetadataKeys: string[];
-};
-/**
- * The ruleset id the SCHEMA selects, or null when it doesn't select one.
- *
- * The dynamic store holds a dropdown's `value` (e.g. `weekly_digest`), never the
- * backing id — that travels on the option itself (`{ id, label, value }`, from
- * `dynamicOptions` or from inline JSON options that carry an `id`). So: find the
- * `ruleset_id`/`scope_id` leaf, read its store value, and return the id of the
- * option currently selected in it.
- *
- * Null means "the schema has no opinion" and the caller keeps whatever ruleset
- * it already used — that's the case for a schema without such a leaf, nothing
- * picked yet, or an option without an id. Only GLOBAL store values are read: a
- * ruleset is a per-template choice, not a per-variant one.
- */
-export declare const resolveSchemaRuleSetId: (jsonSchema: any, dynamicOptions?: Record<string, any>) => string | null;
-/**
- * Checks required JSON fields in the dynamic form store.
- * Optional tier/variant scopes limit validation to the data being saved.
- */
-export declare const areRequiredFieldsFilled: (jsonSchema: any, tierVariantMap: Map<string, Map<number, any>>, activeTierKeys?: Iterable<string>, activeVariantIndexes?: Iterable<number>) => boolean;
-/**
- * Write an AI/C.A.R.E. response back into the dynamic store.
- *
- * The AI echoes the same PROPERTY KEYS we sent in `ui_state` (e.g. `rule_title`,
- * `wta`). For every schema leaf whose property key is present in `response`, we
- * write the value into the store slot (`data_key`) the field reads from — so the
- * RHS re-renders with the AI's value and the next payload build reflects it.
- * String-typed fields that carry a list (wta/wnta) may arrive as an array; we
- * join those to a single `\n`-separated string to match the store's string shape.
- *
- * Where each key is read depends on where the writer put it (symmetry with
- * `generatePayloadFromSchema`):
- *   - core_field leaves          → top level of `response` (e.g. `response.wta`).
- *   - non-core (learning_metadata) → under `response.learning_metadata.properties`.
- * For non-core we also tolerate older shapes on load/edit: a flat
- * `learning_metadata[propKey]`, or the legacy `{ type, title, value }` wrapper.
- *
- * Pass `tierKey`/`variantIndex` to hydrate a specific variant; omit them for the
- * global (non-variant) flow. `read_only` and `ui_only` leaves are never written
- * (host-owned values like Category/Sub-Category must survive the round-trip).
- */
-export declare const applyResponseToStore: (jsonSchema: any, response: Record<string, any> | null | undefined, tierKey?: string, variantIndex?: number, options?: {
-    hydrateAll?: boolean;
-    variantOnly?: boolean;
-}) => void;
+export declare const getVariantPrefilledData: (jsonSchema: any, prefilledData: Record<string, any>) => Record<string, Record<number, Record<string, any>>>;
+/**
+ * A core leaf's value may arrive under a looser name than the property key:
+ *  - from the AI's `updated_fields` (e.g. `title` for `rule_title`), or
+ *  - from the rule-fetch API on load, which uses its own fixed field names
+ *    (`ruleTitle`, `description`, `whenToApply`, `whenNotToApply`).
+ * Read those aliases without changing the canonical wire key we emit. Keys here
+ * are the conventional property keys; a schema using different keys would extend this.
+ * Shared by `applyResponseToStore` (store hydration) and `buildFieldLabelMap`
+ * (chat labels) so both resolve the AI's key names the same way.
+ */
+export declare const CORE_KEY_ALIASES: Record<string, string[]>;
+/**
+ * Build the AI-key → user-facing-label map for the schema-driven flow.
+ *
+ * The C.A.R.E. response echoes schema PROPERTY KEYS (or their `CORE_KEY_ALIASES`)
+ * in `updated_fields` / `identified_fields`. The chat renderer must label those
+ * with the same title the RHS form shows, and the JSON owns that title
+ * (`rule_title` → "Template Title", `rule_description` → "Template Goal", …),
+ * so it is derived here instead of being hardcoded in the renderer.
+ *
+ * Every leaf that carries a `title` contributes an entry under its property key
+ * plus each of its aliases, so `title`, `rule_title` and `ruleTitle` all resolve
+ * to the same label. Only the schema-driven modal passes this map down; the
+ * legacy flow keeps the renderer's built-in defaults.
+ */
+export declare const buildFieldLabelMap: (jsonSchema: any) => Record<string, string>;
+export declare const generatePayloadFromSchema: (jsonSchema: any, tierKey: string, variantIndex: number) => {
+    rootPayload: any;
+    learningMetadata: {
+        properties: any;
+        required: string[];
+    };
+    variantScopedMetadataKeys: string[];
+};
+/**
+ * The ruleset id the SCHEMA selects, or null when it doesn't select one.
+ *
+ * The dynamic store holds a dropdown's `value` (e.g. `weekly_digest`), never the
+ * backing id — that travels on the option itself (`{ id, label, value }`, from
+ * `dynamicOptions` or from inline JSON options that carry an `id`). So: find the
+ * `ruleset_id`/`scope_id` leaf, read its store value, and return the id of the
+ * option currently selected in it.
+ *
+ * Null means "the schema has no opinion" and the caller keeps whatever ruleset
+ * it already used — that's the case for a schema without such a leaf, nothing
+ * picked yet, or an option without an id. Only GLOBAL store values are read: a
+ * ruleset is a per-template choice, not a per-variant one.
+ */
+export declare const resolveSchemaRuleSetId: (jsonSchema: any, dynamicOptions?: Record<string, any>) => string | null;
+/**
+ * Checks required JSON fields in the dynamic form store.
+ * Optional tier/variant scopes limit validation to the data being saved.
+ */
+export declare const areRequiredFieldsFilled: (jsonSchema: any, tierVariantMap: Map<string, Map<number, any>>, activeTierKeys?: Iterable<string>, activeVariantIndexes?: Iterable<number>) => boolean;
+/**
+ * Write an AI/C.A.R.E. response back into the dynamic store.
+ *
+ * The AI echoes the same PROPERTY KEYS we sent in `ui_state` (e.g. `rule_title`,
+ * `wta`). For every schema leaf whose property key is present in `response`, we
+ * write the value into the store slot (`data_key`) the field reads from — so the
+ * RHS re-renders with the AI's value and the next payload build reflects it.
+ * String-typed fields that carry a list (wta/wnta) may arrive as an array; we
+ * join those to a single `\n`-separated string to match the store's string shape.
+ *
+ * Where each key is read depends on where the writer put it (symmetry with
+ * `generatePayloadFromSchema`):
+ *   - core_field leaves          → top level of `response` (e.g. `response.wta`).
+ *   - non-core (learning_metadata) → under `response.learning_metadata.properties`.
+ * For non-core we also tolerate older shapes on load/edit: a flat
+ * `learning_metadata[propKey]`, or the legacy `{ type, title, value }` wrapper.
+ *
+ * Pass `tierKey`/`variantIndex` to hydrate a specific variant; omit them for the
+ * global (non-variant) flow. `read_only` and `ui_only` leaves are never written
+ * (host-owned values like Category/Sub-Category must survive the round-trip).
+ */
+export declare const applyResponseToStore: (jsonSchema: any, response: Record<string, any> | null | undefined, tierKey?: string, variantIndex?: number, options?: {
+    hydrateAll?: boolean;
+    variantOnly?: boolean;
+}) => void;
 //# sourceMappingURL=PayloadUtils.d.ts.map

package/dist/types/src/schema-driven/utils/aiReasoning.d.ts

@@ -1,5 +1,5 @@
-export declare const stripAiReasoning: (value: string) => {
-    clean: string;
-    raw: string | null;
-};
+export declare const stripAiReasoning: (value: string) => {
+    clean: string;
+    raw: string | null;
+};
 //# sourceMappingURL=aiReasoning.d.ts.map

package/dist/types/src/schema-driven/utils/conditionText.d.ts

@@ -1,8 +1,8 @@
-export interface ConditionItem {
-    id: string;
-    text: string;
-    reasoning?: string;
-}
-export declare const hasMeaningfulText: (text?: string | null) => boolean;
-export declare const splitConditions: (raw: string, keyPrefix: string) => ConditionItem[];
+export interface ConditionItem {
+    id: string;
+    text: string;
+    reasoning?: string;
+}
+export declare const hasMeaningfulText: (text?: string | null) => boolean;
+export declare const splitConditions: (raw: string, keyPrefix: string) => ConditionItem[];
 //# sourceMappingURL=conditionText.d.ts.map