import * as plugins from './plugins.js';
import { type IControllerProjectFilesystemIdentity } from './interfaces.projects.js';
type TFlexCreateSessionOptions = plugins.flexharness.IFlexCreateSessionOptions;
type TFlexMessage = plugins.flexharness.IFlexMessage;
type TFlexMessagePage = plugins.flexharness.IFlexMessagePage;
type TFlexPermissionRequest = plugins.flexharness.IFlexPermissionRequest;
export type TFlexPromptQueueEntry = plugins.flexharness.IFlexPromptQueueEntry;
type TFlexPromptOptions = plugins.flexharness.IFlexPromptOptions;
type TFlexSession = plugins.flexharness.IFlexSession;
type TFlexToolMessagePart = plugins.flexharness.IFlexToolMessagePart;
type TFlexReasoningMessagePart = Extract<plugins.flexharness.TFlexMessagePart, {
    type: 'reasoning';
}>;
type TFlexTextMessagePart = Extract<plugins.flexharness.TFlexMessagePart, {
    type: 'text';
}>;
type TFlexUpdateSessionOptions = plugins.flexharness.IFlexUpdateSessionOptions;
type TFlexPermissionDecision = plugins.flexharness.TFlexPermissionDecision;
type TFlexPrompt = plugins.flexharness.TFlexPrompt;
type TFlexProjectManagementRecord = plugins.flexharness.TFlexProjectManagementRecord;
type TFlexProjectManagementSnapshot = plugins.flexharness.IFlexProjectManagementSnapshot;
type TFlexProjectManagementTombstone = plugins.flexharness.IFlexProjectManagementTombstone;
type TFlexProjectManagementWriteContext = plugins.flexharness.IFlexProjectManagementWriteContext;
export type TFlexProjectManagementSessionContext = plugins.flexharness.IFlexProjectManagementSessionContext;
export type TFlexSubagentProvenance = plugins.flexharness.IFlexSubagentProvenance;
type TFlexJsonValue = plugins.flexharness.TJsonValue;
export type TFlexSessionGeneration = plugins.flexharness.IFlexSessionGeneration;
export type TFlexSessionGenerationCohortEntry = plugins.flexharness.IFlexSessionGenerationCohortEntry;
export type TFlexSlashCommandDescriptor = plugins.flexharness.IFlexSlashCommandDescriptor;
export type TFlexSessionReversionInfo = plugins.flexharness.IFlexSessionReversionInfo;
export type TFlexTurnReversionFinalizedOutcome = plugins.flexharness.TFlexTurnReversionFinalizedOutcome;
export type TFlexTurnReversionCaptureInspectionV2 = plugins.flexharness.TFlexTurnReversionCaptureInspectionV2;
export type TFlexTurnReversionApplyInspection = plugins.flexharness.IFlexTurnReversionApplyInspection;
export declare const flexIpcProtocolVersion: 18;
export declare const flexIpcMaximumFrameBytes: number;
export declare const flexIpcTargetDeltaBytes: number;
export declare const flexIpcMaximumDeltaBytes: number;
export declare const flexIpcMaximumPendingRequests = 64;
export declare const flexIpcMaximumBrowserChannels = 128;
export declare const flexIpcMaximumBrowserFrameBytes: number;
export declare const flexIpcMaximumPendingBrowserFrames = 128;
export declare const flexIpcMaximumPendingBrowserFrameBytes: number;
export declare const flexIpcMaximumChildJobs = 64;
export declare const flexIpcMaximumPromptQueueEntries = 128;
export declare const flexIpcMaximumQueuedSessionChanges = 256;
export declare const flexIpcMaximumQueuedSessionChangeBytes: number;
export declare const flexGenerationLeaseCleanupTimeoutMs = 30000;
export declare const flexIpcControlTimeoutMs = 35000;
export declare const flexIpcMaximumHostTimeoutMs: number;
export declare const flexIpcReversionMaintenanceTimeoutMs: number;
export declare const flexIpcLifecycleTimeoutMs: number;
export declare const flexIpcStartupTimeoutMs: number;
export declare const flexIpcDisposeTimeoutMs = 10000;
export declare const flexIpcSlashTimeoutMs: number;
export declare const flexIpcCancellationGraceTimeoutMs = 2000;
export interface IFlexProjectRecord {
    projectId: string;
    directory: string;
    directoryIdentity?: IControllerProjectFilesystemIdentity;
}
export interface IFlexIdentityBoundProjectRecord extends IFlexProjectRecord {
    directoryIdentity: IControllerProjectFilesystemIdentity;
}
export interface IFlexProjectCleanupCohortEntry extends TFlexSessionGenerationCohortEntry {
    cleanupRoot: boolean;
}
export interface IFlexDatabaseDescriptor {
    mongoDbUrl: string;
    mongoDbName: string;
}
export interface IFlexServiceInit {
    controllerId: string;
    database: IFlexDatabaseDescriptor;
    flexCredentialDirectory: string;
    projects: IFlexProjectRecord[];
}
export interface IFlexBrowserResourceDescriptor {
    resourceId: string;
    attachmentRevision: number;
}
export interface IFlexBrowserChannelBinding {
    projectId: string;
    browserResourceId: string;
    attachmentAuthorityId: string;
    attachmentRevision: number;
    actorId: string;
    peerId: string;
    role: 'agent';
    source: 'flex';
    scopeId: string;
    channelId: string;
    runId: string;
    sessionId: {
        harnessId: 'flex';
        nativeId: string;
    };
    sessionGenerationId: string;
    sessionGenerationSequence: number;
}
export type TFlexGenerationBoundBrowserChannelBinding = IFlexBrowserChannelBinding;
export interface IFlexIntelligenceSessionId {
    harnessId: 'opencode' | 'flex';
    nativeId: string;
}
export interface IFlexIntelligenceChatSummary {
    sessionId: IFlexIntelligenceSessionId;
    title: string;
    updatedAt: string;
    isActive?: boolean;
}
export interface IFlexIntelligenceChatMessage {
    role: string;
    text: string;
    timestamp?: string;
}
export interface IFlexIntelligenceChatTranscript {
    sessionId: IFlexIntelligenceSessionId;
    title: string;
    messages: IFlexIntelligenceChatMessage[];
    totalMessages?: number;
}
export interface IFlexIntelligenceResult {
    answer: string;
    scratchpad: string;
    model: string;
}
export interface IFlexTurnReversionBaseRequest {
    scopeId: string;
    storageKey: string;
    sessionId: string;
    sessionGenerationId: string;
    sessionGenerationSequence: number;
    runId: string;
    captureId: string;
}
export interface IFlexTurnReversionApplyRequest extends IFlexTurnReversionBaseRequest {
    reference: TFlexJsonValue;
    operationId: string;
    direction: 'undo' | 'redo';
}
export interface IFlexTurnReversionReleaseRequest extends IFlexTurnReversionBaseRequest {
    reference: TFlexJsonValue;
}
export interface IFlexGitWorktreeDescriptor {
    worktreeId: string;
    projectId: string;
    sessionId: string;
    path: string;
    repositoryId: string;
    createdAt: string;
}
export type TFlexIntelligenceJobStatus = 'running' | 'completed' | 'failed' | 'cancelled';
export interface IFlexDelegatedRunAdmissionContext {
    scopeId: string;
    storageKey: string;
    sessionId: string;
    sessionGenerationId: string;
    sessionGenerationSequence: number;
    queueId: string;
    runId: string;
    parentSessionId: string;
    parentSessionGenerationId: string;
    parentSessionGenerationSequence: number;
    parentQueueId: string;
    parentRunId: string;
    parentToolCallId: string;
    originParentRunId: string;
    originParentToolCallId: string;
    agent: string;
    depth: number;
}
export interface IFlexDelegatedRunAdmissionCloseRequest extends IFlexDelegatedRunAdmissionContext {
    leaseId: string;
}
export interface IFlexHostRequestMap {
    'delegated-run-admission.acquire': {
        request: IFlexDelegatedRunAdmissionContext;
        response: {
            leaseId: string;
            model: IFlexModelChoice;
        };
    };
    'delegated-run-admission.close': {
        request: IFlexDelegatedRunAdmissionCloseRequest;
        response: {
            closed: true;
        };
    };
    'reversion.prepare': {
        request: IFlexTurnReversionBaseRequest;
        response: {
            prepared: true;
        };
    };
    'reversion.inspect-capture': {
        request: IFlexTurnReversionBaseRequest;
        response: TFlexTurnReversionCaptureInspectionV2;
    };
    'reversion.finalize': {
        request: IFlexTurnReversionBaseRequest;
        response: TFlexTurnReversionFinalizedOutcome;
    };
    'reversion.inspect-apply': {
        request: IFlexTurnReversionApplyRequest;
        response: TFlexTurnReversionApplyInspection;
    };
    'reversion.apply': {
        request: IFlexTurnReversionApplyRequest;
        response: {
            applied: true;
        };
    };
    'reversion.release': {
        request: IFlexTurnReversionReleaseRequest;
        response: {
            released: true;
        };
    };
    'git.worktree.create': {
        request: {
            scopeId: string;
            sessionId: string;
            sessionGenerationId: string;
            sessionGenerationSequence: number;
        };
        response: {
            worktree: IFlexGitWorktreeDescriptor;
        };
    };
    'git.worktree.list': {
        request: {
            scopeId: string;
            sessionId: string;
            sessionGenerationId: string;
            sessionGenerationSequence: number;
        };
        response: {
            worktrees: IFlexGitWorktreeDescriptor[];
        };
    };
    'git.worktree.remove': {
        request: {
            scopeId: string;
            sessionId: string;
            sessionGenerationId: string;
            sessionGenerationSequence: number;
            worktreeId: string;
            compensate?: true;
        };
        response: {
            removed: true;
        };
    };
    'crossharness.chats.list': {
        request: {
            capabilityToken: string;
            limit: number;
        };
        response: {
            chats: IFlexIntelligenceChatSummary[];
        };
    };
    'crossharness.chat.read': {
        request: {
            capabilityToken: string;
            sessionId: IFlexIntelligenceSessionId;
            limit: number;
            maxChars: number;
        };
        response: {
            transcript: IFlexIntelligenceChatTranscript;
        };
    };
    'project-management.load': {
        request: {
            storageKey: string;
            sessionId: string;
            sessionContext: TFlexProjectManagementSessionContext;
            registrationOperationId?: string;
        };
        response: {
            record: TFlexProjectManagementRecord | null;
        };
    };
    'project-management.save': {
        request: {
            storageKey: string;
            sessionId: string;
            snapshot: TFlexProjectManagementSnapshot;
            expectedRevision: number;
            writeContext: TFlexProjectManagementWriteContext;
        };
        response: TFlexProjectManagementCommitResult;
    };
    'project-management.tombstone': {
        request: {
            storageKey: string;
            sessionId: string;
            tombstone: TFlexProjectManagementTombstone;
            expectedRevision: number;
            sessionContext: TFlexProjectManagementSessionContext;
        };
        response: TFlexProjectManagementCommitResult;
    };
    'browser.resources.resolve': {
        request: {
            scopeId: string;
            sessionId: string;
            sessionGenerationId: string;
            sessionGenerationSequence: number;
            runId: string;
        };
        response: {
            resources: IFlexBrowserResourceDescriptor[];
        };
    };
    'browser.channel.open': {
        request: {
            scopeId: string;
            sessionId: string;
            sessionGenerationId: string;
            sessionGenerationSequence: number;
            runId: string;
            resourceId: string;
            attachmentRevision: number;
            channelId: string;
        };
        response: {
            binding: TFlexGenerationBoundBrowserChannelBinding;
            capabilityToken: string;
        };
    };
    'browser.channel.close': {
        request: {
            channelId: string;
            sessionGenerationId: string;
            sessionGenerationSequence: number;
        };
        response: {
            closed: true;
        };
    };
}
export type TFlexProjectManagementCommitResult = {
    committed: true;
} | {
    committed: false;
    actualRevision: number;
};
export type TFlexHostRequestMethod = keyof IFlexHostRequestMap;
export type TFlexHostRequest<TMethod extends TFlexHostRequestMethod> = IFlexHostRequestMap[TMethod]['request'];
export type TFlexHostResponse<TMethod extends TFlexHostRequestMethod> = IFlexHostRequestMap[TMethod]['response'];
export type TFlexRetainedHostSuccessMethod = 'delegated-run-admission.acquire' | 'git.worktree.create';
export declare const isFlexRetainedHostSuccessMethod: (methodArg: TFlexHostRequestMethod) => methodArg is TFlexRetainedHostSuccessMethod;
export type TFlexServiceState = 'starting' | 'ready' | 'unsupported' | 'failed' | 'stopping' | 'stopped';
export type TFlexServiceStatusCode = 'UNSUPPORTED_RUNTIME' | 'INITIALIZATION_FAILED' | 'SERVICE_STOPPED';
export interface IFlexServiceStatus {
    state: TFlexServiceState;
    ready: boolean;
    code?: TFlexServiceStatusCode;
    startedAt?: string;
}
export type TFlexPublicConnectionState = 'pending' | 'active' | 'deleting' | 'reauthRequired';
export interface IFlexPublicAccountSummary {
    providerId: string;
    authKind: 'chatgptOAuth';
    accountId?: string;
    email?: string;
    plan?: string;
}
export interface IFlexPublicProviderConnection {
    loginId: string;
    providerId: 'openai';
    status: TFlexPublicConnectionState;
    account?: IFlexPublicAccountSummary;
}
/** Private child-to-controller projection. It is never exposed by controller RPC. */
export interface IFlexOpenCodeOAuthAuth {
    type: 'oauth';
    access: string;
    refresh: string;
    expires: number;
    accountId?: string;
}
export interface IFlexPublicProviderModel {
    providerId: 'openai';
    modelId: string;
    displayName: string;
    description: string;
    hidden: boolean;
    reasoningEfforts: Array<{
        effort: string;
        description: string;
    }>;
    defaultReasoningEffort: string;
    inputModalities: Array<'text' | 'image' | 'audio'>;
    supportsPersonality: boolean;
    serviceTiers: Array<{
        id: string;
        name: string;
        description: string;
    }>;
    defaultServiceTier?: string;
    isDefault: boolean;
}
export interface IFlexPublicProviderRateLimitWindow {
    usedPercent: number;
    limitWindowSeconds: number;
    resetAfterSeconds: number;
    resetsAt: number;
}
export interface IFlexPublicProviderRateLimitDetails {
    allowed: boolean;
    limitReached: boolean;
    primaryWindow?: IFlexPublicProviderRateLimitWindow;
    secondaryWindow?: IFlexPublicProviderRateLimitWindow;
}
export interface IFlexPublicProviderAdditionalRateLimit {
    limitName: string;
    meteredFeature: string;
    rateLimit?: IFlexPublicProviderRateLimitDetails;
}
export interface IFlexPublicProviderAccountRateLimits {
    providerId: 'openai';
    plan: string;
    observedAt: string;
    rateLimit?: IFlexPublicProviderRateLimitDetails;
    additionalRateLimits: IFlexPublicProviderAdditionalRateLimit[];
    rateLimitReachedType?: string;
    rateLimitResetCreditsAvailableCount?: number;
}
export interface IFlexModelChoice {
    providerConnectionId: string;
    modelId: string;
    variant?: string;
}
export interface IFlexJobAdmission {
    jobId: string;
}
export interface IFlexSessionListResult {
    sessions: TFlexSession[];
    total: number;
    truncated: boolean;
}
export type TFlexSlashExecutionResult = plugins.flexharness.IFlexSlashCommandNotCommandResult | plugins.flexharness.IFlexSlashCommandMalformedResult | plugins.flexharness.IFlexSlashCommandUnknownResult | plugins.flexharness.IFlexSlashCommandOperationResult | plugins.flexharness.IFlexSlashCommandHandlerResult | {
    type: 'prompt-admission';
    name: string;
    admission: {
        queueId: string;
        runId: string;
    };
};
export interface IFlexRequestMap {
    'service.status': {
        request: Record<string, never>;
        response: IFlexServiceStatus;
    };
    'project.register': {
        request: {
            project: IFlexIdentityBoundProjectRecord;
            registrationOperationId: string;
        };
        response: {
            registered: true;
            added: boolean;
        };
    };
    'project.remove': {
        request: {
            project: IFlexIdentityBoundProjectRecord;
            removalOperationId: string;
            cleanupCohort: IFlexProjectCleanupCohortEntry[];
        };
        response: {
            removed: true;
        };
    };
    'intelligence.start': {
        request: {
            scopeId: string;
            sourceSessionId: IFlexIntelligenceSessionId;
            question: string;
            scratchpad: string;
            model: IFlexModelChoice;
            capabilityToken: string;
        };
        response: {
            jobId: string;
            workerSessionId: string;
        };
    };
    'intelligence.get': {
        request: {
            scopeId: string;
            jobId: string;
            capabilityToken: string;
        };
        response: {
            status: TFlexIntelligenceJobStatus;
            workerSessionId: string;
            result?: IFlexIntelligenceResult;
            error?: string;
        };
    };
    'intelligence.cancel': {
        request: {
            scopeId: string;
            capabilityToken: string;
        };
        response: {
            cancelled: boolean;
        };
    };
    'session.list': {
        request: {
            scopeId: string;
            offset?: number;
            limit?: number;
        };
        response: IFlexSessionListResult;
    };
    'session.create': {
        request: {
            scopeId: string;
            options: TFlexCreateSessionOptions & {
                sessionId: string;
                sessionGenerationId: string;
            };
        };
        response: TFlexSession;
    };
    'session.get': {
        request: {
            scopeId: string;
            sessionId: string;
        };
        response: TFlexSession;
    };
    'session.update': {
        request: {
            scopeId: string;
            sessionId: string;
            options: TFlexUpdateSessionOptions;
        };
        response: TFlexSession;
    };
    'session.delete': {
        request: {
            scopeId: string;
            root: TFlexSessionGenerationCohortEntry;
            authorizedCohort: TFlexSessionGenerationCohortEntry[];
        };
        response: {
            matched: boolean;
        };
    };
    'session.compact': {
        request: {
            scopeId: string;
            sessionId: string;
            model?: IFlexModelChoice;
        };
        response: {
            compacted: true;
        };
    };
    'session.reversion.info': {
        request: {
            scopeId: string;
            sessionId: string;
        };
        response: TFlexSessionReversionInfo;
    };
    'slash.list': {
        request: {
            scopeId: string;
            sessionId: string;
        };
        response: {
            commands: TFlexSlashCommandDescriptor[];
        };
    };
    'slash.execute': {
        request: {
            scopeId: string;
            sessionId: string;
            input: string;
            model?: IFlexModelChoice;
        };
        response: TFlexSlashExecutionResult;
    };
    'message.page': {
        request: {
            scopeId: string;
            sessionId: string;
            limit?: number;
            before?: string;
        };
        response: TFlexMessagePage;
    };
    'message.get': {
        request: {
            scopeId: string;
            sessionId: string;
            messageId: string;
        };
        response: TFlexMessage;
    };
    'prompt.start': {
        request: {
            scopeId: string;
            sessionId: string;
            prompt: TFlexPrompt;
            options?: TFlexPromptOptions;
            model?: IFlexModelChoice;
            upload?: {
                operationId: string;
                directory: string;
            };
        };
        response: {
            queueId: string;
            runId: string;
        };
    };
    'prompt.acknowledge': {
        request: {
            scopeId: string;
            sessionId: string;
            queueId: string;
            runId: string;
        };
        response: {
            acknowledged: true;
        };
    };
    'prompt.get': {
        request: {
            scopeId: string;
            sessionId: string;
            queueId: string;
        };
        response: {
            entry: TFlexPromptQueueEntry;
        };
    };
    'prompt.list': {
        request: {
            scopeId: string;
            sessionId: string;
        };
        response: {
            entries: TFlexPromptQueueEntry[];
        };
    };
    'prompt.cancel': {
        request: {
            scopeId: string;
            sessionId: string;
            queueId: string;
        };
        response: {
            accepted: boolean;
        };
    };
    'permission.list': {
        request: {
            scopeId: string;
            sessionId?: string;
        };
        response: {
            permissions: TFlexPermissionRequest[];
        };
    };
    'permission.respond': {
        request: {
            scopeId: string;
            sessionId: string;
            sessionGenerationId: string;
            sessionGenerationSequence: number;
            permissionId: string;
            decision: TFlexPermissionDecision;
        };
        response: {
            accepted: true;
        };
    };
    'provider.list': {
        request: Record<string, never>;
        response: {
            providers: Array<{
                providerId: 'openai';
                displayName: string;
                loginFlow: 'device';
            }>;
        };
    };
    'provider.login.begin': {
        request: {
            providerId: 'openai';
        };
        response: {
            loginId: string;
            verificationUrl: string;
            userCode: string;
            status: 'pending';
        };
    };
    'provider.login.status': {
        request: {
            loginId: string;
        };
        response: IFlexPublicProviderConnection;
    };
    'provider.login.cancel': {
        request: {
            loginId: string;
        };
        response: {
            canceled: boolean;
        };
    };
    'provider.connection.list': {
        request: Record<string, never>;
        response: {
            connections: IFlexPublicProviderConnection[];
        };
    };
    'provider.connection.opencode-auth.get': {
        request: {
            providerConnectionId: string;
        };
        response: {
            auth: IFlexOpenCodeOAuthAuth;
        };
    };
    'provider.connection.logout.prepare': {
        request: {
            providerConnectionId: string;
        };
        response: {
            accepted: true;
        };
    };
    'provider.connection.logout': {
        request: {
            providerConnectionId: string;
        };
        response: {
            accepted: true;
        };
    };
    'provider.connection.ratelimits.get': {
        request: {
            providerConnectionId: string;
        };
        response: {
            rateLimits: IFlexPublicProviderAccountRateLimits;
        };
    };
    'provider.models.refresh': {
        request: {
            providerConnectionId: string;
        };
        response: IFlexJobAdmission;
    };
    'model.choice.get': {
        request: {
            scopeId: string;
        };
        response: {
            choice: IFlexModelChoice | null;
        };
    };
    'model.choice.set': {
        request: {
            scopeId: string;
            choice: IFlexModelChoice;
        };
        response: {
            choice: IFlexModelChoice;
        };
    };
    'model.choice.validate': {
        request: {
            choice: IFlexModelChoice;
        };
        response: {
            valid: true;
        };
    };
}
export type TFlexRequestMethod = keyof IFlexRequestMap;
export type TFlexRequest<TMethod extends TFlexRequestMethod> = IFlexRequestMap[TMethod]['request'];
export type TFlexResponse<TMethod extends TFlexRequestMethod> = IFlexRequestMap[TMethod]['response'];
export interface IFlexIpcInitMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'init';
    init: IFlexServiceInit;
}
export interface IFlexIpcRequestMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'request';
    requestId: string;
    method: TFlexRequestMethod;
    payload: unknown;
}
export interface IFlexIpcRequestCancelMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'request.cancel';
    requestId: string;
}
export interface IFlexIpcDisposeMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'dispose';
    requestId: string;
}
export type TFlexIpcHostResponseMessage = {
    version: typeof flexIpcProtocolVersion;
    type: 'host.response';
    requestId: string;
} & ({
    ok: true;
    result: unknown;
} | {
    ok: false;
    error: IFlexServiceError;
});
export interface IFlexIpcParentBrowserFrameMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'browser.channel.frame';
    channelId: string;
    dataBase64: string;
}
export interface IFlexIpcBrowserChannelClosedMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'browser.channel.closed';
    channelId: string;
    sessionGenerationId: string;
    sessionGenerationSequence: number;
}
export type TFlexParentMessage = IFlexIpcInitMessage | IFlexIpcRequestMessage | IFlexIpcRequestCancelMessage | IFlexIpcDisposeMessage | TFlexIpcHostResponseMessage | IFlexIpcParentBrowserFrameMessage | IFlexIpcBrowserChannelClosedMessage;
export type TFlexServiceErrorCode = 'INVALID_REQUEST' | 'NOT_READY' | 'NOT_FOUND' | 'CONFLICT' | 'BUSY' | 'TIMEOUT' | 'ABORTED' | 'OUTCOME_UNKNOWN' | 'SLASH_UNAVAILABLE' | 'LIMIT_EXCEEDED' | 'STALE_RUN' | 'PROVIDER_LOGIN_FAILED' | 'PROVIDER_REAUTH_REQUIRED' | 'MODEL_CATALOG_REQUIRED' | 'UNSUPPORTED_RUNTIME' | 'INTERNAL';
export declare const flexServiceErrorMessages: Readonly<Record<TFlexServiceErrorCode, string>>;
export interface IFlexServiceError {
    name: 'FlexServiceError';
    code: TFlexServiceErrorCode;
    message: string;
}
export interface IFlexIpcStatusMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'status';
    status: IFlexServiceStatus;
}
export type TFlexIpcResponseMessage = {
    version: typeof flexIpcProtocolVersion;
    type: 'response';
    requestId: string;
} & ({
    ok: true;
    result: unknown;
} | {
    ok: false;
    error: IFlexServiceError;
});
export type TFlexJobKind = 'provider.models';
type TFlexChildSessionEvent = TFlexSessionGeneration & {
    scopeId: string;
    sessionId: string;
};
export type TFlexChildEvent = (TFlexChildSessionEvent & {
    type: 'session.history.changed';
    direction: 'undo' | 'redo' | 'branch';
    runId?: string;
}) | {
    type: 'sessions.changed';
    coalesced: true;
} | (TFlexChildSessionEvent & {
    type: 'sessions.changed';
    coalesced: boolean;
}) | (TFlexChildSessionEvent & {
    type: 'permissions.changed';
}) | (TFlexChildSessionEvent & {
    type: 'tool.updated';
    runId: string;
    messageId: string;
    messageIndex: number;
    partIndex: number;
    sequence: number;
    timestamp: string;
    part: TFlexToolMessagePart;
}) | (TFlexChildSessionEvent & {
    type: 'reasoning.updated';
    runId: string;
    messageId: string;
    messageIndex: number;
    partIndex: number;
    sequence: number;
    timestamp: string;
    part: TFlexReasoningMessagePart;
}) | (TFlexChildSessionEvent & {
    type: 'text.updated';
    runId: string;
    messageId: string;
    messageIndex: number;
    partIndex: number;
    sequence: number;
    timestamp: string;
    status: 'running' | 'completed';
    part: TFlexTextMessagePart;
}) | (TFlexChildSessionEvent & {
    type: 'part.delta';
    runId: string;
    messageId: string;
    messageIndex: number;
    partId: string;
    partIndex: number;
    sequence: number;
    timestamp: string;
    partType: 'text' | 'reasoning';
    delta: string;
    baseTextUtf8Bytes: number;
    textUtf8Bytes: number;
}) | (TFlexChildSessionEvent & {
    type: 'prompt.queued';
    queueId: string;
    runId?: never;
    entry: TFlexPromptQueueEntry;
}) | (TFlexChildSessionEvent & {
    type: 'prompt.started' | 'prompt.running' | 'prompt.finished';
    queueId: string;
    runId: string;
    entry: TFlexPromptQueueEntry;
}) | (TFlexChildSessionEvent & {
    type: 'prompt.message-bound';
    queueId: string;
    runId: string;
    messageId: string;
}) | {
    type: 'job.finished';
    jobId: string;
    kind: TFlexJobKind;
    status: 'completed' | 'failed' | 'cancelled';
    models?: IFlexPublicProviderModel[];
} | {
    type: 'provider.connection.changed';
    connection: IFlexPublicProviderConnection;
};
export interface IFlexIpcEventMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'event';
    event: TFlexChildEvent;
}
export interface IFlexIpcHostRequestMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'host.request';
    requestId: string;
    method: TFlexHostRequestMethod;
    payload: unknown;
    timeoutMs: number;
}
export interface IFlexIpcHostCancelMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'host.cancel';
    requestId: string;
}
export interface IFlexIpcHostResponseAcknowledgementMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'host.response.acknowledge';
    requestId: string;
}
export interface IFlexIpcChildBrowserFrameMessage {
    version: typeof flexIpcProtocolVersion;
    type: 'browser.channel.frame';
    channelId: string;
    dataBase64: string;
}
export type TFlexChildMessage = IFlexIpcStatusMessage | TFlexIpcResponseMessage | IFlexIpcEventMessage | IFlexIpcHostRequestMessage | IFlexIpcHostCancelMessage | IFlexIpcHostResponseAcknowledgementMessage | IFlexIpcChildBrowserFrameMessage;
export declare const isFlexDelegatedRunAdmissionLeaseId: (valueArg: unknown) => valueArg is string;
export declare const isFlexPlainObject: (valueArg: unknown) => valueArg is Record<string, unknown>;
export declare const hasFlexExactKeys: (valueArg: Record<string, unknown>, requiredKeysArg: readonly string[], optionalKeysArg?: readonly string[]) => boolean;
export declare const isFlexProjectRecord: (valueArg: unknown) => valueArg is IFlexProjectRecord;
export declare const isFlexIdentityBoundProjectRecord: (valueArg: unknown) => valueArg is IFlexIdentityBoundProjectRecord;
export declare const isFlexDatabaseDescriptor: (valueArg: unknown) => valueArg is IFlexDatabaseDescriptor;
export declare const isFlexServiceInit: (valueArg: unknown) => valueArg is IFlexServiceInit;
export declare const isFlexServiceStatus: (valueArg: unknown) => valueArg is IFlexServiceStatus;
export declare const isFlexPublicProviderConnection: (valueArg: unknown) => valueArg is IFlexPublicProviderConnection;
export declare const isFlexPublicMessage: (valueArg: unknown) => valueArg is TFlexMessage;
export declare const isFlexPublicSession: (valueArg: unknown) => valueArg is TFlexSession;
export declare const flexDelegatedRunAdmissionContextKeys: readonly ["scopeId", "storageKey", "sessionId", "sessionGenerationId", "sessionGenerationSequence", "queueId", "runId", "parentSessionId", "parentSessionGenerationId", "parentSessionGenerationSequence", "parentQueueId", "parentRunId", "parentToolCallId", "originParentRunId", "originParentToolCallId", "agent", "depth"];
export declare const isFlexRequestPayload: <TMethod extends TFlexRequestMethod>(methodArg: TMethod, valueArg: unknown) => valueArg is TFlexRequest<TMethod>;
export declare const isFlexHostRequestPayload: <TMethod extends TFlexHostRequestMethod>(methodArg: TMethod, valueArg: unknown) => valueArg is TFlexHostRequest<TMethod>;
export declare const isFlexHostResponseResult: <TMethod extends TFlexHostRequestMethod>(methodArg: TMethod, valueArg: unknown) => valueArg is TFlexHostResponse<TMethod>;
export declare const isFlexResponseResult: <TMethod extends TFlexRequestMethod>(methodArg: TMethod, valueArg: unknown) => valueArg is TFlexResponse<TMethod>;
export declare const isFlexServiceError: (valueArg: unknown) => valueArg is IFlexServiceError;
export declare const parseFlexParentMessage: (valueArg: unknown) => TFlexParentMessage;
export declare const parseFlexChildMessage: (valueArg: unknown) => TFlexChildMessage;
export declare const createFlexServiceError: (codeArg: TFlexServiceErrorCode) => IFlexServiceError;
export declare class FlexServiceError extends Error {
    readonly code: TFlexServiceErrorCode;
    readonly name = "FlexServiceError";
    constructor(code: TFlexServiceErrorCode);
}
export {};