@sdux-vault/shared 0.0.10

package/types/sdux-vault-shared.d.ts

@@ -0,0 +1,1801 @@
+import { Observable, Subject } from 'rxjs';
+
+/**
+ * Extends the global Window object with optional SDuX monitoring and DevTools references.
+ * This declaration defines the global attachment points used to expose runtime singletons.
+ */
+declare global {
+    interface Window {
+        /**
+         * Optional container for globally exposed SDuX runtime instances.
+         */
+        sdux?: SDuXShape;
+    }
+    /**
+     * Optional global reference to SDuX runtime instances.
+     */
+    var sdux: SDuXShape | undefined;
+}
+
+interface BehaviorClassContext {
+    /**
+     * The unique key of the FeatureCell that this behavior instance is
+     * operating within. Used to scope behavior execution to a specific cell.
+     */
+    readonly featureCellKey: string;
+    readonly behaviorConfig?: unknown;
+    readonly licensePayload?: unknown;
+}
+
+/**
+ * Canonical error representation emitted by the Vault pipeline.
+ *
+ * `VaultError` normalizes thrown values from any pipeline stage into a
+ * consistent shape that addon error behaviors can transform and that
+ * consumers can observe from the global VaultErrorPublicService signal.
+ */
+interface VaultErrorShape {
+    /**
+     * Human-readable error message.
+     */
+    message: string;
+    /**
+     * Optional FeatureCell key.
+     */
+    featureCellKey: string;
+    /**
+     * Timestamp (epoch ms) when the error occurred.
+     * Enables reactive timelines and differentiating repeated errors.
+     */
+    timestamp: number;
+    /**
+     * Raw thrown value captured before any normalization.
+     * Useful for debugging, logging, and devtools visualization.
+     */
+    raw: unknown;
+    /**
+     * Optional numeric status (HTTP or domain).
+     */
+    status?: number;
+    /**
+     * Optional textual status text (e.g., HTTP status text).
+     */
+    statusText?: string;
+    /**
+     * Additional diagnostic or domain-specific details.
+     */
+    details?: unknown;
+}
+
+/**
+ * Defines the immutable snapshot shape representing FeatureCell state at a specific moment.
+ * This interface exposes loading, value, and error indicators used by consumers to reason about current state.
+ *
+ * --RelatedStart--
+ * VaultErrorShape
+ * --RelatedEnd--
+ */
+interface StateSnapshotShape<T> {
+    /**
+     * Indicates whether the state is currently in a loading phase.
+     */
+    isLoading: boolean;
+    /**
+     * The resolved value for this snapshot, or `undefined` when no value exists.
+     */
+    value: T | undefined;
+    /**
+     * Error associated with the state at this moment, or `null` if no error is present.
+     */
+    error: VaultErrorShape | null;
+    /**
+     * Whether the snapshot contains a non-undefined value.
+     */
+    hasValue: boolean;
+}
+
+/**
+ * Callback function signature used for observing errors emitted during
+ * the FeatureCell error-handling pipeline.
+ *
+ * An `ErrorCallback` receives the normalized {@link VaultErrorShape} produced by
+ * the pipeline and a read-only {@link StateSnapshotShape} representing the
+ * FeatureCell’s state at the time the error occurred.
+ *
+ * This callback type performs no transformation of the pipeline value;
+ * implementations are expected to execute side effects only, such as logging
+ * or reporting. Returning a value has no effect on pipeline behavior.
+ *
+ * @typeParam T - The type of the FeatureCell state associated with the callback.
+ */
+type VaultErrorCallback<T> = (error: VaultErrorShape, state: Readonly<StateSnapshotShape<T>>) => void;
+
+declare const StateEmitTypes: {
+    readonly IncomingPipeline: "Incoming Pipeline";
+    readonly FinalizePipeline: "Finalize Pipeline";
+    readonly PipelineError: "Pipeline Error";
+    readonly PipelineDestroy: "Pipeline Destroy";
+    readonly PipelineReset: "Pipeline Reset";
+    readonly AbortController: "Abort Controller";
+    readonly DenyController: "Deny Controller";
+};
+type StateEmitType = (typeof StateEmitTypes)[keyof typeof StateEmitTypes];
+
+interface StateEmitSnapshotShape<T> {
+    snapshot: StateSnapshotShape<T>;
+    options: unknown | undefined;
+    type: StateEmitType;
+}
+
+declare const OperationTypes: {
+    readonly Merge: "merge";
+    readonly Replace: "replace";
+    readonly Initialize: "initialize";
+};
+type OperationType = (typeof OperationTypes)[keyof typeof OperationTypes];
+
+/**
+ * Enumerates the available resolve strategy identifiers used by resolve
+ * behaviors. These identifiers indicate how a FeatureCell obtains its initial
+ * and subsequent state values during the resolve stage of the pipeline.
+ *
+ * - `Value` — Resolve from a synchronous, in-memory value.
+ * - `HttpResource` — Resolve using an HTTP-driven resource behavior.
+ * - `Observable` — Resolve from an observable stream source.
+ * - `Promise` — Resolve from a promise source.
+ */
+declare const ResolveTypes: {
+    readonly HttpResource: "http-resource";
+    readonly Observable: "observable";
+    readonly Promise: "promise";
+    readonly Value: "value";
+};
+/**
+ * Union type representing all supported resolve strategy identifiers.
+ */
+type ResolveType = (typeof ResolveTypes)[keyof typeof ResolveTypes];
+
+/**
+ * Structural interface representing a reactive, asynchronously resolved resource.
+ *
+ * This interface intentionally mirrors the *shape* of Angular’s `HttpResourceRef`
+ * without introducing any framework dependency. It is used by core Vault logic
+ * to interact with resource-backed values in a fully framework-agnostic way.
+ *
+ * Implementations may be backed by:
+ * - Angular `HttpResourceRef`
+ * - Signals
+ * - Observables
+ * - Promises
+ * - Custom adapters or test doubles
+ *
+ * Consumers should treat all methods as **side-effect free** accessors.
+ *
+ * @typeParam T - The resolved value type of the resource.
+ */
+interface HttpResourceRefShape<T> {
+    /**
+     * Returns the current resolved value of the resource.
+     *
+     * - Returns `undefined` if the resource has not yet resolved
+     * - Returns a value of type `T` once available
+     *
+     * This method must be safe to call multiple times.
+     */
+    value(): T | undefined;
+    /**
+     * Indicates whether the resource is currently loading.
+     *
+     * @returns `true` while the resource is resolving, otherwise `false`.
+     */
+    isLoading(): boolean;
+    /**
+     * Returns the most recent error produced by the resource, if any.
+     *
+     * @returns An error object, or `null` / `undefined` if no error is present.
+     */
+    error(): unknown;
+    /**
+     * Indicates whether the resource currently holds a resolved value.
+     *
+     * This is semantically equivalent to checking `value() !== undefined`,
+     * but is provided explicitly to support resource implementations that
+     * track resolution state independently.
+     *
+     * @returns `true` if a value is available, otherwise `false`.
+     */
+    hasValue(): boolean;
+}
+
+type DeferredType<T> = () => T | undefined | null | Promise<T | undefined | null>;
+
+/**
+ * Structured shape used to represent a state update packet flowing into the
+ * pipeline. Each field is optional, allowing callers to specify only the
+ * components of state they intend to update. This snapshot is interpreted by
+ * upstream behaviors including resolve, merge, filters, and reducers.
+ *
+ * @typeParam T - The underlying feature state value type.
+ */
+interface StateInputShape<T> {
+    /** Indicates whether the feature is currently loading. */
+    loading?: boolean;
+    /**
+     * The state value to apply. This may be the raw state value or the resolved
+     * upstream value type as defined by the pipeline.
+     */
+    value?: T | undefined | null | DeferredType<T>;
+    /** Optional error information associated with the state update. */
+    error?: unknown;
+}
+
+type DeferredFactory<T> = Partial<{
+    loading: boolean;
+    value: DeferredType<T>;
+    error: unknown;
+}>;
+
+type StateInputType<T> = T | StateInputShape<T> | DeferredFactory<T> | DeferredType<T> | HttpResourceRefShape<T> | Observable<T> | undefined | null;
+
+/**
+ * Defines the execution context supplied to behaviors during pipeline processing.
+ * This interface provides access to state snapshots, operation metadata, lifecycle signals, and configuration required for behavior execution.
+ */
+interface BehaviorContext<T> {
+    /**
+     * Emits when the FeatureCell is destroyed. Behaviors may subscribe to this
+     * to perform cleanup work.
+     */
+    destroyed$?: Observable<void>;
+    /**
+     * The feature cell key
+     */
+    featureCellKey: string;
+    /**
+     * The raw incoming payload submitted to the FeatureCell through replace or
+     * merge operations. This is the source input used by resolve and merge
+     * behaviors to compute next-state values.
+     */
+    incoming?: StateInputType<T>;
+    /**
+     * The last snapshow of the state
+     */
+    lastSnapshot: StateSnapshotShape<T>;
+    /**
+     * Indicates whether the current pipeline action is a "replace" or "merge"
+     * operation. Merge behaviors rely on this to apply correct semantics.
+     */
+    operation: OperationType;
+    /**
+     * Optional behavior-specific configuration supplied for the current operation.
+     */
+    options: unknown;
+    /**
+     * Emits when the FeatureCell is reset. Behaviors may use this to restore
+     * internal state or deferred work.
+     */
+    reset$?: Observable<void>;
+    /**
+     * Identifies the resolve mode for the current operation.
+     * This is set by resolve behaviors during the resolve stage.
+     */
+    resolveType?: ResolveType;
+    /**
+     * Immutable snapshot of the FeatureCell state at the start of the
+     * operation. Used by merge, reducer, filter, and operator behaviors to read
+     * the current state without mutating it.
+     */
+    state: Readonly<StateSnapshotShape<T>>;
+    /**
+     * Emits when the state of the FeatureCell is updated.
+     */
+    state$: Subject<StateEmitSnapshotShape<T> | undefined>;
+    /**
+     * The traceId for Devtools debugging and tracking
+     * Assigned by the orchestrator
+     */
+    traceId: string;
+}
+
+/**
+ * Defines configuration options that control which data is included in emitted insight events.
+ * This interface allows consumers to specify the level of state, payload, error, and queue detail captured during monitoring.
+ */
+interface InsightConfig {
+    /**
+     * Unique identifier for the insight definition.
+     * Commonly used to distinguish different monitoring consumers.
+     */
+    id?: string;
+    /**
+     * Whether lifecycle events should include a snapshot of the
+     * FeatureCell’s current state value.
+     */
+    wantsState?: boolean;
+    /**
+     * Whether emitted events should contain the operation payload such as
+     * reducer results, merge patches, or replacement values.
+     */
+    wantsPayload?: boolean;
+    /**
+     * Whether error information should be included in emitted insight events.
+     */
+    wantsErrors?: boolean;
+}
+
+declare const DecisionOutcomeTypes: {
+    readonly Abort: "abort";
+    readonly Abstain: "abstain";
+    readonly Deny: "deny";
+};
+type DecisionOutcomeType = (typeof DecisionOutcomeTypes)[keyof typeof DecisionOutcomeTypes];
+
+interface ControllerDecisionShape {
+    traceId: string;
+    outcome: DecisionOutcomeType;
+}
+
+interface ControllerContext<T> {
+    traceId: string;
+    featureCellKey: string;
+    /** Immutable snapshot of the current cell state. */
+    snapshot: Readonly<StateSnapshotShape<T>>;
+    /** Raw incoming payload for replace/merge. */
+    incoming?: StateInputType<T>;
+    /** Replace or merge. */
+    operation: OperationType;
+}
+
+type VaultMonitorContext<T> = BehaviorContext<T> | ControllerContext<T> | FeatureCellExtensionContext<T>;
+
+/**
+ * Public interface for the VaultMonitor singleton.
+ *
+ * This interface defines the full DevTools-visible monitoring API
+ * without exposing implementation details.
+ */
+interface VaultMonitorContract {
+    activateGlobalInsights(definition: InsightConfig): void;
+    startAfterTap<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endAfterTap<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startBeforeTap<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endBeforeTap<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startComputeMerge<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endComputeMerge<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startClearPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endClearPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startCoreCallbackError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endCoreCallbackError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startCoreEmitState<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endCoreEmitState<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startCoreError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endCoreError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startCoreState<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endCoreState<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startDestroy<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endDestroy<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startDecrypt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endDecrypt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startEncrypt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endEncrypt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startFilter<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endFilter<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startGlobalError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endGlobalError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    ingressSubscribed<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, source: string): void;
+    ingressCompleted<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, source: string): void;
+    startInterceptor<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endInterceptor<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startInitialized<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endInitialized<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startLoadPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endLoadPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startMerge<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endMerge<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startOperator<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endOperator<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endPersist<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startReducer<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endReducer<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    registerCell(cellKey: string, insight?: InsightConfig): void;
+    startReplace<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endReplace<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startReset<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endReset<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    startResolve<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endResolve<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startSetInitialValue<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endSetInitialValue<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startStepwise<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endStepwise<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload?: unknown): void;
+    notifyConductorDeny<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    conductorRevote<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    conductorAbort<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    conductorLicenseAttempt(cell: string, featureCellKey: string): void;
+    conductorLicenseApproved(cell: string, featureCellKey: string): void;
+    conductorLicenseDenied(cell: string, featureCellKey: string): void;
+    startControllerAttempt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endControllerAttempt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload: unknown): void;
+    restartControllerAttempt<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload: string): void;
+    controllerFailure<T>(behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, error: unknown): void;
+    controllerFinalize<T>(behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    controllerSuccess<T>(behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    startControllerVote<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endControllerVote<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload: ControllerDecisionShape): void;
+    conductorCrashed<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, error: unknown): void;
+    runtimeError<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, error: unknown): void;
+    warn<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, message: string): void;
+    startErrorTransform<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>): void;
+    endErrorTransform<T>(cell: string, behaviorKey: string, ctx: Readonly<VaultMonitorContext<T>>, payload: VaultErrorShape): void;
+}
+
+interface FeatureCellExtensionContext<T> {
+    destroyed$: Observable<void>;
+    featureCellKey: string;
+    mergeState(incoming: StateInputType<T>, options?: unknown): Promise<void>;
+    replaceState(input: StateInputType<T>, options?: unknown): Promise<void>;
+    reset$: Observable<void>;
+    state$: Observable<StateEmitSnapshotShape<T>>;
+    vaultMonitor: VaultMonitorContract;
+    options?: unknown;
+}
+
+/**
+ * FeatureCell extensions registry.
+ *
+ * Every extended cell API method is added here via module augmentation.
+ */
+interface FeatureCellExtension<TEntity> {
+}
+
+interface FeatureCellFluentApi<TEntity> {
+}
+
+/**
+ * Runtime-safe registry of all behavior types.
+ *
+ * This object acts as an enum substitute without introducing JavaScript enum
+ * overhead.
+ * Values are string literals preserved at runtime and suitable for
+ * switch statements, comparisons, and pipeline classification.
+ * Each key maps 1:1 to its string literal value.
+ * The structure is fully tree-shakable and safely inferable by TypeScript.
+ */
+declare const BehaviorTypes: {
+    readonly CoreAfterTap: "coreAfterTap";
+    readonly CoreBeforeTap: "coreBeforeTap";
+    readonly ReplayGlobalError: "replayGlobalError";
+    readonly CoreError: "coreError";
+    readonly CoreErrorCallback: "coreErrorCallback";
+    readonly CoreState: "coreState";
+    readonly DevPipelineObserver: "devPipelineObserver";
+    readonly Encrypt: "encrypt";
+    readonly CoreEmitState: "coreEmitState";
+    readonly ErrorTransform: "errorTransform";
+    readonly Extension: "extension";
+    readonly Filter: "filter";
+    readonly FromObservable: "fromObservable";
+    readonly FromPromise: "fromPromise";
+    readonly FromStream: "fromStream";
+    readonly Interceptor: "interceptor";
+    readonly Merge: "merge";
+    readonly Operator: "operator";
+    readonly Persist: "persist";
+    readonly Reduce: "reduce";
+    readonly Resolve: "resolve";
+    readonly StepwiseFilter: "stepwiseFilter";
+    readonly StepwiseReducer: "stepwiseReducer";
+    readonly StepwiseResolve: "stepwiseResolve";
+};
+/**
+ * Union of all valid behavior type strings.
+ *
+ * This type is derived from `BehaviorTypes` using literal inference, ensuring
+ * strong typing while preserving full runtime compatibility.
+ * This type should not be manually extended—add new values to `BehaviorTypes`
+ * instead.
+ *
+ * --RelatedStart--
+ * BehaviorTypes
+ * --RelatedEnd--
+ */
+type BehaviorType = (typeof BehaviorTypes)[keyof typeof BehaviorTypes];
+
+interface BehaviorClassContract<T = any> {
+    /**
+     * Creates a new behavior instance.
+     *
+     * @param behaviorKey - Unique key assigned by the behavior factory.
+     * @param behaviorCtx - The behaviorCtxfor dependency resolution.
+     */
+    new (behaviorKey: string, behaviorCtx: BehaviorClassContext): BehaviorContract<T>;
+    readonly type: BehaviorType;
+    /**
+     * Unique identifier assigned to this behavior instance. Used by the
+     * orchestrator, diagnostics, and devtools for behavior correlation.
+     */
+    readonly key: string;
+    /**
+     * If the actions of the behavior are critical in regards to error handling.
+     * True means the pipeline should VAULT_NOOP and stop the pipeline flow on any errors
+     * False means that pipeline should log any error and continue
+     */
+    readonly critical: boolean;
+    installFluentApi?: <T>(cell: FeatureCellBaseShape<T>, behaviorConfigs: Map<string, unknown>) => void;
+    readonly wantsConfig?: boolean;
+    readonly configKey?: string;
+}
+
+interface InterceptorBehaviorClassContract<T> extends BehaviorClassContract<T> {
+}
+
+interface OperatorsBehaviorClassContract<T> extends BehaviorClassContract<T> {
+}
+
+type CoreEmitStateCallback<T, E = void> = (snapshot: StateSnapshotShape<T>) => E;
+
+type TapCallback<T> = (current: T) => void;
+
+/**
+ * A pure function used by the Filter behavior stage.
+ *
+ * A filter receives the current state value and must return either the same
+ * value or a transformed version of it. Implementations must be pure: they
+ * must not mutate the input value, trigger side effects, or access external
+ * mutable state. Filters execute before reducers and tap behaviors.
+ *
+ * @typeParam T - The state value type processed by this filter.
+ */
+type FilterFunction<T> = (current: T) => T;
+
+/**
+ * A pure reducer function used by the Vault pipeline.
+ *
+ * A `ReducerFunction` receives the current pipeline value and must return
+ * a new pipeline value of the same type. Reducers should be pure and must
+ * not mutate the input. They are executed during the reducer stage of the
+ * pipeline and are responsible for producing deterministic, immutable
+ * state transitions.
+ *
+ * @typeParam T - The state slice or model type being reduced.
+ * @param current - The current state value before applying the reducer.
+ * @returns The next state value after transformation.
+ */
+type ReducerFunction<T> = (current: T) => T;
+
+/**
+ * Defines the builder contract used to configure and initialize a FeatureCell.
+ * This interface exposes the fluent configuration surface for registering behaviors, callbacks, and operators prior to activation.
+ *
+ * --RelatedStart--
+ * FeatureCellExtension
+ * FeatureCellFluentApi
+ * CoreEmitStateCallback
+ * TapCallback
+ * VaultErrorCallback
+ * FilterFunction
+ * InterceptorBehaviorClassContract
+ * OperatorsBehaviorClassContract
+ * ReducerFunction
+ * --RelatedEnd--
+ */
+interface CellBuilderContract<T> extends FeatureCellExtension<T>, FeatureCellFluentApi<T> {
+    /**
+     * Registers functions executed during the "after tap" stage.
+     *
+     * @param afterTaps - Tap functions invoked after reducers.
+     * @returns The same builder instance for fluent chaining.
+     */
+    afterTaps(afterTaps: TapCallback<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers functions executed during the "before tap" stage.
+     *
+     * @param beforeTaps - Tap functions invoked before reducers.
+     * @returns The same builder instance for fluent chaining.
+     */
+    beforeTaps(beforeTaps: TapCallback<T>[]): CellBuilderContract<T>;
+    /**
+     * Map of behavior configuration values keyed by behavior configuration identifiers.
+     */
+    behaviorConfigs: Map<string, unknown>;
+    /**
+     * Registers emitState functions executed during the emitState stage.
+     *
+     * @param emitStates - EmitState callbacks invoked during state changes.
+     * @returns The builder instance for fluent chaining.
+     */
+    emitStates(emitStates: CoreEmitStateCallback<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers error functions to run during the error stage.
+     *CellBuilderContract
+     * @param errors - Error functions that may block or transform values.
+     * @returns The same builder instance for fluent chaining.
+     */
+    errors(errors: VaultErrorCallback<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers filter functions to run during the filter stage.
+     *
+     * @param filters - Filter functions that may block or transform values.
+     * @returns The same builder instance for fluent chaining.
+     */
+    filters(filters: FilterFunction<T>[]): CellBuilderContract<T>;
+    hydrate(incoming: DeferredType<T>): CellBuilderContract<T>;
+    /**
+     * Finalizes the builder configuration and activates the FeatureCell.
+     *
+     * Implementations may perform synchronous or asynchronous setup.
+     *
+     * @returns The builder instance, or a Promise resolving when initialization completes.
+     */
+    initialize(): void;
+    /**
+     * Registers interceptor behaviors that preprocess incoming state before resolve.
+     *
+     * @param interceptors - Interceptor behavior classes.
+     * @returns The same builder instance for fluent chaining.
+     */
+    interceptors(interceptors: InterceptorBehaviorClassContract<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers operator behaviors executed prior to filtering.
+     *
+     * @param operators - Operator behavior classes that may transform or block updates.
+     * @returns The same builder instance for fluent chaining.
+     */
+    operators(operators: OperatorsBehaviorClassContract<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers a sequence of reducer functions to run during the reducer stage.
+     *
+     * @param reducers - Ordered reducer functions applied to the working state.
+     * @returns The same builder instance for fluent chaining.
+     */
+    reducers(reducers: ReducerFunction<T>[]): CellBuilderContract<T>;
+}
+
+/**
+ * Defines the public base contract for a FeatureCell instance.
+ * This interface exposes the full builder, lifecycle, and state update surface required to configure, initialize, and interact with a FeatureCell at runtime.
+ */
+interface FeatureCellBaseShape<T> extends FeatureCellExtension<T>, FeatureCellFluentApi<T> {
+    /**
+     * Registers tap functions executed during the "after tap" stage.
+     *
+     * @param afterTaps - Functions invoked after the reducer stage.
+     * @returns The builder instance for fluent chaining.
+     */
+    afterTaps(afterTaps: TapCallback<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers tap functions executed during the "before tap" stage.
+     *
+     * @param beforeTaps - Functions invoked before the reducer stage.
+     * @returns The builder instance for fluent chaining.
+     */
+    beforeTaps(beforeTaps: TapCallback<T>[]): CellBuilderContract<T>;
+    /**
+     * Performs cleanup and teardown of the FeatureCell.
+     * Called automatically when the cell's hosting provider is destroyed.
+     */
+    destroy(): void;
+    /**
+     * Observable that emits when the FeatureCell has been destroyed.
+     */
+    destroyed$?: Observable<void>;
+    /**
+     * Registers emitState functions executed during the emitState stage.
+     *
+     * @param emitStates - EmitState callbacks invoked during state changes.
+     * @returns The builder instance for fluent chaining.
+     */
+    emitStates(emitStates: CoreEmitStateCallback<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers error functions to run during the error stage.
+     *
+     * @param errors - Error functions applied to the upstream snapshot.
+     * @returns The builder instance for fluent chaining.
+     */
+    errors(errors: VaultErrorCallback<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers filter functions to run during the filter stage.
+     *
+     * @param filters - Filter functions applied to the upstream snapshot.
+     * @returns The builder instance for fluent chaining.
+     */
+    filters(filters: FilterFunction<T>[]): CellBuilderContract<T>;
+    hydrate(incoming: DeferredType<T>): CellBuilderContract<T>;
+    /**
+     * Finalizes builder configuration and activates the FeatureCell.
+     *
+     * @returns The builder instance, or a Promise resolving once initialization completes.
+     */
+    initialize(): CellBuilderContract<T> | void;
+    /**
+     * Registers interceptor behaviors executed prior to resolve.
+     *
+     * @param interceptors - Interceptor behavior classes.
+     * @returns The builder instance for fluent chaining.
+     */
+    interceptors(interceptors: InterceptorBehaviorClassContract<T>[]): CellBuilderContract<T>;
+    /**
+     * Unique identifier assigned to the FeatureCell.
+     */
+    readonly key: string;
+    /**
+     * Performs a merge-style state update using the configured merge behavior.
+     *
+     * @param incoming Structured state input to be merged.
+     * @param options Optional merge behavior configuration.
+     */
+    mergeState(incoming: StateInputType<T>, options?: unknown): void;
+    /**
+     * Registers operator behaviors executed before filters.
+     *
+     * @param operators - Operator behavior classes.
+     * @returns The builder instance for fluent chaining.
+     */
+    operators(operators: OperatorsBehaviorClassContract<T>[]): CellBuilderContract<T>;
+    /**
+     * Registers reducer functions executed during the reducer stage.
+     *
+     * @param reducers - Reducer functions that transform the working state.
+     * @returns The builder instance for fluent chaining.
+     */
+    reducers(reducers: ReducerFunction<T>[]): CellBuilderContract<T>;
+    /**
+     * Performs a replace-style state update that fully replaces the current state.
+     *
+     * @param incoming Structured state input to replace the current state.
+     * @param options Optional merge behavior configuration.
+     */
+    replaceState(incoming: StateInputType<T>, options?: unknown): void;
+    /**
+     * Resets the FeatureCell to its initial state.
+     */
+    reset(): void;
+    /**
+     * Observable that emits when the FeatureCell has been reset.
+     */
+    reset$?: Observable<void>;
+    /**
+     * Observable that emits when the FeatureCell has been reset.
+     */
+    state$: Observable<StateEmitSnapshotShape<T>>;
+    /**
+     * Dev-mode testing hook.
+     * Only defined when DevMode.active === true.
+     * Non-enumerable and not part of runtime API.
+     */
+    vaultSettled?: () => Promise<void>;
+}
+
+type BehaviorExtFunction = (...args: any[]) => unknown;
+/**
+ * A map of extension function names to their implementation functions.
+ * Behaviors may return these objects to expose additional APIs on the
+ * FeatureCell instance. Keys correspond to method names added to the
+ * cell’s public API surface.
+ */
+type BehaviorExtension = Partial<Record<string, BehaviorExtFunction>>;
+/**
+ * Base interface implemented by all behavior types in the SDuX/ Vault
+ * pipeline. Behaviors participate in specific pipeline stages based on
+ * their declared BehaviorType, and may optionally expose additional
+ * FeatureCell APIs through the `extendCellAPI()` hook.
+ *
+ * @typeParam T - The FeatureCell state value type handled by this behavior.
+ * @typeParam E - The shape of the extension API returned by this behavior.
+ */
+interface BehaviorContract<T = unknown, E extends BehaviorExtension = BehaviorExtension> {
+    /**
+     * Declares the pipeline classification for this behavior. The orchestrator
+     * uses this to determine the execution order in the upstream and persist
+     * stages.
+     */
+    readonly type: BehaviorType;
+    /**
+     * Unique identifier assigned to this behavior instance. Used by the
+     * orchestrator, diagnostics, and devtools for behavior correlation.
+     */
+    readonly key: string;
+    /**
+     * If the actions of the behavior are critical in regards to error handling.
+     * True means the pipeline should VAULT_NOOP and stop the pipeline flow on any errors
+     * False means that pipeline should log any error and continue
+     */
+    readonly critical: boolean;
+    /**
+     * Optional list of extension function names that this behavior is permitted
+     * to override when multiple behaviors contribute conflicting API keys.
+     * Behaviors without explicit override permission may not replace an
+     * existing API entry.
+     */
+    allowOverride?: string[];
+    extendCellAPI?(ctx: FeatureCellExtensionContext<T>): E | void;
+    destroy(ctx?: BehaviorContext<T>): void;
+    reset(ctx?: BehaviorContext<T>): void;
+    installFluentApi?: <T>(cell: FeatureCellBaseShape<T>, behaviorConfigs: Map<string, unknown>) => void;
+}
+
+interface ErrorCallbackBehaviorContract<T> extends BehaviorContract<T> {
+    type: 'coreErrorCallback';
+    callbackError(current: VaultErrorShape, state: StateSnapshotShape<T>, oldschoolCallback: VaultErrorCallback<T>): Promise<void>;
+}
+
+declare abstract class AbstractErrorCallbackBehavior<T> implements ErrorCallbackBehaviorContract<T> {
+    readonly behaviorCtx: BehaviorClassContext;
+    /** Indicates that this error behavior is critical and always executed. */
+    readonly critical: boolean;
+    /** Unique identifier for this behavior instance. */
+    readonly key: string;
+    /** Behavior type for orchestrator registration. */
+    readonly type: "coreErrorCallback";
+    /**
+     * Creates a new abstract error behavior instance.
+     *
+     * @param key - Unique behavior identifier supplied by the behavior factory.
+     * @param behaviorCtx - Behavior class context providing injector access and extensibility hooks.
+     */
+    constructor(key: string, behaviorCtx: BehaviorClassContext);
+    abstract callbackError(current: VaultErrorShape, state: StateSnapshotShape<T>, oldschoolCallback: VaultErrorCallback<T>): Promise<void>;
+    /**
+     * Lifecycle hook invoked when the behavior instance is destroyed.
+     *
+     * Error behaviors do not allocate runtime resources and therefore require
+     * no cleanup. A diagnostic entry is logged for lifecycle visibility.
+     */
+    destroy(): void;
+    /**
+     * Lifecycle hook invoked when the behavior instance is reset.
+     *
+     * Error behaviors hold no internal state, making this a no-operation.
+     * The hook ensures lifecycle uniformity across all behaviors.
+     */
+    reset(): void;
+}
+
+declare const VAULT_NOOP: unique symbol;
+
+interface ErrorTransformBehaviorContract<T> extends BehaviorContract<T> {
+    type: 'errorTransform';
+    transformError(error: unknown, current: VaultErrorShape, previousStateSnapshot: StateSnapshotShape<T>): Promise<unknown | typeof VAULT_NOOP>;
+}
+
+/**
+ * Abstract base behavior for transforming errors during pipeline execution.
+ * This class defines the contract and lifecycle hooks required for error transformation behaviors.
+ *
+ * --RelatedStart--
+ * ErrorTransformBehaviorContract
+ * BehaviorClassContext
+ * StateSnapshotShape
+ * VaultErrorShape
+ * --RelatedEnd--
+ */
+declare abstract class AbstractErrorTransformBehavior<T> implements ErrorTransformBehaviorContract<T> {
+    readonly behaviorCtx: BehaviorClassContext;
+    /**
+     * Indicates that this error transform behavior is critical and always executed.
+     */
+    readonly critical: boolean;
+    /**
+     * Unique identifier for this behavior instance.
+     */
+    readonly key: string;
+    /**
+     * Behavior type identifier used for orchestrator registration.
+     */
+    readonly type: "errorTransform";
+    /**
+     * Creates a new abstract error transform behavior instance.
+     *
+     * @param key Unique behavior identifier supplied by the factory.
+     * @param behaviorCtx Behavior class context providing configuration and hooks.
+     */
+    constructor(key: string, behaviorCtx: BehaviorClassContext);
+    /**
+     * Transforms an error produced during pipeline execution.
+     *
+     * @param error Incoming error value to be transformed.
+     * @param current Current normalized Vault error value.
+     * @param previousStateSnapshot Snapshot of state prior to the error.
+     * @returns Transformed error, original error, or VAULT_NOOP to suppress emission.
+     */
+    abstract transformError(error: unknown, current: VaultErrorShape, previousStateSnapshot: StateSnapshotShape<T>): Promise<unknown | typeof VAULT_NOOP>;
+    /**
+     * Lifecycle hook invoked when the behavior instance is destroyed.
+     */
+    destroy(): void;
+    /**
+     * Lifecycle hook invoked when the behavior instance is reset.
+     */
+    reset(): void;
+}
+
+interface ControllerClassContext {
+    featureCellKey: string;
+    requestRevote: (traceId: string) => void;
+    requestAbort: (traceId: string) => void;
+    licenseDenied?: (traceId: string) => void;
+    licenseApproved?: (traceId: string) => void;
+    readonly controllerConfig?: unknown;
+    readonly licensePayload?: unknown;
+}
+
+declare const ControllerMessageTypes: {
+    readonly Attempt: "attempt";
+    readonly Failure: "failure";
+    readonly Finalize: "Finalize Pipeline";
+    readonly Success: "success";
+    readonly Vote: "vote";
+};
+type ControllerMessageType = (typeof ControllerMessageTypes)[keyof typeof ControllerMessageTypes];
+
+interface ControllerMessageBaseShape {
+    type: ControllerMessageType;
+    traceId: string;
+}
+
+interface ControllerAttemptMessageShape<T> extends ControllerMessageBaseShape {
+    type: typeof ControllerMessageTypes.Attempt;
+    ctx: ControllerContext<T>;
+}
+
+interface ControllerFailMessageShape<T> extends ControllerMessageBaseShape {
+    type: typeof ControllerMessageTypes.Failure;
+    ctx: ControllerContext<T>;
+    error: VaultErrorShape | unknown;
+}
+
+interface ControllerFinalizeMessageShape extends ControllerMessageBaseShape {
+    type: typeof ControllerMessageTypes.Finalize;
+}
+
+interface ControllerSuccessMessageShape<T> extends ControllerMessageBaseShape {
+    type: typeof ControllerMessageTypes.Success;
+    ctx: ControllerContext<T>;
+}
+
+type ControllerMessageShape<T> = ControllerAttemptMessageShape<T> | ControllerSuccessMessageShape<T> | ControllerFailMessageShape<T> | ControllerFinalizeMessageShape;
+
+declare const ControllerVotes: {
+    readonly Abstain: "abstain";
+    readonly Abort: "abort";
+    readonly Deny: "deny";
+};
+type ControllerVote = (typeof ControllerVotes)[keyof typeof ControllerVotes];
+
+declare const ControllerTypes: {
+    readonly CoreAbstain: "coreAbstain";
+    readonly Error: "error";
+    readonly License: "license";
+    readonly Policy: "policy";
+    readonly ReplayGlobalError: "replayGlobalError";
+    readonly Stepwise: "stepwise";
+};
+type ControllerType = (typeof ControllerTypes)[keyof typeof ControllerTypes];
+
+interface ControllerContract<T = unknown> {
+    readonly type: ControllerType;
+    readonly key: string;
+    readonly critical: boolean;
+    handleMessage(msg: ControllerMessageShape<T>): Observable<ControllerVote | void>;
+    destroy(): void;
+    reset(): void;
+    installFluentApi?: <T>(cell: FeatureCellBaseShape<T>, behaviorConfigs: Map<string, unknown>) => void;
+}
+
+declare abstract class AbstractActiveController<T> implements ControllerContract<T> {
+    #private;
+    protected readonly ctx: ControllerClassContext;
+    readonly key: string;
+    abstract readonly type: ControllerType;
+    readonly critical = false;
+    protected hasError: boolean;
+    protected traceId: string | null;
+    constructor(key: string, ctx: ControllerClassContext);
+    /** Child classes override to react to external error toggles */
+    protected onExternalTrigger(_newErrorState: boolean): void;
+    /** All controllers must implement this */
+    abstract handleMessage(msg: ControllerMessageShape<T>): Observable<ControllerVote | void>;
+    destroy(): void;
+    reset(): void;
+}
+
+/**
+ * Configuration options for merge operations executed by a MergeBehavior.
+ *
+ * `MergeConfig` allows callers to influence how undefined values are treated
+ * during state merging. These options are consumed by the active merge strategy
+ * (e.g., array replace, append, shallow object merge, deep merge).
+ */
+interface MergeConfig {
+    /**
+     * When enabled, properties with `undefined` values in the incoming snapshot
+     * will clear corresponding properties on the current state. When disabled,
+     * incoming `undefined` values leave existing state properties unchanged.
+     */
+    clearUndefined?: boolean;
+}
+
+/**
+ * Configuration options for deep object merge behaviors.
+ *
+ * `ObjectDeepMergeConfig` influences how nested object structures are merged
+ * during a deep-merge operation. These settings are applied recursively by the
+ * merge behavior and determine how undefined and null-valued fields are handled.
+ */
+interface ObjectDeepMergeConfig {
+    /**
+     * When enabled, incoming `undefined` values will clear matching properties
+     * on the current state during the merge. When disabled, `undefined` values
+     * leave existing fields unchanged.
+     */
+    clearUndefined?: boolean;
+    /**
+     * When enabled, properties whose incoming value is `null` are removed from the
+     * merged output. When disabled, incoming `null` values are preserved during the
+     * merge operation.
+     */
+    stripNulls?: boolean;
+}
+
+interface VaultLicensingShape {
+    licenseId: string;
+    payload: unknown;
+}
+
+/**
+ * Defines the allowable verbosity levels for Vault logging.
+ *
+ * A `LogLevel` controls the amount of diagnostic output emitted by the
+ * vault’s internal debug, warning, or error channels. Higher levels
+ * produce more detailed logs, while lower levels suppress output.
+ *
+ * - `'off'`   — no logs are emitted
+ * - `'error'` — only errors are logged
+ * - `'warn'`  — warnings and errors are logged
+ * - `'log'`   — standard log events, warnings, and errors are logged
+ * - `'debug'` — all debug-level information is emitted
+ */
+declare const LogLevelTypes: {
+    readonly Off: "off";
+    readonly Error: "error";
+    readonly Warn: "warn";
+    readonly Log: "log";
+    readonly Debug: "debug";
+};
+type LogLevelType = (typeof LogLevelTypes)[keyof typeof LogLevelTypes];
+
+interface VaultConfig {
+    /**
+     * Enables development-mode diagnostics and additional internal checks.
+     * When `true`, Vault emits more verbose warnings and validation errors.
+     */
+    devMode?: boolean;
+    /**
+     * Controls the verbosity of internal logging.
+     * Common levels: `'debug' | 'info' | 'warn' | 'error' | 'off'`.
+     */
+    logLevel?: LogLevelType;
+    /**
+     * Optional array of pre-registered license payloads.
+     *
+     * Vault stores these payloads in memory at startup and makes them
+     * retrievable via `getLicensePayload(licenseId)`. Vault does not
+     * validate or interpret the payload — vendors are responsible for
+     * validation logic.
+     */
+    licenses?: VaultLicensingShape[];
+    /**
+     * Maximum time (in milliseconds) Vault will wait for a required
+     * license to be validated before marking it as timed out.
+     *
+     * If validation does not occur within this window, the FeatureCell
+     * is denied. Defaults to 15,000 ms. Set to `0` to disable timeout.
+     */
+    licenseTimeoutMs?: number;
+}
+
+declare const BEHAVIOR_META: unique symbol;
+
+declare const CONTROLLER_META: unique symbol;
+
+/**
+ * String token used to uniquely identify the DevTools Aggregate FeatureCell.
+ *
+ * This key is referenced by the DevTools service, monitor utilities,
+ * and the router configuration to ensure all DevTools-related state
+ * is consistently mapped to the same FeatureCell instance.
+ *
+ * The value is stable across versions to maintain compatibility with
+ * external tools such as the Chrome DevTools extension.
+ */
+declare const DEVTOOLS_AGGREGATE_KEY_CONSTANT = "vault::devtools::aggregate:feature::cell";
+
+/**
+ * String token used to uniquely identify the DevTools Logging FeatureCell.
+ *
+ * This key is referenced by the DevTools service, monitor utilities,
+ * and the router configuration to ensure all DevTools-related state
+ * is consistently mapped to the same FeatureCell instance.
+ *
+ * The value is stable across versions to maintain compatibility with
+ * external tools such as the Chrome DevTools extension.
+ */
+declare const DEVTOOLS_LOGGING_KEY_CONSTANT = "vault::devtools::logging::feature::cell";
+
+declare const VAULT_CLEAR_STATE: unique symbol;
+
+declare const VAULT_CONTINUE: unique symbol;
+
+declare const VAULT_STOP: unique symbol;
+
+interface BehaviorMetaShape {
+    /**
+     * The pipeline stage in which this behavior participates.
+     * Determines when the orchestrator invokes the behavior.
+     */
+    type: BehaviorType;
+    /**
+     * Unique identifier for this behavior. Used for diagnostics,
+     * devtools visualization, and orchestrator classification.
+     */
+    key: string;
+    /**
+     * Indicates whether this behavior is critical. Critical behaviors
+     * are mandatory and must always run when present in the pipeline.
+     */
+    critical: boolean;
+    /**
+     * Optional resolve strategy associated with this behavior.
+     * Only set for resolution behaviors that determine how state
+     * is initially derived (e.g., value, http, observable).
+     */
+    resolveType?: ResolveType;
+    wantsConfig?: boolean;
+    configKey?: string;
+    needsLicense?: boolean;
+    licenseId?: string;
+}
+
+/**
+ * Decorator that registers a class as an Vault behavior.
+ *
+ * The `VaultBehavior` decorator attaches the provided `BehaviorMeta`
+ * definition to the target constructor, making the behavior discoverable by
+ * the orchestrator during pipeline initialization. Metadata fields such as
+ * `type`, `key`, and `critical` are also mirrored onto static properties of
+ * the decorated class to support lightweight runtime introspection.
+ *
+ * This decorator does not modify method logic or structure; it only assigns
+ * metadata required for orchestrator classification and behavior lifecycle
+ * management.
+ *
+ * @param meta - Metadata describing the behavior’s category, unique key, and
+ *               criticality within the pipeline.
+ * @returns A class decorator that applies behavior metadata to the target.
+ */
+declare function VaultBehavior(meta: BehaviorMetaShape): (target: any) => void;
+
+interface ControllerMetaShape {
+    type: ControllerType;
+    key: string;
+    critical?: boolean;
+    wantsConfig?: boolean;
+    configKey?: string;
+    needsLicense?: boolean;
+    licenseId?: string;
+}
+
+declare function VaultController(meta: ControllerMetaShape): (target: any) => void;
+
+declare const VaultErrorUsageKindTypes: {
+    readonly Encryption: "VaultErrorEncryption";
+    readonly License: "VaultErrorLicense";
+    readonly Promise: "VaultErrorUsagePromise";
+    readonly PromiseFactoryRequired: "VaultErrorUsagePromiseFactoryRequired";
+    readonly Usage: "VaultErrorUsage";
+};
+type VaultErrorUsageKindType = (typeof VaultErrorUsageKindTypes)[keyof typeof VaultErrorUsageKindTypes];
+
+declare const VaultErrorKindTypes: {
+    readonly Usage: "VaultErrorUsage";
+    readonly VaultError: "VaultError";
+};
+type VaultErrorKindType = (typeof VaultErrorKindTypes)[keyof typeof VaultErrorKindTypes] | (typeof VaultErrorUsageKindTypes)[keyof typeof VaultErrorUsageKindTypes];
+
+declare const VaultErrorNameTypes: {
+    readonly EncryptionIntegrity: "VaultErrorEncryptionIntegrity";
+    readonly License: "VaultErrorLicense";
+    readonly Usage: "VaultErrorUsage";
+    readonly VaultError: "VaultError";
+};
+type VaultErrorNameType = (typeof VaultErrorNameTypes)[keyof typeof VaultErrorNameTypes];
+
+declare class VaultError extends Error {
+    readonly kind: VaultErrorKindType;
+    constructor(message: string, name?: VaultErrorNameType, kind?: VaultErrorKindType);
+}
+
+/**
+ * Thrown when encrypted payload integrity verification fails.
+ *
+ * This occurs when AES-GCM authentication fails during decryption.
+ * Causes may include:
+ *
+ * - Tampered ciphertext
+ * - Modified IV
+ * - Incorrect encryption key
+ * - Corrupted storage payload
+ *
+ * AES-GCM provides authenticated encryption, so any modification to the
+ * encrypted envelope will cause the WebCrypto decrypt operation to throw.
+ */
+declare class VaultEncryptionIntegrityError extends VaultError {
+    constructor();
+}
+
+declare class VaultLicenseError extends VaultError {
+    constructor(message: string, kind?: VaultErrorUsageKindType);
+}
+
+declare class VaultUsageError extends VaultError {
+    constructor(message: string, kind?: VaultErrorUsageKindType);
+}
+
+declare class VaultUsagePromiseError extends VaultUsageError {
+    constructor();
+}
+
+declare class VaultUsagePromiseFactoryRequiredError extends VaultUsageError {
+    constructor();
+}
+
+/**
+ * Represents the possible result of a core emit operation.
+ * This type indicates either an intentional no-op signal or the absence of an emitted state.
+ *
+ * --RelatedStart--
+ * VAULT_NOOP
+ * --RelatedEnd--
+ */
+type CoreEmitStateResult = typeof VAULT_NOOP | undefined;
+
+/**
+ * Contract for behaviors that emit finalized state snapshots.
+ */
+interface CoreEmitStateBehaviorContract<T> extends BehaviorContract<T> {
+    /**
+     * Emits a state snapshot through the configured emit callback.
+     *
+     * @param snapshot - The finalized state snapshot.
+     * @param callback - The callback invoked with the snapshot.
+     * @returns The emit result indicating pipeline continuation behavior.
+     */
+    emitState(snapshot: StateSnapshotShape<T>, callback: CoreEmitStateCallback<T>): CoreEmitStateResult;
+}
+
+/**
+ * Behavior contract for observing pipeline execution events in development mode.
+ *
+ * This interface defines the lifecycle hooks and notification methods used by
+ * a dev-only pipeline observer behavior to track execution boundaries and
+ * propagate success or error signals associated with a FeatureCell run.
+ */
+interface DevPipelineObserverBehaviorContract extends BehaviorContract {
+    /**
+     * Signals the start of a pipeline execution cycle.
+     */
+    beginRun(): void;
+    /**
+     * Emits a successful pipeline completion event for a FeatureCell.
+     *
+     * @param cellKey - The unique key of the FeatureCell that completed successfully.
+     */
+    emitSuccess(cellKey: string): void;
+    /**
+     * Emits a pipeline error event for a FeatureCell.
+     *
+     * @param cellKey - The unique key of the FeatureCell that encountered an error.
+     * @param error - The normalized error associated with the failed execution.
+     */
+    emitError(cellKey: string, error: VaultErrorShape): void;
+}
+
+/**
+ * Represents the value passed into persistence behaviors.
+ *
+ * A `PipelinePersistValue<T>` may be:
+ * - `T` — the final, post-encryption state ready to be persisted
+ * - `undefined` — indicating that no value should be written to storage
+ *
+ * Unlike upstream pipeline values, persistence values never include
+ * `VAULT_NOOP`, because no-op handling is completed before the persistence
+ * stage begins.
+ *
+ * @typeParam T - The decrypted/plain state type handled by persistence behaviors.
+ */
+type PipelinePersistValue<T> = T | undefined;
+
+interface EncryptBehaviorContract<T> extends BehaviorContract<T> {
+    /**
+     * Encrypts a plain or already-processed state value before persistence.
+     *
+     * @param ctx - The active behavior context for this pipeline execution.
+     * @param current - The current value to encrypt. May be a plain state value
+     *                  or `undefined` if persistence should be skipped.
+     * @returns The encrypted `PipelinePersistValue<T>`, either synchronously or asynchronously.
+     */
+    encryptState(ctx: BehaviorContext<T>, current: PipelinePersistValue<T>): Promise<PipelinePersistValue<T>> | PipelinePersistValue<T>;
+    /**
+     * Decrypts a value retrieved from storage.
+     *
+     * @param ctx - The active behavior context associated with this pipeline run.
+     * @param encrypted - A persisted value (possibly `undefined`) to decrypt.
+     * @returns The decrypted `PipelinePersistValue<T>`, either synchronously or asynchronously.
+     */
+    decryptState(ctx: BehaviorContext<T>, encrypted: PipelinePersistValue<T>): Promise<PipelinePersistValue<T>> | PipelinePersistValue<T>;
+}
+
+type PipelineUpstreamValue<T> = T | undefined | typeof VAULT_NOOP | typeof VAULT_CLEAR_STATE | typeof VAULT_CONTINUE;
+
+interface FilterBehaviorContract<T> extends BehaviorContract<T> {
+    /** Identifies this behavior as a filter behavior. */
+    type: 'filter';
+    applyFilter(current: PipelineUpstreamValue<T>, filter: FilterFunction<T>): PipelineUpstreamValue<T>;
+}
+
+/**
+ * Represents the full set of values an interceptor may return to the
+ * orchestrator during the interceptor stage.
+ *
+ * Interceptors may either:
+ *
+ * - forward the original {@link StateInputType} value unchanged,
+ * - replace it with a transformed {@link StateInputType}, or
+ * - return the reserved {@link VAULT_STOP} symbol to indicate that
+ *   pipeline execution should halt for the current write operation.
+ *
+ * Returning `VAULT_STOP` instructs the orchestrator to abort further
+ * processing of the incoming state while maintaining deterministic
+ * pipeline flow. This symbol is treated as an explicit control signal
+ * and is not a user-provided state value.
+ *
+ * @typeParam T - The underlying feature state type being processed.
+ */
+type InterceptorStateType<T> = StateInputType<T> | typeof VAULT_STOP;
+
+interface InterceptorBehaviorContract<T> extends BehaviorContract<T> {
+    /**
+     * Applies the interceptor logic for the incoming state packet.
+     *
+     * @param ctx - The behavior execution context containing the incoming
+     * state and lifecycle metadata for the current pipeline operation.
+     * @returns A promise that resolves to a transformed or replacement
+     * {@link StateInputType} value, or `undefined` when no modification is
+     * necessary.
+     */
+    applyInterceptor(ctx: BehaviorContext<T>): Promise<InterceptorStateType<T>>;
+}
+
+interface MergeBehaviorContract<T> extends BehaviorContract<T> {
+    computeMerge(currentValue: PipelineUpstreamValue<T> | undefined, nextValue: PipelineUpstreamValue<T> | undefined, options?: MergeConfig): PipelineUpstreamValue<T> | undefined;
+}
+
+interface OperatorBehaviorContract<T> extends BehaviorContract<T> {
+    applyOperator(value: PipelineUpstreamValue<T>): Promise<PipelineUpstreamValue<T>>;
+}
+
+interface PersistBehaviorContract<T> extends BehaviorContract<T> {
+    /** Identifies this behavior as a persistence behavior. */
+    type: 'persist';
+    persistState(current: PipelinePersistValue<T>): Promise<void> | void;
+    clearState(): void;
+    loadState(): PipelinePersistValue<T>;
+}
+
+interface ReduceBehaviorContract<T> extends BehaviorContract<T> {
+    /** Pipeline behavior type identifier for reducer-stage execution. */
+    type: 'reduce';
+    /**
+     * Applies the provided reducer function to the current state.
+     *
+     * @param current - The current state value prior to reducer execution.
+     * @param reducer - A pure reducer function returning a new state value.
+     * @returns The transformed state value.
+     */
+    applyReducer(current: T, reducer: ReducerFunction<T>): T;
+}
+
+interface ResolveBehaviorContract<T> extends BehaviorContract<T> {
+    /** Resolve strategy used by this behavior (value, HTTP resource, observable, etc.). */
+    resolveType: 'http-resource' | 'observable' | 'promise' | 'value';
+    computeResolve(ctx: BehaviorContext<T>): Promise<PipelineUpstreamValue<T>> | PipelineUpstreamValue<T>;
+}
+
+interface StepwiseBehaviorContract<T> extends BehaviorContract<T> {
+    evaluateStepwise(current: T | undefined, candidate: PipelineUpstreamValue<T>, pipelineId: string): Promise<PipelineUpstreamValue<T>>;
+}
+
+interface AfterTapBehaviorContract<T> extends BehaviorContract<T> {
+    applyAfterTap(current: PipelineUpstreamValue<T>, tap: TapCallback<T>): void;
+}
+
+interface BeforeTapBehaviorContract<T> extends BehaviorContract<T> {
+    applyBeforeTap(current: PipelineUpstreamValue<T>, tap: TapCallback<T>): void;
+}
+
+interface ControllerClassContract<T = any> {
+    new (controllerKey: string, controllerCtx: ControllerClassContext): ControllerContract<T>;
+    readonly type: ControllerType;
+    readonly key: string;
+    readonly critical: boolean;
+    installFluentApi?: <T>(cell: FeatureCellBaseShape<T>, behaviorConfigs: Map<string, unknown>) => void;
+}
+
+declare const EventBoundaryTypes: {
+    readonly End: "end";
+    readonly Notification: "notification";
+    readonly Start: "start";
+    readonly Unknown: "unknown";
+};
+type EventBoundaryType = (typeof EventBoundaryTypes)[keyof typeof EventBoundaryTypes];
+
+declare const EventTypes: {
+    readonly Conductor: "conductor";
+    readonly Controller: "controller";
+    readonly Lifecycle: "lifecycle";
+    readonly Stage: "stage";
+    readonly Unknown: "unknown";
+};
+type EventType = (typeof EventTypes)[keyof typeof EventTypes];
+
+/**
+ * Describes the shape of a pipeline event emitted during FeatureCell execution.
+ * This interface defines the core event contract used for diagnostics, Devtools inspection, and lifecycle tracking.
+ *
+ * --RelatedStart--
+ * StateSnapshotShape
+ * --RelatedEnd--
+ */
+interface EventShape<T = any> {
+    /**
+     * Unique identifier for the emitted event.
+     */
+    id: string;
+    /**
+     * The behavior key that produced the event.
+     */
+    behaviorKey: string;
+    /**
+     * Identifier of the FeatureCell associated with the event.
+     */
+    cell: string;
+    /**
+     * Optional error information associated with a failure event.
+     */
+    error?: any;
+    /**
+     * Optional payload associated with the event.
+     */
+    payload?: unknown;
+    /**
+     * Timestamp indicating when the event occurred.
+     */
+    timestamp: number;
+    /**
+     * Trace identifier used for Devtools debugging and correlation.
+     */
+    traceId?: string;
+    /**
+     * The event name describing the lifecycle transition or action.
+     */
+    name: string;
+    type: EventType;
+    /**
+     * The event boundary type.
+     */
+    boundary: EventBoundaryType;
+    /**
+     * Optional partial snapshot of FeatureCell state at the time of emission.
+     */
+    state?: Partial<StateSnapshotShape<T>>;
+    /**
+     * Optional source identifier provided by the event origin.
+     */
+    source?: string;
+}
+
+/**
+ * Defines the contract for an event bus responsible for emitting and observing pipeline and queue events.
+ * This interface provides methods for publishing events and subscribing to their corresponding event streams.
+ *
+ * --RelatedStart--
+ * EventShape
+ * EventQueueShape
+ * --RelatedEnd--
+ */
+interface EventBusContract {
+    /**
+     * Emits a pipeline event to all subscribed observers.
+     *
+     * @param event Pipeline event instance to be dispatched.
+     */
+    nextPipeline(event: EventShape): void;
+    /**
+     * Provides an observable stream of emitted pipeline events.
+     *
+     * @returns Observable stream of pipeline events.
+     */
+    pipeline$(): Observable<EventShape>;
+}
+
+interface VaultErrorServiceContract {
+    readonly error$: Observable<VaultErrorShape | null>;
+    clear(): void;
+    get hasError(): boolean;
+}
+
+interface VaultPrivateErrorServiceContract {
+    setError(error: VaultErrorShape | null): void;
+    getError(): Observable<VaultErrorShape | null>;
+    clear(): void;
+}
+
+declare function VaultErrorService(): VaultErrorServiceContract;
+
+declare function VaultPrivateErrorService(): VaultPrivateErrorServiceContract;
+
+declare const VaultRegistrationLicenseStatusTypes: {
+    readonly NotRequired: "not-required";
+    readonly Pending: "pending";
+    readonly Revoked: "revoked";
+    readonly Timeout: "timeout";
+    readonly Valid: "valid";
+};
+type VaultRegistrationLicenseStatusType = (typeof VaultRegistrationLicenseStatusTypes)[keyof typeof VaultRegistrationLicenseStatusTypes];
+
+interface VaultRegistrationEntityShape {
+    key: string;
+    type: string;
+    critical?: boolean;
+    needsLicense?: boolean;
+    validLicense?: VaultRegistrationLicenseStatusType;
+    licenseId?: string;
+}
+
+interface VaultRegistrationFluentApiShape {
+    filters: number;
+    reducers: number;
+    beforeTaps: number;
+    afterTaps: number;
+    emitStateCallbacks: number;
+    errorCallbacks: number;
+}
+
+interface VaultRegistrationShape {
+    key: string;
+    vaultSettled?: () => Promise<void>;
+    behaviors?: Map<string, VaultRegistrationEntityShape>;
+    controllers?: Map<string, VaultRegistrationEntityShape>;
+    fluentApis?: Readonly<VaultRegistrationFluentApiShape>;
+    behaviorsRegistered?: boolean;
+    controllersRegistered?: boolean;
+}
+
+interface SDuXShape {
+    /**
+     * Global Vault monitor instance.
+     */
+    vaultMonitorInstance?: VaultMonitorContract;
+    /**
+     * Global Vault event bus instance.
+     */
+    vaultEventBus?: EventBusContract;
+    debugWidget?: {
+        versions?: Record<string, string>;
+        injected?: boolean;
+        getRegistry?: () => ReadonlyMap<string, VaultRegistrationShape>;
+    };
+}
+
+/**
+ * Comparison function used by withDistinctUntilChanged to determine
+ * whether the new incoming value should be considered equal to the
+ * previously emitted value.
+ *
+ * @typeParam T - The value type being compared.
+ */
+type DistinctComparison<T> = (a: T, b: T) => boolean;
+
+/**
+ * Represents the final UI-facing value flowing out of a FeatureCell.
+ *
+ * A `PipelineValue<T>` is the resolved form of state after all
+ * pipeline stages
+ *
+ * Unlike internal pipeline values, this UI-facing type never includes
+ *
+ * @typeParam T - The underlying state type maintained by the FeatureCell.
+ */
+type PipelineValue<T> = T | undefined;
+
+type FinalState<T> = PipelineUpstreamValue<T> | typeof VAULT_STOP;
+
+/**
+ * Creates a normalized behavior key identifier used for behavior registration.
+ *
+ * A behavior key uniquely identifies a behavior within the Vault pipeline,
+ * following the canonical format:
+ *
+ * `SDUX::<Domain>::<Name>`
+ *
+ * Both `domain` and `name` are normalized by:
+ * - capitalizing the first character
+ * - removing all non-alphanumeric characters
+ *
+ * This ensures consistent and predictable behavior keys for orchestration,
+ * diagnostics, and tooling.
+ *
+ * @param domain - The logical domain or category of the behavior.
+ * @param name - The specific behavior name within the domain.
+ * @returns A normalized behavior key string.
+ */
+declare function defineBehaviorKey(domain: string, name: string): string;
+/**
+ * Validates whether a string conforms to the Vault behavior key format.
+ *
+ * A valid behavior key must follow the structure:
+ *
+ * `SDUX::<Domain>::<Name>`
+ *
+ * Where `<Domain>` and `<Name>` begin with an uppercase character and contain
+ * only alphanumeric characters.
+ *
+ * @param key - The behavior key string to validate.
+ * @returns `true` if the key matches the required pattern; otherwise `false`.
+ */
+declare function validateBehaviorKey(key: string): boolean;
+
+declare function defineControllerKey(domain: string, name: string): string;
+declare function validateControllerKey(key: string): boolean;
+
+declare function isDeferredFactory<T = unknown>(value: unknown): value is DeferredFactory<T>;
+
+declare const DevMode: {
+    readonly active: boolean;
+    setDevMode(isDevMode: boolean): void;
+};
+
+declare const isTestEnv: {
+    readonly active: boolean;
+};
+
+/**
+ * Normalizes any thrown error into a canonical `VaultError` structure.
+ *
+ * This ensures that all errors—HTTP, runtime, string, or unknown—
+ * are represented consistently throughout the Vault error pipeline.
+ *
+ * @param err - The raw thrown value.
+ * @param featureCellKey - the origination of the error
+ * @returns A fully normalized `VaultError`.
+ */
+declare function createVaultError(err: unknown, featureCellKey: string): VaultErrorShape;
+
+declare const isolateValue: <T>(value: T) => T;
+
+/**
+ * Emits an `error`-level Vault log message.
+ *
+ * @param args - Console arguments to log.
+ */
+declare const vaultError: (...args: any[]) => void;
+/**
+ * Emits a `warn`-level Vault log message.
+ *
+ * @param args - Console arguments to log.
+ */
+declare const vaultWarn: (...args: any[]) => void;
+/**
+ * Emits a `log`-level Vault log message.
+ *
+ * @param args - Console arguments to log.
+ */
+declare const vaultLog: (...args: any[]) => void;
+/**
+ * Emits a `debug`-level Vault log message.
+ *
+ * @param args - Console arguments to log.
+ */
+declare const vaultDebug: (...args: any[]) => void;
+declare function setVaultLogLevel(level: LogLevelType): void;
+declare function getVaultLogLevel(): LogLevelType;
+
+/**
+ * Indicates whether a final pipeline value represents a NOOP condition.
+ *
+ * @param current - The computed pipeline result.
+ * @returns `true` if the value is the `VAULT_NOOP` sentinel.
+ */
+declare const isVaultNoop: <T>(current: FinalState<T>) => boolean;
+declare const isVaultClearState: <T>(current: FinalState<T>) => boolean;
+declare const isVaultContinue: <T>(current: FinalState<T>) => boolean;
+/**
+ * Checks whether a value is exactly `null`.
+ *
+ * @param current - The value to check.
+ * @returns `true` if the value is `null`.
+ */
+declare const isNull: (current: unknown) => current is null;
+/**
+ * Checks whether a value is exactly `undefined`.
+ *
+ * @param current - The value to check.
+ * @returns `true` if the value is `undefined`.
+ */
+declare const isUndefined: (current: unknown) => current is undefined;
+/**
+ * Determines whether a value is defined (not `undefined`).
+ * Note: This intentionally does *not* exclude `null`.
+ *
+ * @param current - The value to check.
+ * @returns `true` if the value is not `undefined`.
+ */
+declare const isDefined: (current: unknown) => boolean;
+/**
+ * Determines whether a value is nullish — meaning either `null` or `undefined`.
+ *
+ * @param current - The value to inspect.
+ * @returns `true` for `null` or `undefined`, otherwise `false`.
+ */
+declare const isNullish: (current: unknown) => current is null | undefined;
+declare const isFunction: (value: unknown) => value is (...args: any[]) => unknown;
+declare const isObject: (value: unknown) => value is Record<string, unknown>;
+declare const isStateInputShape: <T>(value: unknown) => value is StateInputShape<T>;
+
+declare function isPromise<T = unknown>(value: unknown): value is Promise<T>;
+
+/**
+ * Type guard that determines whether a value is an `HttpResourceRef<T>`.
+ *
+ * An `HttpResourceRef` is a structured object produced by Angular’s
+ * `HttpClient` resource APIs. It contains a standardized shape used by
+ * Vault to detect and normalize resource-backed state transitions.
+ *
+ * This utility checks only for the presence of the canonical
+ * `HttpResourceRef` fields (`value`, `isLoading`, `error`, `hasValue`)
+ * and does not validate the internal content of those properties.
+ *
+ * @typeParam T - The resource value type.
+ *
+ * @param obj - The value to test.
+ * @returns `true` if the value matches the structural shape of an
+ *          `HttpResourceRef<T>`, otherwise `false`.
+ */
+declare function isHttpResourceRef<T>(obj: any): obj is HttpResourceRefShape<T>;
+
+/**
+ * Safely converts an arbitrary value into a JSON string representation.
+ *
+ * This function wraps `JSON.stringify` with enhanced handling for non-serializable
+ * values, including:
+ * - functions
+ * - `Error` objects
+ * - `Map` and `Set` instances
+ * - circular references
+ *
+ * If serialization fails for any reason, a fallback string `"[unserializable]"`
+ * is returned. The replacer ensures stable and predictable stringification for
+ * use in logging and debugging utilities.
+ *
+ * @param value - The value to stringify safely.
+ * @returns A JSON-formatted string or a fallback indicator.
+ */
+declare function safeStringify(value: unknown): string;
+
+declare const registerVersion: (packageName: string, version: string) => void;
+
+export { AbstractActiveController, AbstractErrorCallbackBehavior, AbstractErrorTransformBehavior, BEHAVIOR_META, BehaviorTypes, CONTROLLER_META, ControllerMessageTypes, ControllerTypes, ControllerVotes, DEVTOOLS_AGGREGATE_KEY_CONSTANT, DEVTOOLS_LOGGING_KEY_CONSTANT, DecisionOutcomeTypes, DevMode, EventBoundaryTypes, EventTypes, LogLevelTypes, OperationTypes, ResolveTypes, StateEmitTypes, VAULT_CLEAR_STATE, VAULT_CONTINUE, VAULT_NOOP, VAULT_STOP, VaultBehavior, VaultController, VaultEncryptionIntegrityError, VaultError, VaultErrorKindTypes, VaultErrorNameTypes, VaultErrorService, VaultErrorUsageKindTypes, VaultLicenseError, VaultPrivateErrorService, VaultUsageError, VaultUsagePromiseError, VaultUsagePromiseFactoryRequiredError, createVaultError, defineBehaviorKey, defineControllerKey, getVaultLogLevel, isDeferredFactory, isDefined, isFunction, isHttpResourceRef, isNull, isNullish, isObject, isPromise, isStateInputShape, isTestEnv, isUndefined, isVaultClearState, isVaultContinue, isVaultNoop, isolateValue, registerVersion, safeStringify, setVaultLogLevel, validateBehaviorKey, validateControllerKey, vaultDebug, vaultError, vaultLog, vaultWarn };
+export type { AfterTapBehaviorContract, BeforeTapBehaviorContract, BehaviorClassContext, BehaviorClassContract, BehaviorContext, BehaviorContract, BehaviorExtFunction, BehaviorExtension, BehaviorMetaShape, BehaviorType, CellBuilderContract, ControllerAttemptMessageShape, ControllerClassContext, ControllerClassContract, ControllerContext, ControllerContract, ControllerDecisionShape, ControllerFailMessageShape, ControllerFinalizeMessageShape, ControllerMessageShape, ControllerMessageType, ControllerMetaShape, ControllerSuccessMessageShape, ControllerType, ControllerVote, CoreEmitStateBehaviorContract, CoreEmitStateCallback, CoreEmitStateResult, DecisionOutcomeType, DeferredFactory, DeferredType, DevPipelineObserverBehaviorContract, DistinctComparison, EncryptBehaviorContract, ErrorCallbackBehaviorContract, ErrorTransformBehaviorContract, EventBoundaryType, EventBusContract, EventShape, EventType, FeatureCellBaseShape, FeatureCellExtension, FeatureCellExtensionContext, FeatureCellFluentApi, FilterBehaviorContract, FilterFunction, FinalState, HttpResourceRefShape, InsightConfig, InterceptorBehaviorClassContract, InterceptorBehaviorContract, InterceptorStateType, LogLevelType, MergeBehaviorContract, MergeConfig, ObjectDeepMergeConfig, OperationType, OperatorBehaviorContract, OperatorsBehaviorClassContract, PersistBehaviorContract, PipelinePersistValue, PipelineUpstreamValue, PipelineValue, ReduceBehaviorContract, ReducerFunction, ResolveBehaviorContract, ResolveType, SDuXShape, StateEmitSnapshotShape, StateEmitType, StateInputShape, StateInputType, StateSnapshotShape, StepwiseBehaviorContract, TapCallback, VaultConfig, VaultErrorCallback, VaultErrorKindType, VaultErrorNameType, VaultErrorServiceContract, VaultErrorShape, VaultErrorUsageKindType, VaultLicensingShape, VaultMonitorContract, VaultPrivateErrorServiceContract, VaultRegistrationEntityShape, VaultRegistrationFluentApiShape, VaultRegistrationShape };