type Json = string | number | boolean | null | {
    [key: string]: Json | undefined;
} | Json[];
interface PromptBlockRow {
    block_type: string;
    bound_tool: string | null;
    category_id: string | null;
    content: string;
    created_at: string;
    created_by: string | null;
    deleted_at: string | null;
    description: string | null;
    icon_name: string | null;
    id: string;
    label: string;
    metadata: Json;
    name: string;
    organization_id: string;
    published_to_web: boolean;
    published_to_web_at: string | null;
    published_to_web_by: string | null;
    shown_to: string | null;
    skill_id: string | null;
    sort_order: number;
    source_kind: string;
    source_ref: string | null;
    test_expires_at: string | null;
    test_run_id: string | null;
    updated_at: string;
    updated_by: string | null;
    version: number;
    visibility: string;
}
interface PromptBlockVariantRow {
    condition: Json;
    content: string;
    created_at: string;
    created_by: string | null;
    deleted_at: string | null;
    id: string;
    label: string;
    metadata: Json;
    organization_id: string;
    prompt_block_id: string;
    sort_order: number;
    updated_at: string;
    updated_by: string | null;
    version: number;
}
/** One entry of the server preview's `prompt_blocks` report (Model view and chip panel). */
interface PromptBlockReportEntry {
    name: string;
    level: string;
    block_id?: string | null;
    variant_id?: string | null;
    source_kind?: string | null;
    bound_tool?: string | null;
    chars?: number | null;
}

type BlockLane = "mine" | "organization" | "system";
declare const BLOCK_LANES: readonly BlockLane[];
declare const BLOCK_LANE_LABEL: Record<BlockLane, string>;
/** The URL param the library's lane lives in (`/agents/prompt-blocks?lane=system`). */
declare const BLOCK_LANE_PARAM = "lane";
declare const DEFAULT_BLOCK_LANE: BlockLane;
/** A lane the address names, when it is one of ours; otherwise the default lane. */
declare function blockLaneFromParam(value: string | null): BlockLane;
/** The Matrx System organization: system blocks live here. */
declare const SYSTEM_ORG_ID = "39c38960-d30c-4840-b0c1-c9960de95582";
declare function laneOf(row: Pick<PromptBlockRow, "organization_id" | "visibility" | "created_by">, meId: string | null): BlockLane;
declare function partitionByLane<T extends Pick<PromptBlockRow, "organization_id" | "visibility" | "created_by">>(rows: readonly T[], meId: string | null): Record<BlockLane, T[]>;
declare function matchesQuery(row: Pick<PromptBlockRow, "name" | "label" | "description">, query: string): boolean;
/** A bound-tool block is "may be stale" when the tool changed after the block's last edit. */
declare function mayBeStale(blockUpdatedAt: string, toolUpdatedAt: string | null | undefined): boolean;

/** The variant condition grammar (v1): provider, model/alias, latest, reasoning. First match wins. */
declare const REASONING_LEVELS: readonly ["none", "minimal", "low", "medium", "high", "max", "auto", "unset"];
interface BlockCondition {
    provider?: string[];
    model?: string[];
    latest?: boolean;
    reasoning?: string[];
}
declare function parseCondition(value: unknown): BlockCondition;
/** `{}` never matches: a variant must say when it applies. */
declare function isEmptyCondition(c: BlockCondition): boolean;
declare function describeCondition(c: BlockCondition): string;
/** The jsonb to store: only keys that carry something. */
declare function conditionToJson(c: BlockCondition): Record<string, unknown>;

/**
 * Prompt block tokens — pure text helpers. `{{<name>}}` is a prompt block the agent declares; the
 * server replaces it on the first turn with `<name>\n…\n</name>`. `{{!<name>}}` is the author's
 * escaped example and stays plain text. Variables (`{{name}}`) are never touched here.
 */
declare const BLOCK_NAME_PATTERN = "[a-z][a-z0-9_-]{0,63}";
declare const BLOCK_NAME_RE: RegExp;
interface BlockTextSegment {
    kind: "text" | "block";
    text: string;
    /** Set when `kind` is "block". */
    name?: string;
}
declare function isValidBlockName(name: string): boolean;
declare function blockToken(name: string): string;
/** Lower-cases a label into a valid block name ("Research rules!" -> "research_rules"). */
declare function toBlockName(label: string): string;
/** Every distinct block name used in `text`, in order of first appearance. */
declare function blockNamesInText(text: string): string[];
/** Cuts `text` into plain runs and block tokens; every byte is kept. */
declare function splitBlockText(text: string): BlockTextSegment[];
type BlockChipState = "ok" | "undeclared" | "missing";
/**
 * How a token in the prompt reads: declared and found -> ok; declared but nothing resolves ->
 * missing (the run would be refused); used but not declared -> undeclared (left as written).
 */
declare function blockChipState(name: string, declared: ReadonlySet<string>, missing: ReadonlySet<string>): BlockChipState;
interface TypedTrigger {
    /** Index of the `{{<`. */
    start: number;
    /** What was typed after it. */
    query: string;
}
/** `{{<res` right before the caret: the picker's trigger. Null when the caret is elsewhere. */
declare function typedTriggerAt(text: string, caret: number): TypedTrigger | null;
/** The new text and caret after the picker chose `name` for a typed trigger (or at the caret). */
declare function applyBlockInsert(text: string, from: number, to: number, name: string, trigger: TypedTrigger | null): {
    text: string;
    caret: number;
};
interface DeclaredBlock {
    name: string;
}
/** Normalizes the stored `prompt_blocks` jsonb into names (unknown shapes are dropped, not guessed). */
declare function declaredNames(value: unknown): string[];
declare function withDeclared(value: unknown, name: string): DeclaredBlock[];
declare function withoutDeclared(value: unknown, name: string): DeclaredBlock[];

/** The database's refusal, as supabase-js reports it. */
interface PromptBlocksDbError {
    message: string;
}
type Answer = {
    data: unknown;
    error: PromptBlocksDbError | null;
};
/** A filter chain: every call returns the chain, awaiting it answers. supabase-js fits it. */
interface PromptBlocksFilter extends PromiseLike<Answer> {
    eq(column: string, value: unknown): PromptBlocksFilter;
    neq(column: string, value: unknown): PromptBlocksFilter;
    is(column: string, value: null): PromptBlocksFilter;
    contains(column: string, value: unknown): PromptBlocksFilter;
    order(column: string, options?: {
        ascending?: boolean;
    }): PromptBlocksFilter;
    limit(count: number): PromptBlocksFilter;
    select(columns?: string): PromptBlocksFilter;
    single(): PromiseLike<Answer>;
    maybeSingle(): PromiseLike<Answer>;
}
/** The calls the door makes. Hosts pass their supabase-js client (cast once at the seam). */
interface PromptBlocksClient {
    schema(name: string): {
        from(table: string): {
            select(columns?: string): PromptBlocksFilter;
            insert(values: unknown): PromptBlocksFilter;
            update(values: unknown): PromptBlocksFilter;
        };
    };
}
interface NewBlock {
    name: string;
    label: string;
    content: string;
    description?: string | null;
    source_kind?: "authored" | "skill";
    source_ref?: string | null;
    bound_tool?: string | null;
    metadata?: Json;
    organization_id: string;
    visibility: string;
    /** A test run's stamp (test data is archived by the run that made it). */
    test_run_id?: string | null;
}
type BlockPatch = Partial<Pick<PromptBlockRow, "label" | "description" | "content" | "source_kind" | "source_ref" | "bound_tool" | "visibility" | "metadata">>;
interface UsingAgent {
    id: string;
    name: string;
}
interface SkillOption {
    skill_id: string;
    label: string;
}
/**
 * Bind the door to a host client. `Row`/`VariantRow` let a host with generated database types read
 * its own row types back (they must fit PromptBlockRow / PromptBlockVariantRow).
 */
declare function createPromptBlockDoor<Row = PromptBlockRow, VariantRow = PromptBlockVariantRow>(db: () => PromptBlocksClient): {
    listBlocks(limit?: number): Promise<Row[]>;
    listBlocksNamed(name: string): Promise<Row[]>;
    getBlock(id: string): Promise<Row | null>;
    createBlock(input: NewBlock): Promise<Row>;
    updateBlock(id: string, patch: BlockPatch): Promise<Row>;
    /** Soft delete: archived blocks stop resolving, history stays. */
    archiveBlock(id: string): Promise<void>;
    listVariants(blockId: string): Promise<VariantRow[]>;
    createVariant(block: Pick<PromptBlockRow, "id" | "organization_id">, input: {
        label: string;
        condition: Record<string, unknown>;
        content: string;
        sort_order: number;
    }): Promise<VariantRow>;
    updateVariant(id: string, patch: Partial<Pick<PromptBlockVariantRow, "label" | "content" | "sort_order">> & {
        condition?: Record<string, unknown>;
    }): Promise<void>;
    archiveVariant(id: string): Promise<void>;
    /** Agents declaring `name` (an edit to the block goes live in all of them). */
    agentsUsing(name: string): Promise<UsingAgent[]>;
    toolUpdatedAt(toolName: string): Promise<string | null>;
    listSkills(): Promise<SkillOption[]>;
    listToolNames(): Promise<string[]>;
};
type PromptBlockDoor<Row = PromptBlockRow, VariantRow = PromptBlockVariantRow> = ReturnType<typeof createPromptBlockDoor<Row, VariantRow>>;

interface LocalPrompt {
    id: string;
    name: string;
    content: string;
    category: string;
    createdAt: number;
    updatedAt: number;
    isPinned: boolean;
}
/** Read Matrx Local's `matrx-system-prompts` value; anything that is not a prompt is dropped. */
declare function parseLocalPrompts(raw: unknown): LocalPrompt[];
/** Where a block that came from a computer's library says it came from (metadata.local_prompt). */
interface LocalPromptOrigin {
    source: string;
    id: string;
    category: string;
    pinned: boolean;
}
declare function localOriginOf(row: Pick<PromptBlockRow, "metadata">): LocalPromptOrigin | null;
/** A block name not yet taken: `name`, then `name-2`, `name-3`… */
declare function freeBlockName(base: string, taken: ReadonlySet<string>): string;
/** The personal block a local prompt becomes (the caller picks a free name and the organization). */
declare function localPromptToBlock(prompt: LocalPrompt, opts: {
    source: string;
    name: string;
    organizationId: string;
    testRunId?: string | null;
}): NewBlock;

export { BLOCK_LANES, BLOCK_LANE_LABEL, BLOCK_LANE_PARAM, BLOCK_NAME_PATTERN, BLOCK_NAME_RE, DEFAULT_BLOCK_LANE, REASONING_LEVELS, SYSTEM_ORG_ID, applyBlockInsert, blockChipState, blockLaneFromParam, blockNamesInText, blockToken, conditionToJson, createPromptBlockDoor, declaredNames, describeCondition, freeBlockName, isEmptyCondition, isValidBlockName, laneOf, localOriginOf, localPromptToBlock, matchesQuery, mayBeStale, parseCondition, parseLocalPrompts, partitionByLane, splitBlockText, toBlockName, typedTriggerAt, withDeclared, withoutDeclared };
export type { BlockChipState, BlockCondition, BlockLane, BlockPatch, BlockTextSegment, DeclaredBlock, Json, LocalPrompt, LocalPromptOrigin, NewBlock, PromptBlockDoor, PromptBlockReportEntry, PromptBlockRow, PromptBlockVariantRow, PromptBlocksClient, PromptBlocksDbError, PromptBlocksFilter, SkillOption, TypedTrigger, UsingAgent };