@praxisui/editorial-forms 1.0.0-beta.61

package/index.d.ts

@@ -0,0 +1,438 @@
+import * as _angular_core from '@angular/core';
+import { EnvironmentProviders, Type, InjectionToken } from '@angular/core';
+import * as _praxisui_core from '@praxisui/core';
+import { EditorialProblemType, EditorialThemePreset, EditorialCompliancePreset, EditorialBlock, EditorialDataCollectionBlock, EditorialSolutionDefinition, EditorialTemplateInstance, FormConfig, EditorialBlockVisibilityRule, EditorialHeroBlock, EditorialRichTextBlock, EditorialPolicyListBlock, EditorialTimelineStepsBlock, EditorialReviewSummaryBlock, EditorialContextSummaryBlock, EditorialInfoCardsBlock, EditorialFaqAccordionBlock } from '@praxisui/core';
+
+/**
+ * Root provider entrypoint for the editorial runtime package.
+ *
+ * Intentionally minimal in v1:
+ * - no global singleton graph yet
+ * - no dependency on @praxisui/dynamic-form
+ * - safe to consume from apps without pulling generic form authoring
+ */
+declare function providePraxisEditorialForms(): EnvironmentProviders;
+
+type EditorialRuntimeDiagnosticSeverity = 'info' | 'warning' | 'error';
+type EditorialRuntimeDiagnosticScopeKind = 'global' | 'journey' | 'step' | 'block';
+type EditorialRuntimeDiagnosticCode = 'solution-missing' | 'theme-preset-not-found' | 'compliance-preset-not-found' | 'context-required-missing' | 'compliance-context-required-missing' | 'data-collection-config-missing' | 'data-collection-config-ambiguous' | 'data-collection-adapter-missing' | 'data-collection-invalid' | 'instance-journey-block-conflict' | 'journey-override-target-missing' | 'step-override-target-missing' | 'block-override-invalid' | 'block-override-conflict' | 'block-override-target-missing';
+interface EditorialRuntimeDiagnostic {
+    code: EditorialRuntimeDiagnosticCode;
+    severity: EditorialRuntimeDiagnosticSeverity;
+    message: string;
+    scopeKind?: EditorialRuntimeDiagnosticScopeKind;
+    path?: string;
+    journeyId?: string;
+    journeyLabel?: string;
+    stepId?: string;
+    stepLabel?: string;
+    blockId?: string;
+    blockLabel?: string;
+}
+interface EditorialRuntimeDiagnostics {
+    items: EditorialRuntimeDiagnostic[];
+    hasErrors: boolean;
+    hasWarnings: boolean;
+}
+
+type EditorialResolvedBlockSourceKind = 'solution' | 'themePreset' | 'compliancePreset' | 'instanceJourney' | 'instanceOverride';
+type EditorialResolvedBlockCompositionOperation = 'seed' | 'compliance-append' | 'instance-journey-append' | 'instance-override-append' | 'instance-override-insert-before' | 'instance-override-insert-after' | 'instance-override-replace' | 'instance-override-remove';
+interface EditorialResolvedBlockSourceRef {
+    kind: EditorialResolvedBlockSourceKind;
+    sourceId: string;
+    solutionId?: string;
+    presetId?: string;
+    instanceId?: string;
+    journeyId?: string;
+    stepId?: string;
+    blockId?: string;
+}
+interface EditorialResolvedBlockCompositionEntry {
+    operation: EditorialResolvedBlockCompositionOperation;
+    source: EditorialResolvedBlockSourceRef;
+}
+interface EditorialResolvedBlockProvenance {
+    primarySource: EditorialResolvedBlockSourceRef;
+    trail: EditorialResolvedBlockCompositionEntry[];
+}
+interface EditorialResolvedDataCollectionState {
+    formBlockId: string;
+    formConfigRef?: string;
+    hasInlineFormConfig: boolean;
+    resolvedFormConfigSource: 'block.formConfig' | 'instance.overrides.runtimeFormConfigs' | 'instance.compatibilityFormConfigs' | 'unresolved';
+    resolvedFormConfigLookupKey?: string;
+    hasResolvedFormConfig: boolean;
+    expectedAdapter: 'optional' | 'required';
+    readiness: 'ready' | 'requiresAdapter' | 'missingConfig' | 'invalid';
+}
+type EditorialResolvedBlockBase<TBlock extends EditorialBlock = EditorialBlock> = TBlock & {
+    provenance: EditorialResolvedBlockProvenance;
+};
+type EditorialResolvedDataCollectionBlock = EditorialDataCollectionBlock & {
+    provenance: EditorialResolvedBlockProvenance;
+    dataCollectionState: EditorialResolvedDataCollectionState;
+};
+type EditorialResolvedBlock = EditorialResolvedBlockBase<Exclude<EditorialBlock, EditorialDataCollectionBlock>> | EditorialResolvedDataCollectionBlock;
+interface EditorialResolvedStep {
+    stepId: string;
+    label: string;
+    description?: string;
+    blocks: EditorialResolvedBlock[];
+}
+interface EditorialResolvedJourney {
+    journeyId: string;
+    label: string;
+    description?: string;
+    steps: EditorialResolvedStep[];
+}
+interface EditorialRuntimeSnapshot {
+    solutionId: string | null;
+    instanceId: string | null;
+    title: string | null;
+    description: string | null;
+    problemType: EditorialProblemType | null;
+    context: Record<string, unknown>;
+    effectiveThemePreset: EditorialThemePreset | null;
+    effectiveCompliancePresets: EditorialCompliancePreset[];
+    journeys: EditorialResolvedJourney[];
+    diagnostics: EditorialRuntimeDiagnostics;
+}
+
+interface EditorialRuntimeInput {
+    solution: EditorialSolutionDefinition | null;
+    instance: EditorialTemplateInstance | null;
+    runtimeContext?: Record<string, unknown> | null;
+}
+interface EditorialRuntimeHostConfig {
+    emitOperationalEvents?: boolean;
+    forwardAdapterOperationalEvents?: boolean;
+}
+declare const DEFAULT_EDITORIAL_RUNTIME_HOST_CONFIG: Required<EditorialRuntimeHostConfig>;
+
+type EditorialRuntimeFallbackMode = 'normal' | 'warning' | 'degraded' | 'blocked';
+interface EditorialRuntimeFallbackState {
+    mode: EditorialRuntimeFallbackMode;
+    progressionBlocked: boolean;
+    hasGlobalErrors: boolean;
+    hasActiveStepErrors: boolean;
+    hasWarnings: boolean;
+    requiresEngineAttention: boolean;
+    diagnostics: EditorialRuntimeDiagnostic[];
+    blockingDiagnostics: EditorialRuntimeDiagnostic[];
+}
+interface EditorialRuntimeFallbackScope {
+    journeyId?: string | null;
+    stepId?: string | null;
+}
+declare function deriveRuntimeFallbackState(snapshot: EditorialRuntimeSnapshot, scope?: EditorialRuntimeFallbackScope): EditorialRuntimeFallbackState;
+
+type EditorialRuntimeOperationalEventType = 'diagnostics-emitted' | 'fallback-changed' | 'blocking-error-detected' | 'override-conflict-detected' | 'data-collection-adapter-resolved' | 'data-collection-adapter-missing' | 'data-collection-adapter-incompatible' | 'data-collection-adapter-invalid';
+type EditorialRuntimeOperationalEventSeverity = 'info' | 'warning' | 'error';
+interface EditorialRuntimeOperationalEventBase<TType extends EditorialRuntimeOperationalEventType, TPayload> {
+    eventType: TType;
+    timestamp: number;
+    severity: EditorialRuntimeOperationalEventSeverity;
+    journeyId?: string;
+    stepId?: string;
+    blockId?: string;
+    payload: TPayload;
+}
+type EditorialRuntimeOperationalEvent = EditorialRuntimeOperationalEventBase<'diagnostics-emitted', {
+    diagnostics: EditorialRuntimeDiagnostic[];
+    errorCount: number;
+    warningCount: number;
+    infoCount: number;
+}> | EditorialRuntimeOperationalEventBase<'fallback-changed', {
+    fallback: EditorialRuntimeFallbackState;
+}> | EditorialRuntimeOperationalEventBase<'blocking-error-detected', {
+    diagnostics: EditorialRuntimeDiagnostic[];
+    scope: 'global' | 'step';
+}> | EditorialRuntimeOperationalEventBase<'override-conflict-detected', {
+    diagnostics: EditorialRuntimeDiagnostic[];
+}> | EditorialRuntimeOperationalEventBase<'data-collection-adapter-resolved', {
+    adapterId: string;
+    formBlockId: string;
+}> | EditorialRuntimeOperationalEventBase<'data-collection-adapter-missing', {
+    formBlockId: string;
+    adapterIds: string[];
+}> | EditorialRuntimeOperationalEventBase<'data-collection-adapter-incompatible', {
+    formBlockId: string;
+    adapterIds: string[];
+}> | EditorialRuntimeOperationalEventBase<'data-collection-adapter-invalid', {
+    adapterId: string;
+    formBlockId: string;
+    reason: string;
+}>;
+
+declare class EditorialFormRuntimeComponent {
+    readonly solution: _angular_core.InputSignal<EditorialSolutionDefinition | null>;
+    readonly instance: _angular_core.InputSignal<EditorialTemplateInstance | null>;
+    readonly runtimeContext: _angular_core.InputSignal<Record<string, unknown> | null>;
+    readonly hostConfig: _angular_core.InputSignal<EditorialRuntimeHostConfig | null>;
+    readonly snapshotChange: _angular_core.OutputEmitterRef<EditorialRuntimeSnapshot>;
+    readonly fallbackChange: _angular_core.OutputEmitterRef<EditorialRuntimeFallbackState>;
+    readonly operationalEvent: _angular_core.OutputEmitterRef<EditorialRuntimeOperationalEvent>;
+    private readonly state;
+    private readonly solutionState;
+    private readonly instanceState;
+    private lastSnapshotSignature;
+    private lastDiagnosticsSignature;
+    private lastFallbackSignature;
+    private lastBlockingSignature;
+    private lastOverrideConflictSignature;
+    private readonly runtime;
+    protected readonly snapshot: _angular_core.Signal<EditorialRuntimeSnapshot>;
+    protected readonly resolvedHostConfig: _angular_core.Signal<{
+        emitOperationalEvents: boolean;
+        forwardAdapterOperationalEvents: boolean;
+    }>;
+    protected readonly journeys: _angular_core.Signal<EditorialResolvedJourney[]>;
+    protected readonly activeJourney: _angular_core.Signal<EditorialResolvedJourney | null>;
+    protected readonly activeStep: _angular_core.Signal<EditorialResolvedStep | null>;
+    protected readonly resolvedContext: _angular_core.Signal<Record<string, unknown>>;
+    protected readonly runtimeDiagnostics: _angular_core.Signal<EditorialRuntimeDiagnostics>;
+    protected readonly fallbackState: _angular_core.Signal<EditorialRuntimeFallbackState>;
+    protected readonly diagnosticItems: _angular_core.Signal<EditorialRuntimeDiagnostic[]>;
+    protected readonly globalDiagnostics: _angular_core.Signal<EditorialRuntimeDiagnostic[]>;
+    protected readonly contextualDiagnostics: _angular_core.Signal<EditorialRuntimeDiagnostic[]>;
+    protected readonly diagnosticsErrorCount: _angular_core.Signal<number>;
+    protected readonly diagnosticsWarningCount: _angular_core.Signal<number>;
+    protected readonly diagnosticsInfoCount: _angular_core.Signal<number>;
+    protected readonly activeStepDiagnostics: _angular_core.Signal<EditorialRuntimeDiagnostic[]>;
+    protected readonly activeStepHasErrors: _angular_core.Signal<boolean>;
+    protected readonly activeStepHasWarnings: _angular_core.Signal<boolean>;
+    protected readonly diagnosticsMessage: _angular_core.Signal<"Existem inconsistencias bloqueadoras que impedem a progressao segura do fluxo editorial." | "O runtime esta operando de forma degradada e requer atencao operacional." | "Existem inconsistencias que podem comprometer a experiencia editorial." | "Existem avisos operacionais para revisar nesta instancia editorial.">;
+    protected readonly activeGlobalDiagnostics: _angular_core.Signal<EditorialRuntimeDiagnostic[]>;
+    protected readonly visibleBlocks: _angular_core.Signal<_praxisui_core.EditorialBlock[]>;
+    protected readonly runtimeTitle: _angular_core.Signal<string | null>;
+    protected readonly runtimeDescription: _angular_core.Signal<string | null>;
+    protected readonly runtimeEyebrow: _angular_core.Signal<_praxisui_core.EditorialProblemType | null>;
+    protected readonly fallbackLabel: _angular_core.Signal<"Runtime bloqueado" | "Runtime degradado" | "Runtime com aviso" | "Runtime saudavel">;
+    protected readonly currentStepIndex: _angular_core.Signal<number>;
+    protected readonly hasPreviousStep: _angular_core.Signal<boolean>;
+    protected readonly hasNextStep: _angular_core.Signal<boolean>;
+    constructor();
+    protected selectJourney(journeyId: string): void;
+    protected selectStep(stepId: string): void;
+    protected goToPreviousStep(): void;
+    protected goToNextStep(): void;
+    protected journeyErrorCount(journeyId: string): number;
+    protected journeyWarningCount(journeyId: string): number;
+    protected stepErrorCount(stepId: string): number;
+    protected stepWarningCount(stepId: string): number;
+    protected formatDiagnosticSeverity(item: EditorialRuntimeDiagnostic): string;
+    protected formatDiagnosticScope(item: EditorialRuntimeDiagnostic): string;
+    protected isForwardNavigationBlocked(): boolean;
+    protected isJourneySelectionBlocked(journeyId: string): boolean;
+    protected isStepSelectionBlocked(stepId: string): boolean;
+    protected navigationBlockingMessage(): string;
+    private countDiagnostics;
+    protected emitOperationalEvent(event: EditorialRuntimeOperationalEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorialFormRuntimeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorialFormRuntimeComponent, "praxis-editorial-form-runtime", never, { "solution": { "alias": "solution"; "required": false; "isSignal": true; }; "instance": { "alias": "instance"; "required": false; "isSignal": true; }; "runtimeContext": { "alias": "runtimeContext"; "required": false; "isSignal": true; }; "hostConfig": { "alias": "hostConfig"; "required": false; "isSignal": true; }; }, { "snapshotChange": "snapshotChange"; "fallbackChange": "fallbackChange"; "operationalEvent": "operationalEvent"; }, never, never, true, never>;
+}
+
+type EditorialDataBlockComponentInputs = Record<string, unknown>;
+interface EditorialDataBlockContext {
+    block: EditorialDataCollectionBlock;
+    runtimeContext: Record<string, unknown> | null;
+    solution: EditorialSolutionDefinition | null;
+    instance: EditorialTemplateInstance | null;
+    resolvedFormConfig: FormConfig | null;
+}
+interface EditorialDataBlockAdapter {
+    readonly adapterId: string;
+    readonly displayName?: string;
+    readonly component?: Type<unknown>;
+    resolveComponent?(context: EditorialDataBlockContext): Promise<Type<unknown>> | Type<unknown>;
+    supports?(context: EditorialDataBlockContext): boolean;
+    buildInputs?(context: EditorialDataBlockContext): EditorialDataBlockComponentInputs;
+    validateComponent?(component: Type<unknown>, context: EditorialDataBlockContext): {
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+    };
+}
+declare const EDITORIAL_DATA_BLOCK_ADAPTER: InjectionToken<readonly EditorialDataBlockAdapter[]>;
+interface EditorialDataBlockResolution {
+    source: 'block.formConfig' | 'instance.overrides.runtimeFormConfigs' | 'instance.compatibilityFormConfigs' | 'unresolved';
+    formConfig: FormConfig | null;
+    lookupKey?: string;
+    ambiguous?: boolean;
+    matchedSources?: Array<'block.formConfig' | 'instance.overrides.runtimeFormConfigs' | 'instance.compatibilityFormConfigs'>;
+    matchedKeys?: string[];
+}
+declare function resolveEditorialDataBlockFormConfigDetails(block: EditorialDataCollectionBlock, instance: EditorialTemplateInstance | null): EditorialDataBlockResolution;
+declare function resolveEditorialDataBlockFormConfig(block: EditorialDataCollectionBlock, instance: EditorialTemplateInstance | null): FormConfig | null;
+
+type EditorialDataBlockAdapterResolutionStatus = 'resolved' | 'missing' | 'incompatible';
+interface EditorialDataBlockAdapterResolution {
+    status: EditorialDataBlockAdapterResolutionStatus;
+    adapter: EditorialDataBlockAdapter | null;
+    adapterIds: string[];
+    registrySize: number;
+}
+declare class EditorialDataBlockAdapterRegistry {
+    private readonly adapters;
+    constructor(adapters: ReadonlyArray<EditorialDataBlockAdapter>);
+    resolve(context: EditorialDataBlockContext): EditorialDataBlockAdapterResolution;
+}
+declare function provideEditorialDataBlockAdapter(adapter: EditorialDataBlockAdapter): EnvironmentProviders;
+declare function resolveEditorialDataBlockAdapter(adapters: ReadonlyArray<EditorialDataBlockAdapter>, context: EditorialDataBlockContext): EditorialDataBlockAdapterResolution;
+
+type DataCollectionOutletState = {
+    kind: 'idle';
+} | {
+    kind: 'loading';
+    message: string;
+} | {
+    kind: 'ready';
+} | {
+    kind: 'error';
+    title: string;
+    message: string;
+    details?: string;
+};
+declare class EditorialDataCollectionBlockOutletComponent {
+    private readonly adapters;
+    private readonly adapterRegistry;
+    private loadVersion;
+    private lastAdapterEventSignature;
+    readonly block: _angular_core.InputSignal<EditorialDataCollectionBlock | EditorialResolvedDataCollectionBlock>;
+    readonly runtimeContext: _angular_core.InputSignal<Record<string, unknown> | null>;
+    readonly solution: _angular_core.InputSignal<EditorialSolutionDefinition | null>;
+    readonly instance: _angular_core.InputSignal<EditorialTemplateInstance | null>;
+    readonly operationalEvent: _angular_core.OutputEmitterRef<EditorialRuntimeOperationalEvent>;
+    private readonly resolvedComponent;
+    protected readonly state: _angular_core.WritableSignal<DataCollectionOutletState>;
+    protected readonly adapterContext: _angular_core.Signal<{
+        block: EditorialDataCollectionBlock | EditorialResolvedDataCollectionBlock;
+        runtimeContext: Record<string, unknown> | null;
+        solution: EditorialSolutionDefinition | null;
+        instance: EditorialTemplateInstance | null;
+        resolvedFormConfig: _praxisui_core.FormConfig | null;
+    }>;
+    private readonly resolution;
+    protected readonly adapterResolution: _angular_core.Signal<EditorialDataBlockAdapterResolution>;
+    protected readonly adapter: _angular_core.Signal<EditorialDataBlockAdapter | null>;
+    protected readonly adapterComponent: _angular_core.Signal<Type<unknown> | null>;
+    protected readonly loadingState: _angular_core.Signal<{
+        kind: "loading";
+        message: string;
+    } | null>;
+    protected readonly errorState: _angular_core.Signal<{
+        kind: "error";
+        title: string;
+        message: string;
+        details?: string;
+    } | null>;
+    protected readonly adapterInputs: _angular_core.Signal<{}>;
+    protected readonly fallbackMessage: _angular_core.Signal<string>;
+    constructor();
+    private loadAdapterComponent;
+    private applyResolvedComponent;
+    private emitAdapterResolutionEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorialDataCollectionBlockOutletComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorialDataCollectionBlockOutletComponent, "praxis-editorial-data-collection-block-outlet", never, { "block": { "alias": "block"; "required": true; "isSignal": true; }; "runtimeContext": { "alias": "runtimeContext"; "required": false; "isSignal": true; }; "solution": { "alias": "solution"; "required": false; "isSignal": true; }; "instance": { "alias": "instance"; "required": false; "isSignal": true; }; }, { "operationalEvent": "operationalEvent"; }, never, never, true, never>;
+}
+
+interface EditorialDynamicFormAdapterOptions {
+    component: Type<DynamicFormCompatibleComponent>;
+}
+interface DynamicFormCompatibleComponent {
+    config: FormConfig;
+    formId?: string;
+    editorialContext?: Record<string, unknown> | null;
+}
+declare function createEditorialDynamicFormAdapter(options: EditorialDynamicFormAdapterOptions): EditorialDataBlockAdapter;
+declare function provideEditorialDynamicFormAdapter(options: EditorialDynamicFormAdapterOptions): _angular_core.EnvironmentProviders;
+
+interface ResolveEditorialRuntimeSnapshotInput {
+    solution: EditorialSolutionDefinition | null;
+    instance: EditorialTemplateInstance | null;
+    runtimeContext?: Record<string, unknown> | null;
+}
+declare function resolveEditorialRuntimeSnapshot(input: ResolveEditorialRuntimeSnapshotInput): EditorialRuntimeSnapshot;
+
+declare class EditorialRuntimeState {
+    private readonly journeyId;
+    private readonly stepId;
+    readonly activeJourneyId: _angular_core.Signal<string | null>;
+    readonly activeStepId: _angular_core.Signal<string | null>;
+    connect(solution: () => EditorialSolutionDefinition | null, instance: () => EditorialTemplateInstance | null, runtimeContext: () => Record<string, unknown> | null): {
+        snapshot: () => EditorialRuntimeSnapshot;
+        journeys: () => EditorialResolvedJourney[];
+        activeJourney: () => EditorialResolvedJourney | null;
+        activeStep: () => EditorialResolvedStep | null;
+    };
+    selectJourney(journeyId: string): void;
+    selectStep(stepId: string): void;
+}
+
+declare function resolveActiveJourney<TJourney extends {
+    journeyId: string;
+}>(journeys: ReadonlyArray<TJourney>, journeyId: string | null | undefined): TJourney | null;
+declare function resolveActiveStep<TStep extends {
+    stepId: string;
+}>(journey: {
+    steps: ReadonlyArray<TStep>;
+} | null, stepId: string | null | undefined): TStep | null;
+declare function getVisibleBlocks(blocks: ReadonlyArray<EditorialBlock> | null | undefined, runtimeContext: Record<string, unknown> | null | undefined): EditorialBlock[];
+declare function isBlockVisible(block: EditorialBlock, runtimeContext: Record<string, unknown> | null | undefined): boolean;
+declare function matchesVisibilityRule(rule: EditorialBlockVisibilityRule, runtimeContext: Record<string, unknown> | null | undefined): boolean;
+declare function getValueAtPath(source: Record<string, unknown>, path: string): unknown;
+
+declare class EditorialBlockRendererComponent {
+    readonly block: _angular_core.InputSignal<EditorialBlock>;
+    readonly runtimeContext: _angular_core.InputSignal<Record<string, unknown> | null>;
+    readonly solution: _angular_core.InputSignal<EditorialSolutionDefinition | null>;
+    readonly instance: _angular_core.InputSignal<EditorialTemplateInstance | null>;
+    readonly operationalEvent: _angular_core.OutputEmitterRef<EditorialRuntimeOperationalEvent>;
+    protected readonly hero: _angular_core.Signal<EditorialHeroBlock>;
+    protected readonly richText: _angular_core.Signal<EditorialRichTextBlock>;
+    protected readonly policyList: _angular_core.Signal<EditorialPolicyListBlock>;
+    protected readonly timeline: _angular_core.Signal<EditorialTimelineStepsBlock>;
+    protected readonly review: _angular_core.Signal<EditorialReviewSummaryBlock>;
+    protected readonly contextSummary: _angular_core.Signal<EditorialContextSummaryBlock>;
+    protected readonly infoCards: _angular_core.Signal<EditorialInfoCardsBlock>;
+    protected readonly faq: _angular_core.Signal<EditorialFaqAccordionBlock>;
+    protected readonly dataCollection: _angular_core.Signal<EditorialDataCollectionBlock>;
+    protected readonly customWidget: _angular_core.Signal<_praxisui_core.EditorialCustomWidgetBlock>;
+    protected resolveValue(valuePath?: string, fallback?: string): string;
+    protected resolveContextPath(valuePath?: string): string | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorialBlockRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorialBlockRendererComponent, "praxis-editorial-block-renderer", never, { "block": { "alias": "block"; "required": true; "isSignal": true; }; "runtimeContext": { "alias": "runtimeContext"; "required": false; "isSignal": true; }; "solution": { "alias": "solution"; "required": false; "isSignal": true; }; "instance": { "alias": "instance"; "required": false; "isSignal": true; }; }, { "operationalEvent": "operationalEvent"; }, never, never, true, never>;
+}
+
+declare class HarnessDataEngineComponent {
+    config: FormConfig;
+    formId?: string;
+    editorialContext: Record<string, unknown> | null;
+    block: EditorialDataCollectionBlock | null;
+    runtimeContext: Record<string, unknown> | null;
+    solution: EditorialSolutionDefinition | null;
+    instance: EditorialTemplateInstance | null;
+    resolvedFormConfig: FormConfig | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HarnessDataEngineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HarnessDataEngineComponent, "praxis-editorial-harness-data-engine", never, { "config": { "alias": "config"; "required": false; }; "formId": { "alias": "formId"; "required": false; }; "editorialContext": { "alias": "editorialContext"; "required": false; }; "block": { "alias": "block"; "required": false; }; "runtimeContext": { "alias": "runtimeContext"; "required": false; }; "solution": { "alias": "solution"; "required": false; }; "instance": { "alias": "instance"; "required": false; }; "resolvedFormConfig": { "alias": "resolvedFormConfig"; "required": false; }; }, {}, never, never, true, never>;
+}
+interface EditorialRuntimeFixture {
+    id: string;
+    title: string;
+    input: EditorialRuntimeInput;
+    expectedFallbackMode: EditorialRuntimeFallbackMode;
+    expectsAdapter: boolean;
+}
+interface EditorialRuntimeHarnessCatalog {
+    healthy: EditorialRuntimeFixture;
+    warning: EditorialRuntimeFixture;
+    globalError: EditorialRuntimeFixture;
+    dataCollectionMissingAdapter: EditorialRuntimeFixture;
+    dataCollectionWithAdapter: EditorialRuntimeFixture;
+}
+declare function createEditorialRuntimeHarnessCatalog(): EditorialRuntimeHarnessCatalog;
+declare function getHarnessDataEngineComponent(): Type<unknown>;
+
+export { DEFAULT_EDITORIAL_RUNTIME_HOST_CONFIG, EDITORIAL_DATA_BLOCK_ADAPTER, EditorialBlockRendererComponent, EditorialDataBlockAdapterRegistry, EditorialDataCollectionBlockOutletComponent, EditorialFormRuntimeComponent, EditorialRuntimeState, HarnessDataEngineComponent, createEditorialDynamicFormAdapter, createEditorialRuntimeHarnessCatalog, deriveRuntimeFallbackState, getHarnessDataEngineComponent, getValueAtPath, getVisibleBlocks, isBlockVisible, matchesVisibilityRule, provideEditorialDataBlockAdapter, provideEditorialDynamicFormAdapter, providePraxisEditorialForms, resolveActiveJourney, resolveActiveStep, resolveEditorialDataBlockAdapter, resolveEditorialDataBlockFormConfig, resolveEditorialDataBlockFormConfigDetails, resolveEditorialRuntimeSnapshot };
+export type { DynamicFormCompatibleComponent, EditorialDataBlockAdapter, EditorialDataBlockAdapterResolution, EditorialDataBlockAdapterResolutionStatus, EditorialDataBlockComponentInputs, EditorialDataBlockContext, EditorialDataBlockResolution, EditorialDynamicFormAdapterOptions, EditorialResolvedBlock, EditorialResolvedBlockBase, EditorialResolvedBlockCompositionEntry, EditorialResolvedBlockCompositionOperation, EditorialResolvedBlockProvenance, EditorialResolvedBlockSourceKind, EditorialResolvedBlockSourceRef, EditorialResolvedDataCollectionBlock, EditorialResolvedDataCollectionState, EditorialResolvedJourney, EditorialResolvedStep, EditorialRuntimeDiagnostic, EditorialRuntimeDiagnosticCode, EditorialRuntimeDiagnosticScopeKind, EditorialRuntimeDiagnosticSeverity, EditorialRuntimeDiagnostics, EditorialRuntimeFallbackMode, EditorialRuntimeFallbackScope, EditorialRuntimeFallbackState, EditorialRuntimeFixture, EditorialRuntimeHarnessCatalog, EditorialRuntimeHostConfig, EditorialRuntimeInput, EditorialRuntimeOperationalEvent, EditorialRuntimeOperationalEventBase, EditorialRuntimeOperationalEventSeverity, EditorialRuntimeOperationalEventType, EditorialRuntimeSnapshot, ResolveEditorialRuntimeSnapshotInput };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@praxisui/editorial-forms",
+  "version": "1.0.0-beta.61",
+  "description": "Editorial form runtime for Praxis UI: journeys, presets, semantic blocks, and specialist hosting for editorial experiences.",
+  "peerDependencies": {
+    "@angular/common": "^20.0.0",
+    "@angular/core": "^20.0.0",
+    "@praxisui/core": "^1.0.0-beta.61"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codexrodrigues/praxis-ui-angular"
+  },
+  "homepage": "https://praxisui.dev",
+  "bugs": {
+    "url": "https://github.com/codexrodrigues/praxis-ui-angular/issues"
+  },
+  "keywords": [
+    "angular",
+    "praxisui",
+    "editorial",
+    "forms",
+    "journeys",
+    "presets",
+    "runtime"
+  ],
+  "sideEffects": false,
+  "module": "fesm2022/praxisui-editorial-forms.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/praxisui-editorial-forms.mjs"
+    }
+  }
+}