import type { MastraMemory } from '../memory/memory.js';
import type { MemoryConfigInternal, StorageThreadType } from '../memory/types.js';
import type { MessageList } from './message-list/index.js';
import type { MastraDBMessage } from './message-list/state/types.js';
import type { AgentStateSignalInput, CreatedAgentSignal } from './signals.js';
export type StateSignalTracking = {
    currentCacheKey?: string;
    currentMode?: 'snapshot' | 'delta';
    version?: number;
    lastSignalId?: string;
    lastSnapshotSignalId?: string;
    updatedAt?: string;
    activeCopies?: Array<{
        id: string;
        cacheKey?: string;
        mode?: 'snapshot' | 'delta';
        version?: number;
    }>;
};
export type ActiveStateSignal = CreatedAgentSignal & {
    type: 'state';
    metadata?: Record<string, unknown> & {
        state?: {
            id?: string;
            threadId?: string;
            cacheKey?: string;
            version?: number;
            mode?: 'snapshot' | 'delta';
        };
    };
};
export type StateSignalHistory = {
    activeStateSignals: ActiveStateSignal[];
    contextWindow: {
        hasSnapshot: boolean;
    };
    lastSnapshot?: ActiveStateSignal;
    deltasSinceSnapshot: ActiveStateSignal[];
};
export type ApplyStateSignalResult = {
    skipped: true;
    reason: 'unchanged';
    stateId: string;
    tracking?: StateSignalTracking;
} | {
    skipped: false;
    signal: CreatedAgentSignal;
    stateId: string;
    version: number;
    tracking: StateSignalTracking;
};
export declare function getStateSignalsMetadata(threadMetadata?: Record<string, unknown>): Record<string, StateSignalTracking>;
export declare function setStateSignalMetadata(threadMetadata: Record<string, unknown> | undefined, stateId: string, tracking: StateSignalTracking): Record<string, unknown>;
export declare function sortStateSignals(signals: ActiveStateSignal[]): ActiveStateSignal[];
export declare function dbMessagesToStateSignals(messages: MastraDBMessage[], stateId: string | undefined, threadId: string): ActiveStateSignal[];
export declare function getActiveStateSignals(messageList: MessageList, stateId: string | undefined, threadId: string): ActiveStateSignal[];
export declare function mergeStateSignals(...signalGroups: ActiveStateSignal[][]): ActiveStateSignal[];
export declare function deriveStateSignalHistory(activeStateSignals: ActiveStateSignal[]): StateSignalHistory;
export declare function resolveStateSignalHistory({ messageList, memory, threadId, resourceId, stateId, tracking, }: {
    messageList: MessageList;
    memory: MastraMemory;
    threadId: string;
    resourceId: string;
    stateId: string;
    tracking?: StateSignalTracking;
}): Promise<StateSignalHistory>;
export declare function createStateSignalInput(input: AgentStateSignalInput | (Omit<AgentStateSignalInput, 'id'> & {
    id?: string;
}), options?: {
    defaultId?: string;
    acceptedAt?: Date;
}): {
    stateId: string;
    signal: CreatedAgentSignal;
    mode: 'snapshot' | 'delta';
    cacheKey: string;
};
export declare function applyStateSignal({ input, memory, thread, resourceId, threadId, memoryConfig, messageList, activeStateSignals, defaultId, acceptedAt, writeSignal, }: {
    input: AgentStateSignalInput | (Omit<AgentStateSignalInput, 'id'> & {
        id?: string;
    });
    memory: MastraMemory;
    thread: StorageThreadType;
    resourceId: string;
    threadId: string;
    memoryConfig?: MemoryConfigInternal;
    messageList?: MessageList;
    activeStateSignals?: ActiveStateSignal[];
    defaultId?: string;
    acceptedAt?: Date;
    writeSignal?: (signal: CreatedAgentSignal) => Promise<void> | void;
}): Promise<ApplyStateSignalResult>;
//# sourceMappingURL=state-signals.d.ts.map