@collective-intelligence/extensions-sdk-frontend-react 0.0.0-stage → 0.1.0

package/dist/workflows/contracts.d.ts

@@ -0,0 +1,358 @@
+/**
+ * Dashboard-owned presentation contracts for workflow authoring.
+ *
+ * These contracts deliberately contain only JSON-compatible values. The
+ * Dashboard transport owns generated DTOs and adapts them at its boundary.
+ */
+import type { WorkflowEditorValueSource, WorkflowEditorVisibilityRule as DeclaredVisibilityRule, WorkflowTemplateKind } from "@collective-intelligence/extensions-sdk";
+/**
+ * Keep the authoring model's JSON recursive type local to this package.
+ * Generated clients expose the same wire shape as a recursive index-signature
+ * alias, but referring to that alias here causes TypeScript to re-expand it
+ * through every dashboard presentation contract.
+ */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = Record<string, JsonValue>;
+export type WorkflowJsonSchema = JsonObject;
+export interface FixedValue extends JsonObject {
+    mode: "fixed";
+    value: JsonValue;
+}
+export interface ExpressionValueEnvelopeInput extends JsonObject {
+    mode: "expression";
+    languageVersion: 1;
+    source: string;
+}
+export type WorkflowAuthoredValue = FixedValue | ExpressionValueEnvelopeInput;
+export interface WorkflowAuthoredConditionComparison {
+    kind: "comparison";
+    left: WorkflowAuthoredValue;
+    operator: string;
+    right?: WorkflowAuthoredValue | null;
+}
+export interface WorkflowAuthoredConditionGroup {
+    conditions: WorkflowAuthoredCondition[];
+    kind: "group";
+    negated?: boolean;
+    operator: "and" | "or";
+}
+export type WorkflowAuthoredCondition = WorkflowAuthoredConditionComparison | WorkflowAuthoredConditionGroup;
+export type WorkflowExpressionValueType = "any" | "array" | "boolean" | "datetime" | "null" | "number" | "object" | "string";
+export interface WorkflowEditorSourceSelector {
+    kind: "same" | "previous" | "all" | "first" | "last" | "index" | "aggregate";
+}
+export interface WorkflowExpressionFunctionSignature {
+    name: string;
+    inputs: WorkflowExpressionValueType[];
+    result: WorkflowExpressionValueType;
+    minimumArgs: number;
+    maximumArgs: number;
+    example?: string;
+}
+export interface WorkflowExpressionLanguageManifest {
+    version: 1;
+    grammar: string;
+    interpolation: {
+        wholeValuePreservesType: boolean;
+        mixedTextReturns: WorkflowExpressionValueType;
+    };
+    selectors: WorkflowEditorSourceSelector[];
+    availabilityPolicies: ("required" | "nullable" | "default")[];
+    operators: string[];
+    functions: WorkflowExpressionFunctionSignature[];
+    pipes: string[];
+    ifExamples: string[];
+    comparators: WorkflowExpressionFunctionSignature[];
+}
+export type WorkflowEditorSourceAvailability = "guaranteed" | "conditional";
+export interface WorkflowEditorSourceField {
+    id: string;
+    label: string;
+    path: (string | number)[];
+    schema: WorkflowJsonSchema;
+    availability: WorkflowEditorSourceAvailability;
+    children?: WorkflowEditorSourceField[];
+}
+export interface WorkflowEditorSource {
+    id: string;
+    kind: "workflow_input" | "node_output";
+    label: string;
+    schema: WorkflowJsonSchema;
+    availability?: WorkflowEditorSourceAvailability;
+    nodeKey?: string | null;
+    nodeId?: string | null;
+    portId?: string | null;
+    selectors?: WorkflowEditorSourceSelector[];
+    fields?: WorkflowEditorSourceField[];
+}
+export interface WorkflowEditorTargetCompatibility {
+    binding: {
+        target: "input_binding" | "parameter";
+        path: (string | number)[];
+    };
+    acceptsExpression: boolean;
+    targetSchema: WorkflowJsonSchema;
+}
+export interface WorkflowExpressionValidationDiagnostic {
+    code: string;
+    severity: "info" | "warning" | "error";
+    message: string;
+    span: {
+        start: number;
+        end: number;
+    };
+    remediation: string;
+    expectedSchema: WorkflowJsonSchema | null;
+    actualSchema: WorkflowJsonSchema | null;
+}
+export interface WorkflowExpressionValidationReference {
+    sourceId: string;
+    path: (string | number)[];
+    span: {
+        start: number;
+        end: number;
+    };
+}
+export interface WorkflowNodeEditorProjection {
+    availableSources?: WorkflowEditorSource[];
+    languageManifest: WorkflowExpressionLanguageManifest;
+    targetCompatibility?: WorkflowEditorTargetCompatibility[];
+}
+/** JSON-only authoring projections shared by Dashboard hosts and extensions. */
+export interface WorkflowFieldProjection {
+    fieldConfig?: JsonObject;
+    fieldFqn: string;
+    fieldVersion: string;
+    path: string[];
+}
+export interface WorkflowBindingSource {
+    kind: string;
+    nodeId?: string | null;
+    portId?: string | null;
+    selection?: {
+        ancestry: string;
+        iteration: string;
+    } | null;
+}
+export type WorkflowBindingExpression = {
+    kind: "literal";
+    value: JsonValue;
+} | {
+    kind: "ref";
+    onUnavailable: {
+        kind: "error" | "null" | "fallback";
+        value?: WorkflowBindingExpression | null;
+    };
+    path: (string | number)[];
+    source: WorkflowBindingSource;
+    span?: {
+        end: number;
+        start: number;
+    } | null;
+} | {
+    fields: Record<string, WorkflowBindingExpression>;
+    kind: "object";
+} | {
+    items: WorkflowBindingExpression[];
+    kind: "array";
+} | {
+    args: WorkflowBindingExpression[];
+    kind: "operator";
+    op: string;
+} | {
+    args: WorkflowBindingExpression[];
+    kind: "call";
+    name: string;
+} | {
+    kind: "interpolation";
+    parts: WorkflowBindingExpression[];
+    span?: {
+        end: number;
+        start: number;
+    } | null;
+};
+export type WorkflowOutputBindingExpression = WorkflowBindingExpression;
+export interface WorkflowOutputBinding {
+    key: string;
+    kind: "value" | "artifact";
+    value: WorkflowOutputBindingExpression;
+}
+export interface WorkflowOutputContract {
+    bindings: WorkflowOutputBinding[];
+    fieldProjections?: WorkflowFieldProjection[];
+    jsonSchema: JsonObject;
+}
+/** Chooses a port value schema from fixed structural node configuration. */
+export type WorkflowPortSchemaResolution = {
+    configPath: (string | number)[];
+    variants: {
+        schema: WorkflowJsonSchema;
+        schemaInjections?: {
+            configPath: (string | number)[];
+            schemaPath: (string | number)[];
+        }[];
+        when: JsonValue;
+    }[];
+};
+/**
+ * One node port. Absent `maxConnections` means one connection and `null`
+ * means unbounded; absent allow-lists accept every peer template.
+ */
+export interface WorkflowPortContract {
+    key: string;
+    direction: "input" | "output";
+    allowedTemplateFqns?: string[] | null;
+    allowedTemplateKinds?: WorkflowTemplateKind[] | null;
+    maxConnections?: number | null;
+    minConnections?: number;
+    schemaResolution?: WorkflowPortSchemaResolution;
+    valueSchema?: WorkflowJsonSchema;
+    [key: string]: JsonValue | undefined;
+}
+/**
+ * Ports derived from a configured list: one per item at `configPath`, keyed
+ * by the item's `idPath`. `defaultIdPath` adds one more port whose id is that
+ * configuration value, falling back to its schema default.
+ */
+export interface WorkflowDynamicPortDeclaration {
+    configPath: string;
+    defaultIdPath?: string;
+    idPath: string;
+    requiredPath?: string;
+    schemaPath?: string;
+}
+export type WorkflowLocalizedText = {
+    kind: "literal";
+    text: string;
+} | {
+    kind: "translation";
+    default: string;
+};
+export interface WorkflowFieldBinding {
+    target: "input_binding" | "parameter" | "setting" | "metadata";
+    path: (string | number)[];
+}
+export type WorkflowEditorOptionSource = {
+    kind: "static";
+    options: {
+        label: WorkflowLocalizedText;
+        value: JsonValue;
+    }[];
+} | {
+    clearOnDependencyChange: boolean;
+    dependsOn: WorkflowFieldBinding[];
+    kind: "remote";
+    operationId: string;
+    searchable: boolean;
+};
+export interface WorkflowEditorVisibilityRule {
+    binding: WorkflowFieldBinding;
+    operator: DeclaredVisibilityRule["operator"];
+    value?: JsonValue;
+}
+export interface WorkflowFormField {
+    key: string;
+    binding: WorkflowFieldBinding;
+    label: WorkflowLocalizedText;
+    /**
+     * A projected SDK `WorkflowEditorWidget`. Kept open so hosted renderers
+     * built against this contract tolerate widgets added by a newer host.
+     */
+    widget: string;
+    valueType: string;
+    fieldFqn?: string | null;
+    fieldVersion?: string | null;
+    fieldConfig?: JsonObject;
+    required?: boolean;
+    sensitive?: boolean;
+    readOnly?: boolean;
+    placeholder?: WorkflowLocalizedText | null;
+    valueSources?: WorkflowEditorValueSource[];
+    resolutionPhase?: string;
+    order?: number;
+    help?: WorkflowLocalizedText | null;
+    optionSource?: WorkflowEditorOptionSource;
+    visibleWhen?: WorkflowEditorVisibilityRule[];
+}
+export interface WorkflowEditorSection {
+    key: string;
+    label: JsonValue;
+    order?: number;
+    fields?: WorkflowFormField[];
+}
+export interface WorkflowTemplateContract {
+    kind?: string;
+    ports?: WorkflowPortContract[];
+    dynamicPorts?: {
+        input?: WorkflowDynamicPortDeclaration;
+        output?: WorkflowDynamicPortDeclaration;
+    };
+    inputSchema?: WorkflowJsonSchema;
+    outputSchema?: WorkflowJsonSchema;
+    configSchema?: WorkflowJsonSchema;
+    triggerInput?: {
+        schema: WorkflowJsonSchema;
+        languageManifest: WorkflowExpressionLanguageManifest;
+    };
+    editor?: {
+        form?: {
+            sections?: WorkflowEditorSection[];
+        };
+    };
+    field?: WorkflowFieldCatalogContract["field"];
+    collection?: WorkflowFieldCollectionCatalogContract["collection"];
+}
+export interface WorkflowFieldCatalogContract {
+    field: {
+        collectionFqn: string;
+        collectionVersion: string;
+        fqn: string;
+        version: string;
+        configSchema?: WorkflowJsonSchema;
+        valueSchema: WorkflowJsonSchema;
+        availableForInput?: boolean;
+        availableForOutput?: boolean;
+        packageFqn?: string;
+        defaultFor?: string[];
+        parts?: JsonValue[];
+    };
+}
+export interface WorkflowFieldCollectionCatalogContract {
+    collection: {
+        fqn: string;
+        version: string;
+        weight?: number;
+        packageFqn?: string;
+    };
+}
+export interface EffectiveWorkflowCatalogTemplate {
+    id: string;
+    kind: string;
+    fqn: string;
+    version: string;
+    packageFqn: string;
+    label: WorkflowLocalizedText;
+    description: WorkflowLocalizedText;
+    icon: string | null;
+    tags: string[];
+    aliases: string[];
+    order: number;
+    enabled: boolean;
+    state: string;
+    contract: WorkflowTemplateContract;
+}
+export interface EffectiveWorkflowCatalogCategory {
+    id: string;
+    key: string;
+    label: WorkflowLocalizedText;
+    description: WorkflowLocalizedText | null;
+    icon: string | null;
+    children?: EffectiveWorkflowCatalogCategory[];
+    templates?: EffectiveWorkflowCatalogTemplate[];
+}
+export interface EffectiveWorkflowCatalog {
+    categories: EffectiveWorkflowCatalogCategory[];
+    nodeCollections?: JsonValue[];
+}

package/dist/workflows/default-template-ui/actions/catalog-node-chart-block.d.ts

@@ -0,0 +1,7 @@
+import type { WorkflowTemplateUiContext } from "../../workflow-types";
+interface CatalogNodeChartBlockProps {
+    context: WorkflowTemplateUiContext;
+    accent: "sky" | "violet" | "emerald" | "slate";
+}
+export declare const CatalogNodeChartBlock: ({ context, accent }: CatalogNodeChartBlockProps) => import("react").JSX.Element;
+export {};

package/dist/workflows/default-template-ui/actions/catalog-node-details-editor.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowTemplateUiContext } from "../../workflow-types";
+export declare const CatalogNodeDetailsEditor: ({ context }: {
+    context: WorkflowTemplateUiContext;
+}) => import("react").JSX.Element;

package/dist/workflows/default-template-ui/actions/catalog-text.d.ts

@@ -0,0 +1,4 @@
+import type { EffectiveWorkflowCatalogTemplate } from "../../contracts";
+type CatalogText = EffectiveWorkflowCatalogTemplate["label"];
+export declare const catalogText: (value: CatalogText | null | undefined) => string;
+export {};

package/dist/workflows/default-template-ui/actions/translations.d.ts

@@ -0,0 +1,3 @@
+export declare const workflowNodeTranslations: {
+    readonly noEditableFields: "This template does not expose editable fields.";
+};

package/dist/workflows/default-template-ui/declarations.d.ts

@@ -0,0 +1,33 @@
+export declare const defaultWorkflowTemplateDeclarations: readonly [Readonly<{
+    kind: "component";
+    target: import("@collective-intelligence/extensions-sdk-frontend").FrontendBinding;
+    implementation: Readonly<{
+        render: import("@collective-intelligence/extensions-sdk-frontend").FrontendModuleReference;
+        [role: string]: import("@collective-intelligence/extensions-sdk-frontend").FrontendModuleReference;
+    }>;
+    metadata: import("@collective-intelligence/extensions-sdk").JsonObject;
+}>, Readonly<{
+    kind: "component";
+    target: import("@collective-intelligence/extensions-sdk-frontend").FrontendBinding;
+    implementation: Readonly<{
+        render: import("@collective-intelligence/extensions-sdk-frontend").FrontendModuleReference;
+        [role: string]: import("@collective-intelligence/extensions-sdk-frontend").FrontendModuleReference;
+    }>;
+    metadata: import("@collective-intelligence/extensions-sdk").JsonObject;
+}>, Readonly<{
+    kind: "component";
+    target: import("@collective-intelligence/extensions-sdk-frontend").FrontendBinding;
+    implementation: Readonly<{
+        render: import("@collective-intelligence/extensions-sdk-frontend").FrontendModuleReference;
+        [role: string]: import("@collective-intelligence/extensions-sdk-frontend").FrontendModuleReference;
+    }>;
+    metadata: import("@collective-intelligence/extensions-sdk").JsonObject;
+}>, Readonly<{
+    kind: "component";
+    target: import("@collective-intelligence/extensions-sdk-frontend").FrontendBinding;
+    implementation: Readonly<{
+        render: import("@collective-intelligence/extensions-sdk-frontend").FrontendModuleReference;
+        [role: string]: import("@collective-intelligence/extensions-sdk-frontend").FrontendModuleReference;
+    }>;
+    metadata: import("@collective-intelligence/extensions-sdk").JsonObject;
+}>];

package/dist/workflows/default-template-ui/renderers.d.ts

@@ -0,0 +1,9 @@
+import type { WorkflowTemplateUiContext } from "../workflow-types";
+export declare const renderDefaultActionChart: (context: WorkflowTemplateUiContext) => import("react").JSX.Element;
+export declare const renderDefaultActionDetails: (context: WorkflowTemplateUiContext) => import("react").JSX.Element;
+export declare const renderDefaultTriggerChart: (context: WorkflowTemplateUiContext) => import("react").JSX.Element;
+export declare const renderDefaultTriggerDetails: (context: WorkflowTemplateUiContext) => import("react").JSX.Element;
+export declare const renderDefaultInputChart: (context: WorkflowTemplateUiContext) => import("react").JSX.Element;
+export declare const renderDefaultInputDetails: (context: WorkflowTemplateUiContext) => import("react").JSX.Element;
+export declare const renderDefaultOutputChart: (context: WorkflowTemplateUiContext) => import("react").JSX.Element;
+export declare const renderDefaultOutputDetails: (context: WorkflowTemplateUiContext) => import("react").JSX.Element;

package/dist/workflows/default-template-ui/triggers/translations.d.ts

@@ -0,0 +1,4 @@
+export declare const workflowTriggerTranslations: {
+    readonly inputBindingsDescription: "Map workflow input field names to literal or dynamic expressions.";
+    readonly inputBindingsTitle: "Input adapter bindings";
+};

package/dist/workflows/default-template-ui/triggers/trigger-details-editor.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowTemplateUiContext } from "../../workflow-types";
+export declare const TriggerDetailsEditor: ({ context }: {
+    context: WorkflowTemplateUiContext;
+}) => import("react").JSX.Element;

package/dist/workflows/default-template-ui/triggers/trigger-expression-environment.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowTemplateContract } from "../../contracts";
+import type { ExpressionEnvironment } from "../../expressions/domain";
+/** Build the expression browser source tree for one trigger's event payload. */
+export declare const triggerExpressionEnvironment: (contract: Pick<WorkflowTemplateContract, "triggerInput">) => ExpressionEnvironment | undefined;

package/dist/workflows/expression-editor/expression-editor.d.ts

@@ -0,0 +1,15 @@
+import type { WorkflowJsonSchema } from "../contracts";
+import type { ExpressionEnvironment, ExpressionValidation } from "../expressions/domain";
+export declare const expressionValidationErrorMessage: (cause: unknown) => string;
+export declare const ExpressionEditor: ({ describedBy, environment, inputLabel, source, onChange, validate, multiline, readOnly, targetSchema }: {
+    describedBy?: string;
+    environment: ExpressionEnvironment;
+    inputLabel?: string;
+    source: string;
+    onChange: (source: string) => void;
+    validate?: (source: string, signal: AbortSignal) => Promise<ExpressionValidation>;
+    multiline?: boolean;
+    readOnly?: boolean;
+    /** Schema of the bound field; ranks suggestions and proposes fixing pipes. */
+    targetSchema?: WorkflowJsonSchema | undefined;
+}) => import("react").JSX.Element;

package/dist/workflows/expression-editor/index.d.ts

@@ -0,0 +1,3 @@
+export { ExpressionEditor } from "./expression-editor";
+export { ExpressionSyntaxReference } from "./syntax-help-drawer";
+export { expressionSourceOptions, schemaLabel } from "./source-browser";

package/dist/workflows/expression-editor/source-browser.d.ts

@@ -0,0 +1,29 @@
+import type { WorkflowJsonSchema } from "../contracts";
+import type { ExpressionEnvironment } from "../expressions/domain";
+export interface ExpressionSourceOption {
+    id: string;
+    /** Section the option is listed under: one per upstream node output. */
+    group: Readonly<{
+        id: string;
+        label: string;
+    }>;
+    /** Full accessible label: source plus the dotted field path. */
+    label: string;
+    /** Row label: the option's own field name. */
+    name: string;
+    /** Dotted field path inside its source, e.g. `email.from.address`. */
+    pathLabel: string;
+    depth: number;
+    parentId: string | null;
+    /** Whether the option is an object with browsable nested fields. */
+    expandable: boolean;
+    /** Expression reference without delimiters, e.g. `trigger.email.subject`. */
+    reference: string;
+    insertion: string;
+    schema: WorkflowJsonSchema;
+    conditional: boolean;
+    selectors: string[];
+}
+export declare const expressionSourceOptions: (environment: ExpressionEnvironment) => ExpressionSourceOption[];
+/** Human type label such as `string | null`, `object`, or `array of {address, name}`. */
+export declare const schemaLabel: (schema: WorkflowJsonSchema) => string;

package/dist/workflows/expression-editor/syntax-help-drawer.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowExpressionLanguageManifest } from "../contracts";
+/** Rendered in the assisted expression suggestion popover. */
+export declare const ExpressionSyntaxReference: ({ manifest }: {
+    manifest: WorkflowExpressionLanguageManifest;
+}) => import("react").JSX.Element;

package/dist/workflows/expression-editor/translations.d.ts

@@ -0,0 +1,8 @@
+export declare const expressionEditorTranslations: {
+    readonly applyPipes: (pipes: string) => string;
+    readonly expectedType: "Field expects";
+    readonly incompatibleType: "Incompatible type";
+    readonly insertWithPipes: "Insert with the pipes that make this value fit the field";
+    readonly validationFailed: (detail: string) => string;
+    readonly validationUnavailable: "We couldn't validate this expression right now. Check its syntax and referenced values, then try again.";
+};

package/dist/workflows/expressions/domain.d.ts

@@ -0,0 +1,59 @@
+import type { ExpressionValueEnvelopeInput, FixedValue, JsonValue, WorkflowEditorSourceAvailability, WorkflowEditorSourceSelector, WorkflowEditorTargetCompatibility, WorkflowExpressionValidationDiagnostic, WorkflowExpressionValidationReference, WorkflowExpressionLanguageManifest, WorkflowJsonSchema, WorkflowNodeEditorProjection } from "../contracts";
+export type AuthoredExpressionValue = FixedValue | ExpressionValueEnvelopeInput;
+export type ExpressionMode = AuthoredExpressionValue["mode"];
+export interface ExpressionDraft {
+    mode: ExpressionMode;
+    fixed: JsonValue;
+    expression: string;
+}
+export interface ExpressionSourceLeaf {
+    id: string;
+    sourceId: string;
+    label: string;
+    path: (string | number)[];
+    schema: WorkflowJsonSchema;
+    availability: WorkflowEditorSourceAvailability;
+}
+export interface ExpressionSourceBranch {
+    id: string;
+    sourceId: string;
+    label: string;
+    path: (string | number)[];
+    schema: WorkflowJsonSchema;
+    availability: WorkflowEditorSourceAvailability;
+    conditional: boolean;
+    selectors: WorkflowEditorSourceSelector["kind"][];
+    nodeKey?: string;
+    children: (ExpressionSourceBranch | ExpressionSourceLeaf)[];
+}
+export interface ExpressionEnvironment {
+    language: WorkflowExpressionLanguageManifest;
+    sources: ExpressionSourceBranch[];
+    compatibility: WorkflowEditorTargetCompatibility[];
+}
+export type ExpressionDiagnostic = Pick<WorkflowExpressionValidationDiagnostic, "code" | "severity" | "message" | "span" | "remediation"> & {
+    expectedSchema: WorkflowJsonSchema | null;
+    actualSchema: WorkflowJsonSchema | null;
+};
+export interface ExpressionValidation {
+    canonicalSource: string | null;
+    references: WorkflowExpressionValidationReference[];
+    diagnostics: ExpressionDiagnostic[];
+    inferredSchema: WorkflowJsonSchema;
+}
+export interface CursorInsertion {
+    source: string;
+    cursor: number;
+}
+export declare const createExpressionDraft: (value: AuthoredExpressionValue) => ExpressionDraft;
+export declare const serializeExpressionDraft: (draft: ExpressionDraft) => AuthoredExpressionValue;
+export declare const normalizeExpressionEnvironment: (projection: Pick<WorkflowNodeEditorProjection, "availableSources" | "languageManifest" | "targetCompatibility">) => ExpressionEnvironment;
+export declare const normalizeExpressionValidation: (input: {
+    canonicalSource?: string | null;
+    diagnostics?: WorkflowExpressionValidationDiagnostic[];
+    inferredSchema: WorkflowJsonSchema;
+    references?: WorkflowExpressionValidationReference[];
+}) => ExpressionValidation;
+/** Whether a source schema can be bound to a target schema; mirrors the backend typing rules. */
+export declare const isSchemaCompatible: (source: WorkflowJsonSchema, target: WorkflowJsonSchema) => boolean;
+export declare const insertExpressionAtCursor: (source: string, cursor: number, insertion: string) => CursorInsertion;

package/dist/workflows/expressions/typing.d.ts

@@ -0,0 +1,28 @@
+import type { WorkflowJsonSchema } from "../contracts";
+/**
+ * Client-side mirror of the backend expression typing rules
+ * (apps/backend/src/domain/workflows/expression-typing.ts). It only ranks and
+ * labels suggestions; backend validation stays the authoritative diagnostic.
+ */
+type JsonType = "array" | "boolean" | "integer" | "null" | "number" | "object" | "string";
+/** Every JSON type a value of this schema may have; `undefined` means unconstrained. */
+export declare const schemaTypes: (schema: WorkflowJsonSchema) => ReadonlySet<JsonType> | undefined;
+/** Item schema of every array branch. */
+export declare const arrayItems: (schema: WorkflowJsonSchema) => WorkflowJsonSchema;
+/** Whether every value described by `actual` satisfies the type shape of `expected`. */
+export declare const schemaAssignable: (expected: WorkflowJsonSchema, actual: WorkflowJsonSchema) => boolean;
+export type ExpressionCompatibility = {
+    status: "compatible" | "unknown" | "incompatible";
+} | {
+    status: "fixable";
+    pipes: string;
+};
+/**
+ * Ranks a source for a target field: directly assignable, assignable after a
+ * suggested pipe chain (`| coalesce(...)` for nullable values, `| first` for
+ * arrays feeding a scalar), or incompatible.
+ */
+export declare const expressionCompatibility: (source: WorkflowJsonSchema, target?: WorkflowJsonSchema) => ExpressionCompatibility;
+/** Human type label such as `string | null` or `array of {address, name}`. */
+export declare const describeSchema: (schema: WorkflowJsonSchema) => string;
+export {};

package/dist/workflows/field-configuration-resolver.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from "react";
+import type { WorkflowFieldConfigurationContext } from "./workflow-types";
+export declare const WorkflowFieldConfigurationResolver: ({ context }: {
+    context: WorkflowFieldConfigurationContext;
+}) => ReactNode;

package/dist/workflows/field-editor/expression-slots.d.ts

@@ -0,0 +1,35 @@
+import type { JsonValue, WorkflowJsonSchema } from "../contracts";
+import type { AuthoredExpressionValue, ExpressionEnvironment, ExpressionValidation } from "../expressions/domain";
+interface FixedSlotControlProps {
+    describedBy?: string;
+    disabled: boolean;
+    onChange: (value: JsonValue) => void;
+    value: JsonValue;
+}
+export interface ExpressionSlotProps {
+    help?: string;
+    label: string;
+    onValueChange: (value: AuthoredExpressionValue) => void;
+    expressionEditor?: {
+        environment?: ExpressionEnvironment;
+        error?: string;
+        loading?: boolean;
+        validate?: (source: string, signal: AbortSignal) => Promise<ExpressionValidation>;
+        /** Bound field schema; ranks suggestions by type compatibility. */
+        targetSchema?: WorkflowJsonSchema;
+    };
+    readOnly?: boolean;
+    renderFixed: (props: FixedSlotControlProps) => React.ReactNode;
+    resetKey?: string | number;
+    slotId: string;
+    value: AuthoredExpressionValue;
+}
+/**
+ * The expression boundary for a value leaf inside a composite field. The
+ * owning composite keeps row identity, ordering, and structural siblings;
+ * this component only retains and commits the authored value envelope.
+ */
+export declare const ExpressionSlot: ({ help, label, onValueChange, expressionEditor, readOnly, renderFixed, resetKey, slotId, value }: ExpressionSlotProps) => import("react").JSX.Element;
+/** Preserve existing authored envelopes while upgrading legacy fixed leaves. */
+export declare const asExpressionSlotValue: (value: JsonValue) => AuthoredExpressionValue;
+export {};

package/dist/workflows/field-editor/index.d.ts

@@ -0,0 +1,2 @@
+export { WorkflowFieldFrame } from "./workflow-field-frame";
+export type { WorkflowFieldFrameDraft } from "./workflow-field-frame";

package/dist/workflows/field-editor/translations.d.ts

@@ -0,0 +1,7 @@
+export declare const workflowFieldFrameTranslations: {
+    readonly expression: "Expression";
+    readonly expressionHelp: "Calculates a value from the data available when this step runs.";
+    readonly fixed: "Fixed";
+    readonly fixedHelp: "Uses the saved value as written.";
+    readonly modesHelp: "Fixed uses the saved value as written. Expression calculates a value from the data available when the step runs.";
+};