import { type Encodable, type SensitivityMask } from "@automate.ax/codec";
import { type AutomationErrorValue } from "@automate.ax/api-contract/errors";
import type { SignalDerivation } from "@automate.ax/api-contract/runtime";
import type ms from "ms";
import type { AutomationRunState, RuntimeValueContext } from "./runtime.js";
import type { SignalCoreMethods, SignalMethods, SignalRegisteredMethods, SignalReservedMethods } from "./signal-methods.js";
export declare const signalDependencyCollector: unique symbol;
export declare const signalDependencyBinder: unique symbol;
declare const SIGNAL_DERIVATION_DEFINITION: unique symbol;
export declare const signalContextDependencyCollector: unique symbol;
export declare const signalContextOrigins: unique symbol;
export declare const signalAncestorOrigins: unique symbol;
export declare const signalGlobal: unique symbol;
export declare const signalIndex: unique symbol;
export declare const signalOrigins: unique symbol;
export declare const signalResolver: unique symbol;
export declare const signalValueType: unique symbol;
/** Author-safe normalized error exposed by signal lifecycle APIs. */
export type AutomationError = AutomationErrorValue;
/** A signal's mutually exclusive terminal outcome. */
export type SignalOutcome<T = unknown> = {
    status: "closed";
} | {
    failure: AutomationError;
    status: "failed";
} | {
    sensitivity?: SensitivityMask;
    status: "succeeded";
    value: T;
};
export type SignalDependencyResolution = {
    outcomeSeq: number;
    status: "closed";
} | {
    failure: AutomationError;
    outcomeSeq: number;
    status: "failed";
} | {
    status: "pending";
} | {
    outcomeSeq: number;
    status: "succeeded";
};
export interface SignalDependencySets {
    actionDependencyIds: Set<string>;
    eventDependencyIds: Set<string>;
    signalDependencyIds: Set<string>;
}
/** Compact duration literal accepted by the platform duration parser. */
export type DurationString = ms.StringValue;
/** Rejects callbacks whose inferred result is asynchronous. */
export type Synchronous<TFunction extends (...arguments_: never[]) => unknown> = [
    ReturnType<TFunction>
] extends [never] ? unknown : ReturnType<TFunction> extends PromiseLike<unknown> ? never : unknown;
interface SignalBehavior<T> {
    ancestorOrigins?: readonly string[];
    collect(this: void, state: AutomationRunState, dependencies: SignalDependencySets): SignalDependencyResolution;
    collectContext?: SignalBehavior<T>["collect"];
    contextOrigins?: readonly string[];
    derivation?: SignalDerivationDefinition;
    origins: readonly string[];
    resolve(this: void, context: RuntimeValueContext): SignalOutcome<T>;
}
type SignalDerivationDefinition = {
    inputs: readonly Signal[];
    property: string;
    type: "property";
} | {
    inputs: readonly Signal[];
    type: "transform" | "transparent";
};
export interface SignalIndexDefinition<T> {
    getKey(value: T, context: RuntimeValueContext): Encodable;
    getPosition?(value: T, context: RuntimeValueContext): number;
}
/** Maps a payload's properties to child signals. */
type SignalProperties<T> = {
    readonly [TKey in keyof NonNullable<T> as TKey extends keyof SignalProtocol<T> | keyof SignalCoreMethods<T> | keyof SignalReservedMethods ? never : TKey extends string | number ? TKey : never]-?: NonNullable<T>[TKey] extends (...arguments_: never[]) => unknown ? never : Signal<NonNullable<T>[TKey]>;
};
type SignalProtocol<T> = {
    readonly [signalAncestorOrigins]: readonly string[];
    readonly [signalContextDependencyCollector]: SignalBehavior<T>["collect"];
    readonly [signalContextOrigins]: readonly string[];
    readonly [signalDependencyBinder]: (dependency: Signal) => Signal<T>;
    readonly [signalDependencyCollector]: SignalBehavior<T>["collect"];
    readonly [SIGNAL_DERIVATION_DEFINITION]?: SignalDerivationDefinition;
    readonly [signalGlobal]?: true;
    readonly [signalIndex]?: SignalIndexDefinition<T>;
    readonly [signalOrigins]: readonly string[];
    readonly [signalResolver]: SignalBehavior<T>["resolve"];
    readonly [signalValueType]: () => T;
};
/**
 * A durable symbolic reference to a value that will be materialized during
 * automation execution.
 *
 * Signals compose synchronously while their values are unavailable. Accessing a
 * property creates a derived signal, so `request.path` is equivalent to
 * `request.transform((value) => value.path)`. Property access can be chained
 * across objects and primitives; for example, `request.path.length` is a
 * `Signal<number>`. Resolving a property derived from a `null` or `undefined`
 * value throws a `TypeError`.
 *
 * Function-valued properties are reserved for signal methods rather than
 * projected as callable values. Use `transform` to invoke a method on the
 * materialized value.
 *
 * @template T - Value represented by the signal.
 */
export type Signal<T = unknown> = SignalProtocol<T> & SignalCoreMethods<T> & SignalMethods & SignalProperties<T> & object;
/** A signal carrying a durable cross-context key definition. */
export type KeyedSignal<T = unknown> = Signal<T> & {
    readonly [signalIndex]: SignalIndexDefinition<T>;
};
/** A signal explicitly using one shared partition per cross-context operator. */
export type GlobalSignal<T = unknown> = Signal<T> & {
    readonly [signalGlobal]: true;
};
/** Preserves a source's explicit keyed or global coordination mode. */
export type InheritSignalCoordination<TSignal extends Signal, TValue> = TSignal extends KeyedSignal ? KeyedSignal<TValue> : TSignal extends GlobalSignal ? GlobalSignal<TValue> : Signal<TValue>;
export type InferSignal<TSignal extends Signal> = TSignal extends TSignal ? ReturnType<TSignal[typeof signalValueType]> : never;
/** Internal control-flow marker for a signal that closed without emitting. */
export declare class ClosedSignalError extends Error {
    name: string;
}
/** Internal control-flow marker carrying a failed signal's details. */
export declare class FailedSignalError extends Error {
    readonly failure: AutomationError;
    name: string;
    /** @param failure - Failure propagated from the resolved signal. */
    constructor(failure: AutomationError);
}
/** Raised when merged parent histories expose multiple values at one slot. */
export declare class AmbiguousSignalError extends Error {
    name: string;
}
/**
 * Determines whether a value implements the internal signal protocol.
 *
 * @param value - Value to inspect.
 */
export declare function isSignal(value: unknown): value is Signal;
/**
 * Installs the public fluent adapters used by every signal proxy.
 *
 * @param implementations - Source-first functions keyed by fluent method name.
 */
export declare function registerSignalMethodImplementations(implementations: Readonly<Record<keyof SignalRegisteredMethods, unknown>>): void;
/**
 * Combines dependencies that must all succeed.
 *
 * @param outcomes - Dependency states to combine.
 */
export declare function combineSignalDependencyOutcomes(outcomes: SignalDependencyResolution[]): SignalDependencyResolution;
/**
 * Materializes the explanatory source, property, and transform graph consumed
 * by one durable declaration.
 *
 * @param signals - Signal roots consumed by the declaration.
 * @param state - Current runtime occurrence used to resolve durable sources.
 * @param selectedDependencies - Exact durable sources selected by dependency
 *   traversal.
 */
export declare function buildSignalDerivation(signals: readonly Signal[], state: AutomationRunState, ...selectedDependencies: [SignalDependencySets, ...SignalDependencySets[]]): SignalDerivation | null;
/**
 * Creates a derived signal from explicit signal inputs and a pure transformer.
 *
 * Dependency collection traverses the inputs without invoking the transformer.
 * The transformer runs only after the runtime materializes every input.
 *
 * @param inputs - Signals consumed by the transformer.
 * @param transformer - Pure function that computes the derived value.
 */
export declare function transform<const TValues extends readonly [unknown, ...unknown[]], TTransformer extends (...inputs: TValues) => unknown>(inputs: {
    readonly [TIndex in keyof TValues]: Signal<TValues[TIndex]>;
}, transformer: Synchronous<TTransformer> extends never ? never : TTransformer): Signal<ReturnType<TTransformer>>;
/** @inheritdoc */
export declare function transform<TValue, TTransformer extends (input: TValue) => unknown>(input: Signal<TValue>, transformer: Synchronous<TTransformer> extends never ? never : TTransformer): Signal<ReturnType<TTransformer>>;
/**
 * Normalizes an unknown thrown value for public automation lifecycle handling.
 *
 * @param error - Thrown value to normalize.
 * @param fallbackCode - Classification used when the error has no stable code.
 */
export declare function normalizeAutomationError(error: unknown, fallbackCode?: string): AutomationError;
/**
 * Copies an explicit keyed or global coordination mode to a value-preserving
 * signal result.
 *
 * @param source - Signal whose coordination mode is retained.
 * @param result - Value-preserving result signal.
 */
export declare function inheritSignalCoordination<TSignal extends Signal, TValue>(source: TSignal, result: Signal<TValue>): InheritSignalCoordination<TSignal, TValue>;
/**
 * Exposes static properties on a transparent wrapper around a signal.
 *
 * @param signal - Signal whose value and dependency behavior are retained.
 * @param staticProperties - Properties exposed directly on the returned proxy.
 */
export declare function withSignalStaticProperties<TValue, const TStatic extends object>(signal: Signal<TValue>, staticProperties: TStatic): SignalProtocol<TValue> & SignalCoreMethods<TValue> & SignalMethods & SignalProperties<TValue> & object & Readonly<TStatic>;
/**
 * Creates a proxy implementing behavior shared by every signal.
 *
 * @param behavior - Dependency, origin, and resolution behavior.
 * @param staticProperties - Values exposed directly instead of as projections.
 */
export declare function createSignal<T, const TStatic extends object = object>(behavior: SignalBehavior<T>, staticProperties?: TStatic): Signal<T> & Readonly<TStatic>;
export {};
//# sourceMappingURL=signal-protocol.d.ts.map