import type { Observable } from 'rxjs';
import { Subject } from 'rxjs';
import type { AddSpanToRecordingEvent, DefinitionModifiedEvent, RequiredSpanSeenEvent, StateTransitionEvent } from './debugTypes';
import { type CPUIdleLongTaskProcessor, type PerformanceEntryLike } from './firstCPUIdle';
import { type SpanMatcherFn } from './matchSpan';
import type { SpanAndAnnotation, SpanAnnotationRecord } from './spanAnnotationTypes';
import { type ActiveTraceConfig, type DraftTraceInput, type Span } from './spanTypes';
import type { TraceRecording } from './traceRecordingTypes';
import type { CompleteTraceDefinition, DraftTraceContext, InterruptionReasonPayload, RelationSchemasBase, TraceContext, TraceDefinitionModifications, TraceInterruptionReason, TraceModifications, TraceUtilities, TransitionDraftOptions } from './types';
import type { DistributiveOmit, StateHandlerPayloads } from './typeUtils';
declare const INITIAL_STATE = "draft";
type InitialTraceState = typeof INITIAL_STATE;
export type NonTerminalTraceStates = InitialTraceState | 'active' | 'debouncing' | 'waiting-for-interactive' | 'waiting-for-children';
export declare const TERMINAL_STATES: readonly ["interrupted", "complete"];
type TerminalTraceStates = (typeof TERMINAL_STATES)[number];
export type TraceStates = NonTerminalTraceStates | TerminalTraceStates;
export declare const isTerminalState: (state: TraceStates) => state is TerminalTraceStates;
export declare const isEnteringTerminalState: <RelationSchemasT extends RelationSchemasBase<RelationSchemasT>>(onEnterState: OnEnterStatePayload<RelationSchemasT>) => onEnterState is FinalTransition<RelationSchemasT>;
export declare const shouldPropagateChildInterruptToParent: (childTraceInterruptionReason: TraceInterruptionReason) => boolean;
interface OnEnterActive {
    transitionToState: 'active';
    transitionFromState: NonTerminalTraceStates;
}
interface OnEnterInterrupted<RelationSchemasT extends RelationSchemasBase<RelationSchemasT>> {
    transitionToState: 'interrupted';
    transitionFromState: NonTerminalTraceStates;
    interruption: InterruptionReasonPayload<RelationSchemasT>;
    lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
}
interface OnEnterComplete<RelationSchemasT extends RelationSchemasBase<RelationSchemasT>> {
    transitionToState: 'complete';
    transitionFromState: NonTerminalTraceStates;
    interruption?: InterruptionReasonPayload<RelationSchemasT>;
    cpuIdleSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
    completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
    lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
    lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
}
export type FinalTransition<RelationSchemasT extends RelationSchemasBase<RelationSchemasT>> = OnEnterInterrupted<RelationSchemasT> | OnEnterComplete<RelationSchemasT>;
interface OnEnterWaitingForInteractive {
    transitionToState: 'waiting-for-interactive';
    transitionFromState: NonTerminalTraceStates;
}
interface OnEnterWaitingForChildren {
    transitionToState: 'waiting-for-children';
    transitionFromState: NonTerminalTraceStates;
}
interface OnEnterDebouncing {
    transitionToState: 'debouncing';
    transitionFromState: NonTerminalTraceStates;
}
export type OnEnterStatePayload<RelationSchemasT extends RelationSchemasBase<RelationSchemasT>> = OnEnterActive | OnEnterInterrupted<RelationSchemasT> | OnEnterComplete<RelationSchemasT> | OnEnterDebouncing | OnEnterWaitingForInteractive | OnEnterWaitingForChildren;
export type Transition<RelationSchemasT extends RelationSchemasBase<RelationSchemasT>> = DistributiveOmit<OnEnterStatePayload<RelationSchemasT>, 'transitionFromState'>;
export type States<SelectedRelationNameT extends keyof RelationSchemasT, RelationSchemasT extends RelationSchemasBase<RelationSchemasT>, VariantsT extends string> = TraceStateMachine<SelectedRelationNameT, RelationSchemasT, VariantsT>['states'];
interface ChildEndEvent<RelationSchemasT extends RelationSchemasBase<RelationSchemasT>> {
    childTrace: AllPossibleTraces<RelationSchemasT>;
    terminalState: 'complete' | 'interrupted';
    interruption?: InterruptionReasonPayload<RelationSchemasT>;
}
interface TraceStateMachineSideEffectHandlers<RelationSchemasT extends RelationSchemasBase<RelationSchemasT>> {
    readonly addSpanToRecording: (spanAndAnnotation: SpanAndAnnotation<RelationSchemasT>) => void;
    readonly onTerminalStateReached: (transition: FinalTransition<RelationSchemasT>) => void;
    readonly onError: (error: Error) => void;
}
type EntryType<RelationSchemasT extends RelationSchemasBase<RelationSchemasT>> = PerformanceEntryLike & {
    entry: SpanAndAnnotation<RelationSchemasT>;
};
interface StateMachineContext<SelectedRelationNameT extends keyof RelationSchemasT, RelationSchemasT extends RelationSchemasBase<RelationSchemasT>, VariantsT extends string> extends DraftTraceContext<SelectedRelationNameT, RelationSchemasT, VariantsT> {
    sideEffectFns: TraceStateMachineSideEffectHandlers<RelationSchemasT>;
    children: ReadonlySet<AllPossibleTraces<RelationSchemasT>>;
    terminalStateChildren: ReadonlySet<AllPossibleTraces<RelationSchemasT>>;
    eventSubjects: {
        'state-transition': Subject<StateTransitionEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
        'required-span-seen': Subject<RequiredSpanSeenEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
        'add-span-to-recording': Subject<AddSpanToRecordingEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
        'definition-modified': Subject<DefinitionModifiedEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
    };
}
type DeadlineType = 'global' | 'debounce' | 'interactive' | 'next-quiet-window';
export declare class TraceStateMachine<SelectedRelationNameT extends keyof RelationSchemasT, RelationSchemasT extends RelationSchemasBase<RelationSchemasT>, const VariantsT extends string> {
    #private;
    constructor(context: StateMachineContext<SelectedRelationNameT, RelationSchemasT, VariantsT>);
    readonly successfullyMatchedRequiredSpanMatchers: Set<SpanMatcherFn<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
    get sideEffectFns(): TraceStateMachineSideEffectHandlers<RelationSchemasT>;
    currentState: TraceStates;
    /** the span that ended at the furthest point in time */
    lastRelevant: SpanAndAnnotation<RelationSchemasT> | undefined;
    lastRequiredSpan: SpanAndAnnotation<RelationSchemasT> | undefined;
    /** it is set once the LRS value is established */
    completeSpan: SpanAndAnnotation<RelationSchemasT> | undefined;
    cpuIdleLongTaskProcessor: CPUIdleLongTaskProcessor<EntryType<RelationSchemasT>> | undefined;
    nextDeadlineRef: ReturnType<typeof setTimeout> | undefined;
    setDeadline(deadlineType: Exclude<DeadlineType, 'global'>, deadlineEpoch: number): void;
    setGlobalDeadline(deadline: number): void;
    clearDeadline(): void;
    /**
     * while debouncing, we need to buffer any spans that come in so they can be re-processed
     * once we transition to the 'waiting-for-interactive' state
     * otherwise we might miss out on spans that are relevant to calculating the interactive
     *
     * if we have long tasks before FMP, we want to use them as a potential grouping post FMP.
     */
    debouncingSpanBuffer: SpanAndAnnotation<RelationSchemasT>[];
    readonly states: {
        draft: {
            onEnterState: () => undefined;
            onMakeActive: () => {
                transitionToState: "active";
            };
            onProcessSpan: (spanAndAnnotation: SpanAndAnnotation<RelationSchemasT>) => {
                readonly transitionToState: "interrupted";
                readonly interruption: {
                    readonly reason: "timeout";
                };
                readonly lastRelevantSpanAndAnnotation: undefined;
            } | {
                readonly transitionToState: "interrupted";
                readonly interruption: {
                    readonly reason: "matched-on-interrupt" | "matched-on-required-span-with-error";
                };
                readonly lastRelevantSpanAndAnnotation: undefined;
            } | undefined;
            onInterrupt: (reasonPayload: InterruptionReasonPayload<RelationSchemasT>) => {
                readonly transitionToState: "interrupted";
                readonly interruption: InterruptionReasonPayload<RelationSchemasT>;
                readonly lastRelevantSpanAndAnnotation: undefined;
            };
            onDeadline: (deadlineType: DeadlineType) => {
                readonly transitionToState: "interrupted";
                readonly interruption: {
                    readonly reason: "timeout";
                };
                readonly lastRelevantSpanAndAnnotation: undefined;
            } | undefined;
            onChildEnd: (event: ChildEndEvent<RelationSchemasT>) => {
                readonly transitionToState: "interrupted";
                readonly interruption: {
                    readonly reason: "child-interrupted" | "child-timeout";
                };
                readonly lastRelevantSpanAndAnnotation: undefined;
            } | undefined;
        };
        active: {
            onEnterState: (_transition: OnEnterActive) => Transition<RelationSchemasT> | undefined;
            onProcessSpan: (spanAndAnnotation: SpanAndAnnotation<RelationSchemasT>) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "timeout";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | {
                transitionToState: "interrupted";
                interruption: {
                    reason: "matched-on-interrupt" | "matched-on-required-span-with-error";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT>;
            } | {
                transitionToState: "debouncing";
                interruption?: undefined;
                lastRelevantSpanAndAnnotation?: undefined;
            } | undefined;
            onInterrupt: (reasonPayload: InterruptionReasonPayload<RelationSchemasT>) => {
                transitionToState: "interrupted";
                interruption: InterruptionReasonPayload<RelationSchemasT>;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            };
            onDeadline: (deadlineType: DeadlineType) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "timeout";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | undefined;
            onChildEnd: (event: ChildEndEvent<RelationSchemasT>) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "child-interrupted" | "child-timeout";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | undefined;
        };
        debouncing: {
            onEnterState: (_payload: OnEnterDebouncing) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "invalid-state-transition";
                };
                lastRelevantSpanAndAnnotation: undefined;
            } | {
                transitionToState: "waiting-for-interactive";
                interruption?: undefined;
                lastRelevantSpanAndAnnotation?: undefined;
            } | undefined;
            onDeadline: (deadlineType: DeadlineType) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "timeout";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | {
                transitionToState: "waiting-for-children";
                interruption?: undefined;
                lastRelevantSpanAndAnnotation?: undefined;
            } | {
                transitionToState: "waiting-for-interactive";
                interruption?: undefined;
                lastRelevantSpanAndAnnotation?: undefined;
            } | undefined;
            onProcessSpan: (spanAndAnnotation: SpanAndAnnotation<RelationSchemasT>) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "timeout";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | {
                transitionToState: "interrupted";
                interruption: {
                    reason: "matched-on-interrupt" | "matched-on-required-span-with-error";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT>;
            } | {
                transitionToState: "waiting-for-interactive";
                interruption?: undefined;
                lastRelevantSpanAndAnnotation?: undefined;
            } | {
                transitionToState: "interrupted";
                interruption: {
                    reason: "idle-component-no-longer-idle";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | undefined;
            onInterrupt: (reasonPayload: InterruptionReasonPayload<RelationSchemasT>) => {
                transitionToState: "interrupted";
                interruption: InterruptionReasonPayload<RelationSchemasT>;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            };
            onChildEnd: (event: ChildEndEvent<RelationSchemasT>) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "child-interrupted" | "child-timeout";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | undefined;
        };
        'waiting-for-interactive': {
            onEnterState: (_payload: OnEnterWaitingForInteractive) => Transition<RelationSchemasT> | undefined;
            onDeadline: (deadlineType: DeadlineType) => {
                transitionToState: "complete";
                interruption: {
                    reason: "timeout";
                };
                completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                cpuIdleSpanAndAnnotation: undefined;
            } | {
                transitionToState: "complete";
                lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                cpuIdleSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT>;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                interruption?: undefined;
            } | undefined;
            onProcessSpan: (spanAndAnnotation: SpanAndAnnotation<RelationSchemasT>) => {
                transitionToState: "waiting-for-children";
                readonly lastRequiredSpanAndAnnotation?: undefined;
                readonly completeSpanAndAnnotation?: undefined;
                readonly cpuIdleSpanAndAnnotation?: undefined;
                lastRelevantSpanAndAnnotation?: undefined;
                interruption?: undefined;
                readonly interruptionReason?: undefined;
            } | {
                transitionToState: "complete";
                lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                cpuIdleSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT>;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                interruption?: undefined;
                readonly interruptionReason?: undefined;
            } | {
                transitionToState: "complete";
                interruption: {
                    reason: "timeout";
                };
                lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                cpuIdleSpanAndAnnotation: undefined;
                readonly interruptionReason?: undefined;
            } | {
                transitionToState: "complete";
                interruption: {
                    reason: "waiting-for-interactive-timeout";
                };
                lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                cpuIdleSpanAndAnnotation: undefined;
                readonly interruptionReason?: undefined;
            } | {
                readonly transitionToState: "waiting-for-children";
                readonly interruptionReason: {
                    reason: string;
                };
                readonly lastRequiredSpanAndAnnotation?: undefined;
                readonly completeSpanAndAnnotation?: undefined;
                readonly cpuIdleSpanAndAnnotation?: undefined;
                lastRelevantSpanAndAnnotation?: undefined;
                interruption?: undefined;
            } | {
                readonly transitionToState: "complete";
                readonly interruption: {
                    reason: "matched-on-required-span-with-error";
                } | {
                    reason: "matched-on-interrupt";
                };
                readonly lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                readonly completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                readonly lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                readonly cpuIdleSpanAndAnnotation: undefined;
                readonly interruptionReason?: undefined;
            } | undefined;
            onInterrupt: (reasonPayload: InterruptionReasonPayload<RelationSchemasT>) => {
                transitionToState: "complete";
                interruption: InterruptionReasonPayload<RelationSchemasT>;
                lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                cpuIdleSpanAndAnnotation: undefined;
            };
            onChildEnd: (event: ChildEndEvent<RelationSchemasT>) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "child-interrupted" | "child-timeout";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | undefined;
        };
        'waiting-for-children': {
            onEnterState: (_payload: OnEnterWaitingForChildren) => {
                transitionToState: "complete";
                completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                cpuIdleSpanAndAnnotation: undefined;
                lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | undefined;
            onChildEnd: (event: ChildEndEvent<RelationSchemasT>) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "child-interrupted" | "child-timeout";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                readonly completeSpanAndAnnotation?: undefined;
                readonly cpuIdleSpanAndAnnotation?: undefined;
                readonly lastRequiredSpanAndAnnotation?: undefined;
            } | {
                transitionToState: "complete";
                completeSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                cpuIdleSpanAndAnnotation: undefined;
                lastRequiredSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
                interruption?: undefined;
            } | undefined;
            onProcessSpan: (spanAndAnnotation: SpanAndAnnotation<RelationSchemasT>) => undefined;
            onInterrupt: (reasonPayload: InterruptionReasonPayload<RelationSchemasT>) => {
                transitionToState: "interrupted";
                interruption: InterruptionReasonPayload<RelationSchemasT>;
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            };
            onDeadline: (deadlineType: DeadlineType) => {
                transitionToState: "interrupted";
                interruption: {
                    reason: "timeout";
                };
                lastRelevantSpanAndAnnotation: SpanAndAnnotation<RelationSchemasT> | undefined;
            } | undefined;
        };
        interrupted: {
            onEnterState: (transition: OnEnterInterrupted<RelationSchemasT>) => undefined;
        };
        complete: {
            onEnterState: (transition: OnEnterComplete<RelationSchemasT>) => undefined;
        };
    };
    /**
     * @returns the last OnEnterState event if a transition was made
     */
    emit<EventName extends keyof StateHandlerPayloads<SelectedRelationNameT, RelationSchemasT, VariantsT>>(event: EventName, payload: StateHandlerPayloads<SelectedRelationNameT, RelationSchemasT, VariantsT>[EventName], 
    /** if called recursively inside of an event handler, it must be set to true to avoid double handling of terminal state */
    internal?: boolean): OnEnterStatePayload<RelationSchemasT> | undefined;
}
export declare class Trace<const SelectedRelationNameT extends keyof RelationSchemasT, const RelationSchemasT extends RelationSchemasBase<RelationSchemasT>, const VariantsT extends string> implements TraceContext<SelectedRelationNameT, RelationSchemasT, VariantsT> {
    readonly sourceDefinition: CompleteTraceDefinition<SelectedRelationNameT, RelationSchemasT, VariantsT>;
    /** the source-of-truth - local copy of a final, mutable definition of this specific trace */
    definition: CompleteTraceDefinition<SelectedRelationNameT, RelationSchemasT, VariantsT>;
    wasActivated: boolean;
    get activeInput(): ActiveTraceConfig<SelectedRelationNameT, RelationSchemasT, VariantsT>;
    set activeInput(value: ActiveTraceConfig<SelectedRelationNameT, RelationSchemasT, VariantsT>);
    wasReplaced: boolean;
    input: DraftTraceInput<RelationSchemasT[SelectedRelationNameT], VariantsT>;
    readonly traceUtilities: TraceUtilities<RelationSchemasT>;
    get isDraft(): boolean;
    recordedItems: Map<string, SpanAndAnnotation<RelationSchemasT>>;
    occurrenceCounters: Map<string, number>;
    processedPerformanceEntries: WeakMap<PerformanceEntry, SpanAndAnnotation<RelationSchemasT>>;
    persistedDefinitionModifications: Set<TraceDefinitionModifications<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
    readonly recordedItemsByLabel: {
        [label: string]: Set<SpanAndAnnotation<RelationSchemasT>>;
    };
    stateMachine: TraceStateMachine<SelectedRelationNameT, RelationSchemasT, VariantsT>;
    children: Set<AllPossibleTraces<RelationSchemasT>>;
    terminalStateChildren: Set<AllPossibleTraces<RelationSchemasT>>;
    adoptChild(childTrace: AllPossibleTraces<RelationSchemasT>): void;
    onChildEnd(childTrace: AllPossibleTraces<RelationSchemasT>, stateTransition: FinalTransition<RelationSchemasT>, traceRecording: TraceRecording<keyof RelationSchemasT, RelationSchemasT> | undefined): void;
    canAdoptChild(childTraceName: string): boolean;
    eventSubjects: {
        'state-transition': Subject<StateTransitionEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
        'required-span-seen': Subject<RequiredSpanSeenEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
        'add-span-to-recording': Subject<AddSpanToRecordingEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
        'definition-modified': Subject<DefinitionModifiedEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
    };
    when(event: 'state-transition'): Observable<StateTransitionEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
    when(event: 'required-span-seen'): Observable<RequiredSpanSeenEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
    when(event: 'add-span-to-recording'): Observable<AddSpanToRecordingEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
    when(event: 'definition-modified'): Observable<DefinitionModifiedEvent<SelectedRelationNameT, RelationSchemasT, VariantsT>>;
    constructor(data: {
        definition: CompleteTraceDefinition<SelectedRelationNameT, RelationSchemasT, VariantsT>;
        input: DraftTraceInput<RelationSchemasT[SelectedRelationNameT], VariantsT>;
        definitionModifications?: TraceDefinitionModifications<SelectedRelationNameT, RelationSchemasT, VariantsT>;
        traceUtilities: TraceUtilities<RelationSchemasT>;
    } | {
        importFrom: Trace<SelectedRelationNameT, RelationSchemasT, VariantsT>;
        definitionModifications: TraceDefinitionModifications<SelectedRelationNameT, RelationSchemasT, VariantsT>;
    });
    toJSON(): {
        input: DraftTraceInput<RelationSchemasT[SelectedRelationNameT], VariantsT>;
        definition: {
            name: string;
        };
    };
    sideEffectFns: TraceStateMachineSideEffectHandlers<RelationSchemasT>;
    private postProcessSpans;
    interrupt(reasonPayload: InterruptionReasonPayload<RelationSchemasT>): void;
    transitionDraftToActive(inputAndDefinitionModifications: TraceModifications<SelectedRelationNameT, RelationSchemasT, VariantsT>, { previouslyActivatedBehavior, invalidRelatedToBehavior, }?: TransitionDraftOptions): void;
    /**
     * The additions to the definition may come from either the variant at transition from draft to active
     * @param definitionModifications
     */
    private applyDefinitionModifications;
    /**
     * This is used for importing spans when recreating a Trace from another Trace
     * if the definition was modified
     */
    private replayItems;
    processSpan<SpanT extends Span<RelationSchemasT>>(span: SpanT): {
        spanAndAnnotation: SpanAndAnnotation<RelationSchemasT>;
        annotationRecord: SpanAnnotationRecord;
    } | undefined;
    /**
     * Creates a new trace that adds additional required spans or debounce spans.
     * Note: This recreates the Trace instance with the modified definition
     * and replays all the recorded spans immediately.
     */
    recreateTraceWithDefinitionModifications(definitionModifications: TraceDefinitionModifications<SelectedRelationNameT, RelationSchemasT, VariantsT>): Trace<SelectedRelationNameT, RelationSchemasT, VariantsT>;
    private getSpanLabels;
}
export type AllPossibleTraces<RelationSchemasT extends RelationSchemasBase<RelationSchemasT>> = Trace<any, RelationSchemasT, any>;
export {};