import type { OperatorMethodInput, OperatorMethodOutput, OperatorTypedMethodId } from '@pellux/goodvibes-contracts/generated/foundation-client-types';
import type { OmitNamed } from '@pellux/goodvibes-contracts';
import { forScopedBrowserSession, type BrowserScopedRouteDefinition, type ScopedBrowserSdk, type ScopedEventStreamOptions, type ScopedBrowserSdkOptions, type SharedBrowserMethodId } from './browser-scoped.js';
import type { ServerSentEventHandlers } from './transport-http.js';
/**
 * The input type of `TMethodId` minus the key this wrapper supplies from its own
 * positional argument (the id already in the URL path).
 *
 * `OmitNamed` rather than a plain `Omit`, see @pellux/goodvibes-contracts'
 * typed-io-keys.ts: an `additionalProperties: true` verb renders with a broad
 * index signature, and `Omit` collapses the whole named shape against it.
 */
type OperatorInputWithout<TMethodId extends OperatorTypedMethodId, TKey extends string> = OmitNamed<OperatorMethodInput<TMethodId>, TKey>;
export declare const KNOWLEDGE_BROWSER_ROUTES: {
    readonly 'knowledge.ask': {
        readonly method: "POST";
        readonly path: "/api/knowledge/ask";
    };
    readonly 'knowledge.candidate.decide': {
        readonly method: "POST";
        readonly path: "/api/knowledge/candidates/{id}/decide";
    };
    readonly 'knowledge.candidate.get': {
        readonly method: "GET";
        readonly path: "/api/knowledge/candidates/{id}";
    };
    readonly 'knowledge.candidates.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/candidates";
    };
    readonly 'knowledge.connector.doctor': {
        readonly method: "GET";
        readonly path: "/api/knowledge/connectors/{id}/doctor";
    };
    readonly 'knowledge.connector.get': {
        readonly method: "GET";
        readonly path: "/api/knowledge/connectors/{id}";
    };
    readonly 'knowledge.connectors.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/connectors";
    };
    readonly 'knowledge.extraction.get': {
        readonly method: "GET";
        readonly path: "/api/knowledge/extractions/{id}";
    };
    readonly 'knowledge.extractions.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/extractions";
    };
    readonly 'knowledge.graphql.execute': {
        readonly method: "POST";
        readonly path: "/api/knowledge/graphql";
    };
    readonly 'knowledge.graphql.schema': {
        readonly method: "GET";
        readonly path: "/api/knowledge/graphql/schema";
    };
    readonly 'knowledge.ingest.artifact': {
        readonly method: "POST";
        readonly path: "/api/knowledge/ingest/artifact";
    };
    readonly 'knowledge.ingest.bookmarks': {
        readonly method: "POST";
        readonly path: "/api/knowledge/ingest/bookmarks";
    };
    readonly 'knowledge.ingest.browserHistory': {
        readonly method: "POST";
        readonly path: "/api/knowledge/ingest/browser-history";
    };
    readonly 'knowledge.ingest.connector': {
        readonly method: "POST";
        readonly path: "/api/knowledge/ingest/connector";
    };
    readonly 'knowledge.ingest.url': {
        readonly method: "POST";
        readonly path: "/api/knowledge/ingest/url";
    };
    readonly 'knowledge.ingest.urls': {
        readonly method: "POST";
        readonly path: "/api/knowledge/ingest/urls";
    };
    readonly 'knowledge.issue.review': {
        readonly method: "POST";
        readonly path: "/api/knowledge/issues/{id}/review";
    };
    readonly 'knowledge.issues.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/issues";
    };
    readonly 'knowledge.item.get': {
        readonly method: "GET";
        readonly path: "/api/knowledge/items/{id}";
    };
    readonly 'knowledge.job-runs.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/job-runs";
    };
    readonly 'knowledge.job.get': {
        readonly method: "GET";
        readonly path: "/api/knowledge/jobs/{jobId}";
    };
    readonly 'knowledge.job.run': {
        readonly method: "POST";
        readonly path: "/api/knowledge/jobs/{jobId}/run";
    };
    readonly 'knowledge.jobs.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/jobs";
    };
    readonly 'knowledge.lint': {
        readonly method: "POST";
        readonly path: "/api/knowledge/lint";
    };
    readonly 'knowledge.map': {
        readonly method: "GET";
        readonly path: "/api/knowledge/map";
    };
    readonly 'knowledge.nodes.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/nodes";
    };
    readonly 'knowledge.packet': {
        readonly method: "POST";
        readonly path: "/api/knowledge/packet";
    };
    readonly 'knowledge.projection.materialize': {
        readonly method: "POST";
        readonly path: "/api/knowledge/projections/materialize";
    };
    readonly 'knowledge.projection.render': {
        readonly method: "POST";
        readonly path: "/api/knowledge/projections/render";
    };
    readonly 'knowledge.projections.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/projections";
    };
    readonly 'knowledge.refinement.run': {
        readonly method: "POST";
        readonly path: "/api/knowledge/refinement/run";
    };
    readonly 'knowledge.refinement.task.cancel': {
        readonly method: "POST";
        readonly path: "/api/knowledge/refinement/tasks/{id}/cancel";
    };
    readonly 'knowledge.refinement.task.get': {
        readonly method: "GET";
        readonly path: "/api/knowledge/refinement/tasks/{id}";
    };
    readonly 'knowledge.refinement.tasks.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/refinement/tasks";
    };
    readonly 'knowledge.reindex': {
        readonly method: "POST";
        readonly path: "/api/knowledge/reindex";
    };
    readonly 'knowledge.report.get': {
        readonly method: "GET";
        readonly path: "/api/knowledge/reports/{id}";
    };
    readonly 'knowledge.reports.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/reports";
    };
    readonly 'knowledge.schedule.delete': {
        readonly method: "DELETE";
        readonly path: "/api/knowledge/schedules/{id}";
    };
    readonly 'knowledge.schedule.enable': {
        readonly method: "POST";
        readonly path: "/api/knowledge/schedules/{id}/enabled";
    };
    readonly 'knowledge.schedule.get': {
        readonly method: "GET";
        readonly path: "/api/knowledge/schedules/{id}";
    };
    readonly 'knowledge.schedule.save': {
        readonly method: "POST";
        readonly path: "/api/knowledge/schedules";
    };
    readonly 'knowledge.schedules.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/schedules";
    };
    readonly 'knowledge.search': {
        readonly method: "POST";
        readonly path: "/api/knowledge/search";
    };
    readonly 'knowledge.source.extraction.get': {
        readonly method: "GET";
        readonly path: "/api/knowledge/sources/{id}/extraction";
    };
    readonly 'knowledge.sources.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/sources";
    };
    readonly 'knowledge.status': {
        readonly method: "GET";
        readonly path: "/api/knowledge/status";
    };
    readonly 'knowledge.usage.list': {
        readonly method: "GET";
        readonly path: "/api/knowledge/usage";
    };
    readonly 'projectPlanning.workPlan.clearCompleted': {
        readonly method: "POST";
        readonly path: "/api/projects/planning/work-plan/clear-completed";
    };
    readonly 'projectPlanning.workPlan.snapshot': {
        readonly method: "GET";
        readonly path: "/api/projects/planning/work-plan";
    };
    readonly 'projectPlanning.workPlan.task.create': {
        readonly method: "POST";
        readonly path: "/api/projects/planning/work-plan/tasks";
    };
    readonly 'projectPlanning.workPlan.task.delete': {
        readonly method: "DELETE";
        readonly path: "/api/projects/planning/work-plan/tasks/{taskId}";
    };
    readonly 'projectPlanning.workPlan.task.get': {
        readonly method: "GET";
        readonly path: "/api/projects/planning/work-plan/tasks/{taskId}";
    };
    readonly 'projectPlanning.workPlan.task.status': {
        readonly method: "POST";
        readonly path: "/api/projects/planning/work-plan/tasks/{taskId}/status";
    };
    readonly 'projectPlanning.workPlan.task.update': {
        readonly method: "PATCH";
        readonly path: "/api/projects/planning/work-plan/tasks/{taskId}";
    };
    readonly 'projectPlanning.workPlan.tasks.list': {
        readonly method: "GET";
        readonly path: "/api/projects/planning/work-plan/tasks";
    };
    readonly 'projectPlanning.workPlan.tasks.reorder': {
        readonly method: "POST";
        readonly path: "/api/projects/planning/work-plan/tasks/reorder";
    };
    readonly 'artifacts.create': {
        readonly method: "POST";
        readonly path: "/api/artifacts";
    };
    readonly 'artifacts.get': {
        readonly method: "GET";
        readonly path: "/api/artifacts/{artifactId}";
    };
    readonly 'artifacts.list': {
        readonly method: "GET";
        readonly path: "/api/artifacts";
    };
    readonly 'companion.chat.messages.create': {
        readonly method: "POST";
        readonly path: "/api/companion/chat/sessions/{sessionId}/messages";
    };
    readonly 'companion.chat.messages.list': {
        readonly method: "GET";
        readonly path: "/api/companion/chat/sessions/{sessionId}/messages";
    };
    readonly 'companion.chat.sessions.create': {
        readonly method: "POST";
        readonly path: "/api/companion/chat/sessions";
    };
    readonly 'companion.chat.sessions.get': {
        readonly method: "GET";
        readonly path: "/api/companion/chat/sessions/{sessionId}";
    };
    readonly 'companion.chat.sessions.list': {
        readonly method: "GET";
        readonly path: "/api/companion/chat/sessions";
    };
    readonly 'companion.chat.sessions.update': {
        readonly method: "PATCH";
        readonly path: "/api/companion/chat/sessions/{sessionId}";
    };
    readonly 'companion.chat.messages.steer': {
        readonly method: "POST";
        readonly path: "/api/companion/chat/sessions/{sessionId}/messages/steer";
    };
    readonly 'companion.chat.turns.cancel': {
        readonly method: "POST";
        readonly path: "/api/companion/chat/sessions/{sessionId}/turns/cancel";
    };
};
export declare const KNOWLEDGE_BROWSER_DOMAINS: readonly ["session", "turn", "tasks", "providers", "knowledge", "control-plane"];
export type BrowserKnowledgeMethodId = SharedBrowserMethodId | Extract<keyof typeof KNOWLEDGE_BROWSER_ROUTES, OperatorTypedMethodId>;
export type BrowserKnowledgeDomain = typeof KNOWLEDGE_BROWSER_DOMAINS[number];
export interface BrowserKnowledgeSdk extends ScopedBrowserSdk<BrowserKnowledgeMethodId, BrowserKnowledgeDomain> {
    readonly knowledge: {
        ask(input: OperatorMethodInput<'knowledge.ask'>): Promise<OperatorMethodOutput<'knowledge.ask'>>;
        search(input: OperatorMethodInput<'knowledge.search'>): Promise<OperatorMethodOutput<'knowledge.search'>>;
        status(input?: OperatorMethodInput<'knowledge.status'>): Promise<OperatorMethodOutput<'knowledge.status'>>;
        map(input?: OperatorMethodInput<'knowledge.map'>): Promise<OperatorMethodOutput<'knowledge.map'>>;
    };
    readonly chat: {
        readonly sessions: {
            create(input?: OperatorMethodInput<'companion.chat.sessions.create'>): Promise<OperatorMethodOutput<'companion.chat.sessions.create'>>;
            get(sessionId: string): Promise<OperatorMethodOutput<'companion.chat.sessions.get'>>;
            list(input?: OperatorMethodInput<'companion.chat.sessions.list'>): Promise<OperatorMethodOutput<'companion.chat.sessions.list'>>;
            update(sessionId: string, input: OperatorInputWithout<'companion.chat.sessions.update', 'sessionId'>): Promise<OperatorMethodOutput<'companion.chat.sessions.update'>>;
        };
        readonly messages: {
            create(sessionId: string, input: OperatorInputWithout<'companion.chat.messages.create', 'sessionId'>): Promise<OperatorMethodOutput<'companion.chat.messages.create'>>;
            list(sessionId: string): Promise<OperatorMethodOutput<'companion.chat.messages.list'>>;
            /**
             * Interrupt-and-send: cancels the in-flight turn (honest partial +
             * terminal turn.cancelled to every subscriber) and runs this message
             * immediately. Feature-detect with isMethodUnavailableError and fall
             * back to an ordinary create on older daemons.
             */
            steer(sessionId: string, input: OperatorInputWithout<'companion.chat.messages.steer', 'sessionId'>): Promise<OperatorMethodOutput<'companion.chat.messages.steer'>>;
        };
        readonly turns: {
            /**
             * Server-side stop for the in-flight turn. The terminal `turn.cancelled`
             * event on the session stream is the authoritative convergence signal;
             * treat 404 NO_ACTIVE_TURN as benign (the turn finished first).
             */
            cancel(sessionId: string, input?: OperatorInputWithout<'companion.chat.turns.cancel', 'sessionId'>): Promise<OperatorMethodOutput<'companion.chat.turns.cancel'>>;
        };
        readonly events: {
            stream(sessionId: string, handlers: ServerSentEventHandlers, options?: ScopedEventStreamOptions): Promise<() => void>;
        };
    };
    readonly artifacts: {
        create(input: OperatorMethodInput<'artifacts.create'>): Promise<OperatorMethodOutput<'artifacts.create'>>;
        get(artifactId: string): Promise<OperatorMethodOutput<'artifacts.get'>>;
        list(): Promise<OperatorMethodOutput<'artifacts.list'>>;
    };
    readonly workPlan: {
        snapshot(input?: OperatorMethodInput<'projectPlanning.workPlan.snapshot'>): Promise<OperatorMethodOutput<'projectPlanning.workPlan.snapshot'>>;
        readonly tasks: {
            list(input?: OperatorMethodInput<'projectPlanning.workPlan.tasks.list'>): Promise<OperatorMethodOutput<'projectPlanning.workPlan.tasks.list'>>;
            get(taskId: string, input?: OperatorInputWithout<'projectPlanning.workPlan.task.get', 'taskId'>): Promise<OperatorMethodOutput<'projectPlanning.workPlan.task.get'>>;
            create(input: OperatorMethodInput<'projectPlanning.workPlan.task.create'>): Promise<OperatorMethodOutput<'projectPlanning.workPlan.task.create'>>;
            update(taskId: string, input: OperatorInputWithout<'projectPlanning.workPlan.task.update', 'taskId'>): Promise<OperatorMethodOutput<'projectPlanning.workPlan.task.update'>>;
            status(taskId: string, input: OperatorInputWithout<'projectPlanning.workPlan.task.status', 'taskId'>): Promise<OperatorMethodOutput<'projectPlanning.workPlan.task.status'>>;
            reorder(input: OperatorMethodInput<'projectPlanning.workPlan.tasks.reorder'>): Promise<OperatorMethodOutput<'projectPlanning.workPlan.tasks.reorder'>>;
            delete(taskId: string, input?: OperatorInputWithout<'projectPlanning.workPlan.task.delete', 'taskId'>): Promise<OperatorMethodOutput<'projectPlanning.workPlan.task.delete'>>;
            clearCompleted(input?: OperatorMethodInput<'projectPlanning.workPlan.clearCompleted'>): Promise<OperatorMethodOutput<'projectPlanning.workPlan.clearCompleted'>>;
        };
    };
}
export declare function createBrowserKnowledgeSdk(options?: ScopedBrowserSdkOptions): BrowserKnowledgeSdk;
export declare function createBrowserKnowledgeSdkFromRoutes(knowledgeRoutes: Partial<Record<BrowserKnowledgeMethodId, BrowserScopedRouteDefinition>>, options?: ScopedBrowserSdkOptions): BrowserKnowledgeSdk;
export { forScopedBrowserSession as forSession };
//# sourceMappingURL=browser-knowledge.d.ts.map