@timeax/digital-service-engine 0.0.1 → 0.0.3

package/dist/react/index.d.cts

@@ -34,12 +34,13 @@ interface BaseFieldUI {
     name?: string;
     label: string;
     required?: boolean;
-    /** Host-defined prop names → typed UI nodes */
-    ui?: Record<string, Ui>;
     /** Host-defined prop names → runtime default values (untyped base) */
     defaults?: Record<string, unknown>;
 }
-type Ui = UiString | UiNumber | UiBoolean | UiAnyOf | UiArray | UiObject;
+type Ui = (UiString | UiNumber | UiBoolean | UiAnyOf | UiArray | UiObject) & {
+    description: string;
+    label: string;
+};
 /** string */
 interface UiString {
     type: "string";
@@ -74,8 +75,17 @@ interface UiAnyOf {
 /** arrays: homogeneous (item) or tuple (items) */
 interface UiArray {
     type: "array";
+    label: string;
+    description: string;
     item?: Ui;
     items?: Ui[];
+    editable?: boolean;
+    /**
+     * Optional: allowed shapes for new items.
+     * Key = label shown in UI picker
+     * Value = schema for the new element
+     */
+    shape?: Record<string, Ui>;
     minItems?: number;
     maxItems?: number;
     uniqueItems?: boolean;
@@ -83,7 +93,16 @@ interface UiArray {
 /** objects: nested props */
 interface UiObject {
     type: "object";
+    label: string;
+    description: string;
+    editable?: boolean;
     fields: Record<string, Ui>;
+    /**
+     * Optional: allowed shapes for dynamically added keys.
+     * Key = human-readable name shown in UI picker
+     * Value = schema applied to the value of the new key
+     */
+    shape?: Record<string, Ui>;
     required?: string[];
     order?: string[];
 }
@@ -192,6 +211,8 @@ type ServiceProps = {
     excludes_for_buttons?: Record<string, string[]>;
     schema_version?: string;
     fallbacks?: ServiceFallback;
+    name?: string;
+    notices?: ServicePropsNotice[];
 };
 type ServiceIdRef = number | string;
 type NodeIdRef = string;
@@ -201,6 +222,34 @@ type ServiceFallback = {
     /** Primary→fallback list used when no node-scoped entry is present */
     global?: Record<ServiceIdRef, ServiceIdRef[]>;
 };
+type NoticeType = "public" | "private";
+type NoticeSeverity = "info" | "warning" | "error";
+/**
+ * “label” is lightweight + UI-friendly (best, sale, hot, etc).
+ * Others remain semantic / governance oriented.
+ */
+type NoticeKind = "label" | "warning" | "deprecation" | "compat" | "migration" | "policy";
+type NoticeTarget = {
+    scope: "global";
+} | {
+    scope: "node";
+    node_kind: "tag" | "field" | "option";
+    node_id: string;
+};
+interface ServicePropsNotice {
+    id: string;
+    type: NoticeType;
+    kind: NoticeKind;
+    severity: NoticeSeverity;
+    target: NoticeTarget;
+    title: string;
+    description?: string;
+    reason?: string;
+    marked_at?: string;
+    icon?: string;
+    color?: string;
+    meta?: Record<string, unknown>;
+}
 
 type NodeKind = "tag" | "field" | "comment" | "option";
 type EdgeKind = "child" | "bind" | "include" | "exclude" | "error" | "anchor";
@@ -440,6 +489,22 @@ type DgpServiceCapability = {
 };
 type DgpServiceMap = Record<string, DgpServiceCapability> & Record<number, DgpServiceCapability>;
 
+type NodeRef$1 = {
+    kind: "tag";
+    id: string;
+    node: Tag;
+} | {
+    kind: "field";
+    id: string;
+    node: Field;
+} | {
+    kind: "option";
+    id: string;
+    node: FieldOption;
+    fieldId: string;
+};
+type NodeMap = Map<string, NodeRef$1>;
+
 type ValidationCode = "root_missing" | "cycle_in_tags" | "bad_bind_reference" | "duplicate_id" | "duplicate_tag_label" | "duplicate_field_name" | "label_missing" | "duplicate_visible_label" | "bad_option_key" | "option_include_exclude_conflict" | "service_field_missing_service_id" | "user_input_field_has_service_option" | "rate_mismatch_across_base" | "utility_without_base" | "unsupported_constraint" | "constraint_contradiction" | "custom_component_missing" | "policy_violation" | "field_unbound" | "constraint_overridden" | "unsupported_constraint_option" | "custom_component_unresolvable" | "quantity_multiple_markers" | "utility_with_service_id" | "utility_missing_rate" | "utility_invalid_mode" | "fallback_bad_node" | "fallback_unknown_service" | "fallback_cycle" | "fallback_no_primary" | "fallback_rate_violation" | "fallback_constraint_mismatch" | "fallback_no_tag_context";
 type ValidationError = {
     code: ValidationCode;
@@ -488,6 +553,7 @@ type DynamicRule = {
 };
 type ValidatorOptions = {
     serviceMap?: DgpServiceMap;
+    nodeMap?: NodeMap;
     allowUnsafe?: boolean;
     selectedOptionKeys?: string[];
     globalUtilityGuard?: boolean;
@@ -556,108 +622,12 @@ interface Builder {
         description: string;
         value: string;
     }[];
+    isTagId(id: string): boolean;
+    isFieldId(id: string): boolean;
+    isOptionId(id: string): boolean;
+    getNodeMap(): NodeMap;
 }
 
-type Env = "client" | "workspace";
-type VisibleGroup = {
-    tagId?: string;
-    tag?: Tag;
-    fields: Field[];
-    fieldIds: string[];
-    parentTags?: Tag[];
-    childrenTags?: Tag[];
-    /** In order of selection: tag base (unless overridden) then selected options */
-    services?: DgpServiceCapability[];
-};
-type VisibleGroupResult = {
-    kind: "single";
-    group: VisibleGroup;
-} | {
-    kind: "multi";
-    groups: string[];
-};
-type ChangeEvt = {
-    ids: string[];
-    primary?: string;
-};
-type Listener = (e: ChangeEvt) => void;
-type SelectionOptions = {
-    env?: Env;
-    rootTagId?: string;
-    /** Resolve service capability from an id (used for `services` array) */
-    resolveService?: (id: any) => DgpServiceCapability | undefined;
-};
-declare class Selection {
-    private readonly builder;
-    private readonly opts;
-    private set;
-    private primaryId;
-    private currentTagId;
-    private onChangeFns;
-    constructor(builder: Builder, opts: SelectionOptions);
-    replace(id?: string | null): void;
-    add(id: string): void;
-    remove(id: string): void;
-    toggle(id: string): void;
-    many(ids: Iterable<string>, primary?: string): void;
-    clear(): void;
-    all(): ReadonlySet<string>;
-    has(id: string): boolean;
-    primary(): string | undefined;
-    currentTag(): string | undefined;
-    onChange(fn: Listener): () => void;
-    visibleGroup(): VisibleGroupResult;
-    private emit;
-    private updateCurrentTagFrom;
-    private resolveTagContextId;
-    private selectedButtonTriggerIds;
-    private computeGroupForTag;
-    private addServiceByRole;
-    private findOptionById;
-}
-
-type EditorEvents = {
-    "editor:command": {
-        name: string;
-        payload?: any;
-    };
-    "editor:change": {
-        props: ServiceProps;
-        reason: string;
-        command?: string;
-    };
-    "editor:undo": {
-        stackSize: number;
-        index: number;
-    };
-    "editor:redo": {
-        stackSize: number;
-        index: number;
-    };
-    "editor:error": {
-        message: string;
-        code?: string;
-        meta?: any;
-    };
-};
-type Command = {
-    name: string;
-    do(): void;
-    undo(): void;
-};
-type EditorOptions = {
-    historyLimit?: number;
-    validateAfterEach?: boolean;
-    /** Sync existence check; return true if the service exists. */
-    serviceExists?: (id: number) => boolean;
-    /** Optional local index; used if serviceExists is not provided. */
-    serviceMap?: Record<number, unknown>;
-    /** Raw policies JSON; will be compiled on demand by filterServicesForVisibleGroup. */
-    policiesRaw?: unknown;
-    selectionProps?: SelectionOptions;
-};
-type ConnectKind = "bind" | "include" | "exclude";
-
 interface ButtonValue {
     id: string;
     value: string | number;
@@ -720,6 +690,7 @@ type OrderSnapshot = {
     builtAt: string;
     selection: {
         tag: string;
+        buttons: string[];
         fields: Array<{
             id: string;
             type: string;
@@ -737,6 +708,8 @@ type OrderSnapshot = {
         rule?: QuantityRule$1;
         defaultedFromHost?: boolean;
     };
+    min: number;
+    max: number;
     services: Array<string | number>;
     serviceMap: Record<string, Array<string | number>>;
     fallbacks?: {
@@ -761,6 +734,130 @@ type OrderSnapshot = {
     };
 };
 
+type Env = "client" | "workspace";
+type VisibleGroup = {
+    tagId?: string;
+    tag?: Tag;
+    fields: Field[];
+    fieldIds: string[];
+    parentTags?: Tag[];
+    childrenTags?: Tag[];
+    /** In order of selection: tag base (unless overridden) then selected options */
+    services?: DgpServiceCapability[];
+};
+type VisibleGroupResult = {
+    kind: "single";
+    group: VisibleGroup;
+} | {
+    kind: "multi";
+    groups: string[];
+};
+type ChangeEvt = {
+    ids: string[];
+    primary?: string;
+};
+type Listener = (e: ChangeEvt) => void;
+type SelectionOptions = {
+    env?: Env;
+    rootTagId?: string;
+    /** Resolve service capability from an id (used for `services` array) */
+    resolveService?: (id: any) => DgpServiceCapability | undefined;
+};
+declare class Selection {
+    private readonly builder;
+    private readonly opts;
+    private set;
+    private primaryId;
+    private currentTagId;
+    private onChangeFns;
+    constructor(builder: Builder, opts: SelectionOptions);
+    replace(id?: string | null): void;
+    add(id: string): void;
+    remove(id: string): void;
+    toggle(id: string): void;
+    many(ids: Iterable<string>, primary?: string): void;
+    clear(): void;
+    all(): ReadonlySet<string>;
+    has(id: string): boolean;
+    primary(): string | undefined;
+    currentTag(): string | undefined;
+    onChange(fn: Listener): () => void;
+    visibleGroup(): VisibleGroupResult;
+    /**
+     * Build a fieldId -> triggerKeys[] map from the current selection set.
+     *
+     * What counts as a "button selection" (trigger key):
+     * - field key where the field has button === true (e.g. "f:dripfeed")
+     * - option key (e.g. "o:fast")
+     * - composite key "fieldId::optionId" (e.g. "f:speed::o:fast")
+     *
+     * Grouping:
+     * - button-field trigger groups under its own fieldId
+     * - option/composite groups under the option's owning fieldId (from nodeMap)
+     *
+     * Deterministic:
+     * - preserves selection insertion order
+     * - de-dupes per field
+     */
+    buttonSelectionsByFieldId(): Record<string, string[]>;
+    /**
+     * Returns only selection keys that are valid "trigger buttons":
+     * - field keys where field.button === true
+     * - option keys
+     * - composite keys "fieldId::optionId" (validated by optionId)
+     * Excludes tags and non-button fields.
+     */
+    selectedButtons(): string[];
+    private emit;
+    private updateCurrentTagFrom;
+    private resolveTagContextId;
+    private computeGroupForTag;
+    private addServiceByRole;
+    private findOptionById;
+}
+
+type EditorEvents = {
+    "editor:command": {
+        name: string;
+        payload?: any;
+    };
+    "editor:change": {
+        props: ServiceProps;
+        reason: string;
+        command?: string;
+    };
+    "editor:undo": {
+        stackSize: number;
+        index: number;
+    };
+    "editor:redo": {
+        stackSize: number;
+        index: number;
+    };
+    "editor:error": {
+        message: string;
+        code?: string;
+        meta?: any;
+    };
+};
+type Command = {
+    name: string;
+    do(): void;
+    undo(): void;
+};
+type EditorOptions = {
+    historyLimit?: number;
+    validateAfterEach?: boolean;
+    /** Sync existence check; return true if the service exists. */
+    serviceExists?: (id: number) => boolean;
+    /** Optional local index; used if serviceExists is not provided. */
+    serviceMap?: Record<number, unknown>;
+    /** Raw policies JSON; will be compiled on demand by filterServicesForVisibleGroup. */
+    policiesRaw?: unknown;
+    selectionProps?: SelectionOptions;
+};
+type ConnectKind = "bind" | "include" | "exclude";
+
 /** Exported alias so the schema generator can target an array */
 type AdminPolicies = DynamicRule[];
 
@@ -1242,6 +1339,9 @@ declare class Editor {
     private stagedBefore?;
     private _lastPolicyDiagnostics?;
     constructor(builder: Builder, api: CanvasAPI, opts?: EditorOptions);
+    isTagId(id: string): boolean;
+    isFieldId(id: string): boolean;
+    isOptionId(id: string): boolean;
     getProps(): ServiceProps;
     transact(label: string, fn: () => void): void;
     exec(cmd: Command): void;
@@ -1470,60 +1570,79 @@ declare class CanvasAPI {
     getServiceProps(): ServiceProps;
 }
 
-type FormSnapshot = {
-    values: Record<string, Scalar | Scalar[]>;
-    selections: Record<string, string[]>;
-};
+type Dict = Record<string, unknown>;
+type FormSnapshot = Dict;
 type FormApi = {
-    /** Scalar/array value by fieldId (non-option inputs) */
-    get: (fieldId: string) => Scalar | Scalar[] | undefined;
-    set: (fieldId: string, value: Scalar | Scalar[]) => void;
-    /** Option selections by fieldId (array of optionIds) */
+    /** Value by fieldId (Wrapper uses name=field.id) */
+    get: (fieldId: string) => unknown;
+    /**
+     * Programmatic set (NOT used by Wrapper).
+     * If the field is mounted, writes into the core.
+     * If not mounted, persists into core.bucket (via core.setValue) or local bag fallback.
+     */
+    set: (fieldId: string, value: unknown) => void;
+    /** Option selections (legacy; kept for compatibility) */
     getSelections: (fieldId: string) => string[];
     setSelections: (fieldId: string, optionIds: string[]) => void;
     toggleSelection: (fieldId: string, optionId: string) => void;
-    /** Read-only snapshot for debugging */
+    removeSelectionToken(token: string): void;
+    /** Read-only snapshot for debugging (NO validation) */
     snapshot: () => FormSnapshot;
     /** Simple subscribe (re-render triggers) */
     subscribe: (fn: () => void) => () => void;
+    /**
+     * Validation gate:
+     * local submit runs validation and returns mounted/visible values.
+     * (This is NOT “submitting to a server”.)
+     */
+    submit: () => {
+        values: Dict;
+        valid: boolean;
+    };
 };
-declare function FormProvider({ initial, children, }: {
-    initial?: Partial<FormSnapshot>;
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
-/** Strict hook (throws if no provider) */
 declare function useFormApi(): FormApi;
-/** Optional hook (returns null if no provider) */
 declare function useOptionalFormApi(): FormApi | null;
-/** Field-scoped helpers */
-declare function useFormField(fieldId: string): {
-    value: Scalar | Scalar[] | undefined;
-    set: (value: Scalar | Scalar[]) => void;
-};
-declare function useFormSelections(fieldId: string): {
-    selected: string[];
-    set: (optionIds: string[]) => void;
-    toggle: (optionId: string) => void;
+type FormProviderProps = {
+    children: ReactNode;
+    /** Optional schema (zod/jsonschema/etc, depending on your palette build) */
+    schema?: any;
+    /**
+     * Same shape as the old OrderFlowProvider usage.
+     * - values: seed values (persisted/rehydrated)
+     * - selections: legacy (kept for compatibility)
+     */
+    initial?: {
+        values?: Dict;
+        selections?: Record<string, string[]>;
+    };
 };
+declare function FormProvider({ children, schema, initial }: FormProviderProps): react_jsx_runtime.JSX.Element;
 
 /** Matches your InputWrapper’s expectations */
 type InputKind = string;
-type InputVariant = 'default' | (string & {});
-type InputAdapter = {
-    /** Prop name where the value goes on the host component (default: "value") */
+type InputVariant = "default" | (string & {});
+type AdapterCtx = {
+    field: Field;
+    props: ServiceProps;
+};
+type Adapter = {
     valueProp?: string;
-    /** Prop name of the change handler on the host component (default: "onChange") */
     changeProp?: string;
-    /**
-     * Normalize the host's change payload into a Scalar | Scalar[] your form will store.
-     * If omitted, `next as Scalar | Scalar[]` is used.
-     */
-    getValue?: (next: unknown, prev: unknown) => Scalar | Scalar[];
+    errorProp?: string;
+    /** normalize what the host emitted into what we store in form-palette */
+    getValue?: (next: unknown, current: unknown, ctx: AdapterCtx) => unknown;
+    /** REQUIRED if field.options exists */
+    getSelectedOptions?: (next: unknown, current: unknown, ctx: AdapterCtx) => string[];
+    /** For option-less action buttons (button: true with no options) */
+    isActive?: (stored: unknown, ctx: AdapterCtx) => boolean;
+    getInputPropsFromField?: (props: AdapterCtx) => any;
+    toValue?: (value: any) => any;
 };
 type InputDescriptor = {
     Component: React.ComponentType<Record<string, unknown>>;
-    adapter?: InputAdapter;
+    adapter?: Adapter;
     defaultProps?: Record<string, unknown>;
+    ui?: Record<string, Ui>;
 };
 type VariantMap = Map<InputVariant, InputDescriptor>;
 type RegistryStore = Map<InputKind, VariantMap>;
@@ -1563,10 +1682,174 @@ declare function useInputs(): InputsCtxValue;
 type InputWrapperProps = {
     field: Field;
     disabled?: boolean;
-    /** Extra props to forward to the host component (low priority, overridden by adapter wiring). */
     extraProps?: Record<string, unknown>;
+    templateStrings?: boolean;
+    ctxOverrides?: Record<string, unknown>;
+    className?: string;
+};
+declare function Wrapper({ field, disabled, extraProps, templateStrings, ctxOverrides, className, }: InputWrapperProps): react_jsx_runtime.JSX.Element | null;
+
+type OrderFlowInit = {
+    mode?: "prod" | "dev";
+    /** required service map used for snapshot building / rules */
+    services: DgpServiceMap;
+    /** fallback policy overrides */
+    fallback?: FallbackSettings;
+    /** hydrate initial state from snapshot */
+    hydrateFrom?: OrderSnapshot;
+    /** initial tag (ignored if hydrateFrom exists and provides tag) */
+    initialTagId?: string;
+    /** default quantity used by snapshot builder (default 1) */
+    hostDefaultQuantity?: number;
+    /** selection resolver (optional) */
+    resolveService?: (id: number | string) => DgpServiceCapability | undefined;
+    /**
+     * Host props provided to further enhance the nodes data
+     */
+    ctx?: Record<string, unknown>;
+    normalizeRate?(svc: DgpServiceCapability): number;
+};
+type ProviderFlow = {
+    builder: Builder;
+    selection?: Selection;
 };
-type OnChangeValue = ButtonValue | ButtonValue[];
-declare function Wrapper({ field, disabled, extraProps, }: InputWrapperProps): react_jsx_runtime.JSX.Element | null;
+type OrderFlowProviderProps = {
+    /**
+     * Optional at mount time.
+     * If absent, call initialize(...) later (via ref OR hook API).
+     */
+    serviceProps?: ServiceProps;
+    builder?: Builder;
+    flow?: ProviderFlow;
+    builderOptions?: BuilderOptions;
+    /** optional selection override (if not passed in flow) */
+    selection?: Selection;
+    /** Host input registry (maps kind/variant → components) */
+    registry?: Registry;
+    /** Optional now (deferred init supported). */
+    init?: OrderFlowInit;
+    children?: ReactNode;
+};
+type OrderFlowInitializeParams = {
+    serviceProps?: ServiceProps;
+    builder?: Builder;
+    flow?: ProviderFlow;
+    builderOptions?: BuilderOptions;
+    selection?: Selection;
+    init: OrderFlowInit;
+};
+type OrderFlowHandle = {
+    /** whether provider has enough info to run */
+    ready: () => boolean;
+    /** (re)initialize the provider */
+    initialize: (params: OrderFlowInitializeParams) => void;
+    getActiveTag: () => string | undefined;
+    selectTag: (tagId: string) => void;
+    getVisibleGroup: () => ReturnType<Selection["visibleGroup"]>;
+    getSelectionIds: () => string[];
+    clearSelection: () => void;
+    /** Apply snapshot into selection + form values/selections */
+    setSnapshot: (snap: OrderSnapshot, opts?: {
+        clearFirst?: boolean;
+    }) => void;
+    /** Reset tag + clear fields */
+    reset: (opts?: {
+        keepTag?: boolean;
+    }) => void;
+    refresh: () => void;
+};
+type NormalizedInit = Required<Pick<OrderFlowInit, "mode" | "hostDefaultQuantity">> & OrderFlowInit;
+type EnsureReadyResult = {
+    builder: Builder;
+    selection: Selection;
+    init: NormalizedInit;
+};
+type CtxShape = {
+    builder: Builder | null;
+    selection: Selection | null;
+    activeTagId?: string;
+    setActiveTag: (id: string) => void;
+    init: NormalizedInit | null;
+    /** Form API from FormProvider (always available) */
+    formApi: ReturnType<typeof useFormApi>;
+    /** fallback policy (owned here; used by hook) */
+    fallbackPolicy: FallbackSettings;
+    setFallbackPolicy: (next: FallbackSettings) => void;
+    /** imperative helpers exposed to hook */
+    setSnapshot: (snap: OrderSnapshot, opts?: {
+        clearFirst?: boolean;
+    }) => void;
+    reset: (opts?: {
+        keepTag?: boolean;
+    }) => void;
+    /** guards */
+    ready: () => boolean;
+    ensureReady: (op?: string) => EnsureReadyResult;
+    /** init API */
+    initialize: (params: OrderFlowInitializeParams) => void;
+};
+declare function useOrderFlowContext(): CtxShape;
+declare const OrderFlowProvider: React.ForwardRefExoticComponent<OrderFlowProviderProps & React.RefAttributes<OrderFlowHandle>>;
+
+type PricingPreview = {
+    serviceId?: string | number;
+    unitRate: number;
+    base: number;
+    utilities: number;
+    total: number;
+    utilityBreakdown: Array<{
+        nodeId: string;
+        mode: string;
+        amount: number;
+    }>;
+};
+type UseOrderFlowReturn = {
+    ready: boolean;
+    initialize: (params: OrderFlowInitializeParams) => void;
+    activeTagId?: string;
+    /** raw service props */
+    raw: ServiceProps;
+    /** visibility is Selection-only */
+    visibleGroup: VisibleGroup | null;
+    /**
+     * Values are from form-palette (values()) and are already "visible-only"
+     * because your UI mounts only visible fields.
+     */
+    formValuesByFieldId: Record<string, Scalar | Scalar[]>;
+    /**
+     * Selections are Selection-only now.
+     * We keep this for compatibility with buildOrderSnapshot signature,
+     * but we do NOT read it from form anymore.
+     */
+    optionSelectionsByFieldId: Record<string, string[]>;
+    quantityPreview: number;
+    services: Array<string | number>;
+    serviceMap: Record<string, Array<string | number>>;
+    pricingPreview: PricingPreview;
+    min: number;
+    max: number;
+    selectTag: (tagId: string) => void;
+    toggleOption: (fieldId: string, optionId?: string) => void;
+    /** programmatic value set (rare; wrapper/field hook should handle most) */
+    setValue: (fieldId: string, value: Scalar | Scalar[]) => void;
+    clearField: (fieldId: string) => void;
+    reset: (opts?: {
+        keepTag?: boolean;
+    }) => void;
+    setSnapshot: (snap: OrderSnapshot, opts?: {
+        clearFirst?: boolean;
+    }) => void;
+    /** VALIDATES via form.submit() */
+    buildSnapshot: () => OrderSnapshot | undefined;
+    fallbackPolicy: FallbackSettings;
+    setFallbackPolicy: (next: FallbackSettings) => void;
+};
+declare function useOrderFlow(): UseOrderFlowReturn;
+
+/**
+ * Register all built-in entries.
+ * - You said "variant is the only thing necessary", so we treat kind as a constant.
+ */
+declare function registerEntries(registry: Registry): void;
 
-export { type AdminPolicies, type BaseFieldUI, type ButtonValue, CanvasAPI, type CanvasEvents, type CanvasOptions, type CanvasState, type Command, type CommentAnchor, type CommentId, type CommentMessage, type CommentNode, type CommentThread, type ConnectKind, type ConstraintKey, type DgpServiceCapability, type DgpServiceMap, type DraftWire, type DynamicRule, type EdgeKind, type EdgeRoute, type EdgeView, type EditorEvents, type EditorOptions, type EditorSnapshot, EventBus, type EventMap, type FallbackDiagnostics, type FallbackSettings, type Field, type FieldOption, type FieldType, type FieldWithTypedDefaults, type FlagKey, type FlowNode, type FormApi, FormProvider, type FormSnapshot, type GraphEdge, type GraphNode, type GraphSnapshot, type IdType, type InputAdapter, type InputDescriptor, type InputKind, type InputVariant, type InputWrapperProps, type LayoutState, type NodeIdRef, type NodeKind, type NodePos, type NodePositions, type NodeView, type OnChangeValue, type OrderSnapshot, type PricingRole, Provider, type QuantityMark, type QuantityRule$1 as QuantityRule, type RatePolicy, type Registry, type Scalar, type ServiceEstimates, type ServiceFallback, type ServiceFallbacks, type ServiceFlag, type ServiceFlags, type ServiceIdRef, type ServiceProps, type ServiceWhereClause, type ServiceWhereOp, type SnapshotContext, type SpeedEstimate, type Tag, type ThreadId, type TimeRangeEstimate, type Ui, type UiAnyOf, type UiArray, type UiBoolean, type UiNumber, type UiObject, type UiString, type UiValue, type UtilityLineItem, type UtilityMark, type UtilityMode, type ValidationCode, type ValidationError, type ValidatorOptions, type Viewport, type WithQuantityDefault, Wrapper, createInputRegistry, resolveInputDescriptor, useFormApi, useFormField, useFormSelections, useInputs, useOptionalFormApi };
+export { type Adapter, type AdapterCtx, type AdminPolicies, type BaseFieldUI, type ButtonValue, CanvasAPI, type CanvasEvents, type CanvasOptions, type CanvasState, type Command, type CommentAnchor, type CommentId, type CommentMessage, type CommentNode, type CommentThread, type ConnectKind, type ConstraintKey, type DgpServiceCapability, type DgpServiceMap, type DraftWire, type DynamicRule, type EdgeKind, type EdgeRoute, type EdgeView, type EditorEvents, type EditorOptions, type EditorSnapshot, EventBus, type EventMap, type FallbackDiagnostics, type FallbackSettings, type Field, type FieldOption, type FieldType, type FieldWithTypedDefaults, type FlagKey, type FlowNode, type FormApi, FormProvider, type FormProviderProps, type FormSnapshot, type GraphEdge, type GraphNode, type GraphSnapshot, type IdType, type InputDescriptor, type InputKind, type InputVariant, type InputWrapperProps, type LayoutState, type NodeIdRef, type NodeKind, type NodePos, type NodePositions, type NodeView, type NoticeKind, type NoticeSeverity, type NoticeTarget, type NoticeType, OrderFlowProvider, type OrderSnapshot, type PricingRole, Provider, type QuantityMark, type QuantityRule$1 as QuantityRule, type RatePolicy, type Registry, type Scalar, type ServiceEstimates, type ServiceFallback, type ServiceFallbacks, type ServiceFlag, type ServiceFlags, type ServiceIdRef, type ServiceProps, type ServicePropsNotice, type ServiceWhereClause, type ServiceWhereOp, type SnapshotContext, type SpeedEstimate, type Tag, type ThreadId, type TimeRangeEstimate, type Ui, type UiAnyOf, type UiArray, type UiBoolean, type UiNumber, type UiObject, type UiString, type UiValue, type UtilityLineItem, type UtilityMark, type UtilityMode, type ValidationCode, type ValidationError, type ValidatorOptions, type Viewport, type WithQuantityDefault, Wrapper, createInputRegistry, registerEntries, resolveInputDescriptor, useFormApi, useInputs, useOptionalFormApi, useOrderFlow, useOrderFlowContext };