import * as _sentry_junior_plugin_api from '@sentry/junior-plugin-api';
import { z } from 'zod';
import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
import { PgDatabase } from 'drizzle-orm/pg-core';
import { PgQueryResultHKT } from 'drizzle-orm/pg-core/session';

interface MemoryPluginOptions {
    /** Disable automatic prompt recall while keeping explicit memory tools available. */
    disableRecall?: boolean;
    /** Disable passive memory extraction from completed sessions. */
    disableExtraction?: boolean;
    modelId?: string;
}
/** Register Junior's long-term memory plugin. */
declare function memoryPlugin(options?: MemoryPluginOptions): _sentry_junior_plugin_api.PluginRegistration;

declare const juniorMemoryMemories: drizzle_orm_pg_core.PgTableWithColumns<{
    name: "junior_memory_memories";
    schema: undefined;
    columns: {
        id: drizzle_orm_pg_core.PgColumn<{
            name: "id";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: true;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        scope: drizzle_orm_pg_core.PgColumn<{
            name: "scope";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: "private" | "public";
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: ["private", "public"];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        scopeKey: drizzle_orm_pg_core.PgColumn<{
            name: "scope_key";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        kind: drizzle_orm_pg_core.PgColumn<{
            name: "type";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: "preference" | "procedure" | "knowledge";
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: ["preference", "procedure", "knowledge"];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        subjectType: drizzle_orm_pg_core.PgColumn<{
            name: "subject_type";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: "user" | "conversation" | "general";
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: ["user", "conversation", "general"];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        subjectKey: drizzle_orm_pg_core.PgColumn<{
            name: "subject_key";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        content: drizzle_orm_pg_core.PgColumn<{
            name: "content";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        searchVector: drizzle_orm_pg_core.PgColumn<{
            name: "search_vector";
            tableName: "junior_memory_memories";
            dataType: "custom";
            columnType: "PgCustomColumn";
            data: string;
            driverParam: unknown;
            notNull: false;
            hasDefault: true;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: {
                type: "always";
            };
        }, {}, {
            pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
        }>;
        sourcePlatform: drizzle_orm_pg_core.PgColumn<{
            name: "source_platform";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: "slack" | "local" | "web";
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: ["slack", "local", "web"];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        sourceKey: drizzle_orm_pg_core.PgColumn<{
            name: "source_key";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        locationId: drizzle_orm_pg_core.PgColumn<{
            name: "location_id";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        conversationId: drizzle_orm_pg_core.PgColumn<{
            name: "conversation_id";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        idempotencyKey: drizzle_orm_pg_core.PgColumn<{
            name: "idempotency_key";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        observedAtMs: drizzle_orm_pg_core.PgColumn<{
            name: "observed_at_ms";
            tableName: "junior_memory_memories";
            dataType: "number";
            columnType: "PgBigInt53";
            data: number;
            driverParam: string | number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        createdAtMs: drizzle_orm_pg_core.PgColumn<{
            name: "created_at_ms";
            tableName: "junior_memory_memories";
            dataType: "number";
            columnType: "PgBigInt53";
            data: number;
            driverParam: string | number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        expiresAtMs: drizzle_orm_pg_core.PgColumn<{
            name: "expires_at_ms";
            tableName: "junior_memory_memories";
            dataType: "number";
            columnType: "PgBigInt53";
            data: number;
            driverParam: string | number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        supersededAtMs: drizzle_orm_pg_core.PgColumn<{
            name: "superseded_at_ms";
            tableName: "junior_memory_memories";
            dataType: "number";
            columnType: "PgBigInt53";
            data: number;
            driverParam: string | number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        supersededById: drizzle_orm_pg_core.PgColumn<{
            name: "superseded_by_id";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        archivedAtMs: drizzle_orm_pg_core.PgColumn<{
            name: "archived_at_ms";
            tableName: "junior_memory_memories";
            dataType: "number";
            columnType: "PgBigInt53";
            data: number;
            driverParam: string | number;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        archiveReason: drizzle_orm_pg_core.PgColumn<{
            name: "archive_reason";
            tableName: "junior_memory_memories";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: false;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
    };
    dialect: "pg";
}>;
declare const juniorMemoryEmbeddings: drizzle_orm_pg_core.PgTableWithColumns<{
    name: "junior_memory_embeddings";
    schema: undefined;
    columns: {
        memoryId: drizzle_orm_pg_core.PgColumn<{
            name: "memory_id";
            tableName: "junior_memory_embeddings";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: true;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        provider: drizzle_orm_pg_core.PgColumn<{
            name: "provider";
            tableName: "junior_memory_embeddings";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        model: drizzle_orm_pg_core.PgColumn<{
            name: "model";
            tableName: "junior_memory_embeddings";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        dimensions: drizzle_orm_pg_core.PgColumn<{
            name: "dimensions";
            tableName: "junior_memory_embeddings";
            dataType: "number";
            columnType: "PgInteger";
            data: number;
            driverParam: string | number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        metric: drizzle_orm_pg_core.PgColumn<{
            name: "metric";
            tableName: "junior_memory_embeddings";
            dataType: "string";
            columnType: "PgText";
            data: "cosine";
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: ["cosine"];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        contentHash: drizzle_orm_pg_core.PgColumn<{
            name: "content_hash";
            tableName: "junior_memory_embeddings";
            dataType: "string";
            columnType: "PgText";
            data: string;
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: [string, ...string[]];
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
        embedding: drizzle_orm_pg_core.PgColumn<{
            name: "embedding";
            tableName: "junior_memory_embeddings";
            dataType: "array";
            columnType: "PgVector";
            data: number[];
            driverParam: string;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {
            dimensions: 1536;
        }>;
        createdAtMs: drizzle_orm_pg_core.PgColumn<{
            name: "created_at_ms";
            tableName: "junior_memory_embeddings";
            dataType: "number";
            columnType: "PgBigInt53";
            data: number;
            driverParam: string | number;
            notNull: true;
            hasDefault: false;
            isPrimaryKey: false;
            isAutoincrement: false;
            hasRuntimeDefault: false;
            enumValues: undefined;
            baseColumn: never;
            identity: undefined;
            generated: undefined;
        }, {}, {}>;
    };
    dialect: "pg";
}>;

declare const memorySqlSchema_juniorMemoryEmbeddings: typeof juniorMemoryEmbeddings;
declare const memorySqlSchema_juniorMemoryMemories: typeof juniorMemoryMemories;
declare namespace memorySqlSchema {
  export { memorySqlSchema_juniorMemoryEmbeddings as juniorMemoryEmbeddings, memorySqlSchema_juniorMemoryMemories as juniorMemoryMemories };
}

declare const MEMORY_KINDS: readonly ["preference", "procedure", "knowledge"];
type MemoryKind = (typeof MEMORY_KINDS)[number];
/** Host data used to set memory access, subject, and source. */
declare const memoryRuntimeContextSchema: z.ZodObject<{
    conversationId: z.ZodOptional<z.ZodString>;
    locationId: z.ZodOptional<z.ZodString>;
    actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
        platform: z.ZodLiteral<"slack">;
        teamId: z.ZodString;
        email: z.ZodOptional<z.ZodString>;
        fullName: z.ZodOptional<z.ZodString>;
        userId: z.ZodString;
        userName: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        platform: z.ZodLiteral<"local">;
        email: z.ZodOptional<z.ZodString>;
        fullName: z.ZodOptional<z.ZodString>;
        userId: z.ZodString;
        userName: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        platform: z.ZodLiteral<"web">;
        email: z.ZodOptional<z.ZodString>;
        fullName: z.ZodOptional<z.ZodString>;
        userId: z.ZodString;
        userName: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        platform: z.ZodLiteral<"system">;
        name: z.ZodString;
    }, z.core.$strict>], "platform">>;
    source: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"slack">;
        teamId: z.ZodString;
        channelId: z.ZodString;
        visibility: z.ZodEnum<{
            public: "public";
            private: "private";
        }>;
        messageTs: z.ZodOptional<z.ZodString>;
        threadTs: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"local">;
        visibility: z.ZodLiteral<"private">;
        conversationId: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"web">;
        visibility: z.ZodEnum<{
            public: "public";
            private: "private";
        }>;
        conversationId: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"event">;
        eventKey: z.ZodString;
        eventType: z.ZodString;
        identifier: z.ZodString;
        namespace: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"scheduled_automation">;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"event_automation">;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"plugin_dispatch">;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"agent_invocation">;
    }, z.core.$strict>], "kind">, unknown>;
    userId: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
type MemoryRuntimeContext = z.output<typeof memoryRuntimeContextSchema>;

type MemoryDb = PgDatabase<PgQueryResultHKT, typeof memorySqlSchema>;
declare const createMemoryInputSchema: z.ZodObject<{
    content: z.ZodString;
    expiresAtMs: z.ZodOptional<z.ZodNumber>;
    idempotencyKey: z.ZodString;
    kind: z.ZodEnum<{
        preference: "preference";
        procedure: "procedure";
        knowledge: "knowledge";
    }>;
}, z.core.$strict>;
declare const listMemoriesInputSchema: z.ZodObject<{
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strict>;
declare const searchMemoriesInputSchema: z.ZodObject<{
    limit: z.ZodOptional<z.ZodNumber>;
    query: z.ZodString;
}, z.core.$strict>;
declare const archiveMemoryInputSchema: z.ZodObject<{
    id: z.ZodString;
    reason: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
declare const archiveExpiredMemoriesInputSchema: z.ZodObject<{
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strict>;
declare const memoryRecordSchema: z.ZodObject<{
    archivedAtMs: z.ZodOptional<z.ZodNumber>;
    archiveReason: z.ZodOptional<z.ZodString>;
    content: z.ZodString;
    conversationId: z.ZodOptional<z.ZodString>;
    createdAtMs: z.ZodNumber;
    expiresAtMs: z.ZodOptional<z.ZodNumber>;
    id: z.ZodString;
    observedAtMs: z.ZodNumber;
    scope: z.ZodEnum<{
        private: "private";
        public: "public";
    }>;
    subjectType: z.ZodEnum<{
        user: "user";
        conversation: "conversation";
        general: "general";
    }>;
    supersededAtMs: z.ZodOptional<z.ZodNumber>;
    supersededById: z.ZodOptional<z.ZodString>;
    kind: z.ZodEnum<{
        preference: "preference";
        procedure: "procedure";
        knowledge: "knowledge";
    }>;
}, z.core.$strict>;
/** Validated preference comparison input supplied to a supersession decider. */
declare const memorySupersessionInputSchema: z.ZodObject<{
    candidate: z.ZodObject<{
        content: z.ZodString;
        kind: z.ZodLiteral<"preference">;
    }, z.core.$strict>;
    existingMemories: z.ZodArray<z.ZodObject<{
        content: z.ZodString;
        id: z.ZodString;
    }, z.core.$strict>>;
    runtimeContext: z.ZodObject<{
        conversationId: z.ZodOptional<z.ZodString>;
        locationId: z.ZodOptional<z.ZodString>;
        actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
            platform: z.ZodLiteral<"slack">;
            teamId: z.ZodString;
            email: z.ZodOptional<z.ZodString>;
            fullName: z.ZodOptional<z.ZodString>;
            userId: z.ZodString;
            userName: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>, z.ZodObject<{
            platform: z.ZodLiteral<"local">;
            email: z.ZodOptional<z.ZodString>;
            fullName: z.ZodOptional<z.ZodString>;
            userId: z.ZodString;
            userName: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>, z.ZodObject<{
            platform: z.ZodLiteral<"web">;
            email: z.ZodOptional<z.ZodString>;
            fullName: z.ZodOptional<z.ZodString>;
            userId: z.ZodString;
            userName: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>, z.ZodObject<{
            platform: z.ZodLiteral<"system">;
            name: z.ZodString;
        }, z.core.$strict>], "platform">>;
        source: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
            kind: z.ZodLiteral<"slack">;
            teamId: z.ZodString;
            channelId: z.ZodString;
            visibility: z.ZodEnum<{
                public: "public";
                private: "private";
            }>;
            messageTs: z.ZodOptional<z.ZodString>;
            threadTs: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"local">;
            visibility: z.ZodLiteral<"private">;
            conversationId: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"web">;
            visibility: z.ZodEnum<{
                public: "public";
                private: "private";
            }>;
            conversationId: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"event">;
            eventKey: z.ZodString;
            eventType: z.ZodString;
            identifier: z.ZodString;
            namespace: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"scheduled_automation">;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"event_automation">;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"plugin_dispatch">;
        }, z.core.$strict>, z.ZodObject<{
            kind: z.ZodLiteral<"agent_invocation">;
        }, z.core.$strict>], "kind">, unknown>;
        userId: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
}, z.core.$strict>;
/**
 * Validated preference decision whose referenced ids must come from the
 * supplied existing memories.
 */
declare const memorySupersessionDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    decision: z.ZodLiteral<"duplicate">;
    duplicateId: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    decision: z.ZodLiteral<"supersedes_old">;
    supersededIds: z.ZodArray<z.ZodString>;
}, z.core.$strict>, z.ZodObject<{
    decision: z.ZodEnum<{
        distinct: "distinct";
        uncertain: "uncertain";
    }>;
}, z.core.$strict>], "decision">;
type MemoryRecord = z.output<typeof memoryRecordSchema>;
type CreateMemoryInput = z.output<typeof createMemoryInputSchema>;
/** Result of a memory write after idempotency checks. */
interface CreateMemoryResult {
    created: boolean;
    /** True when this call found the memory previously written for the same input identity. */
    idempotent?: true;
    memory: MemoryRecord;
    /** Memory ids made inactive by this write. */
    supersededIds?: string[];
}
type ListMemoriesInput = z.output<typeof listMemoriesInputSchema>;
type SearchMemoriesInput = z.output<typeof searchMemoriesInputSchema>;
type ArchiveMemoryInput = z.output<typeof archiveMemoryInputSchema>;
type ArchiveExpiredMemoriesInput = z.output<typeof archiveExpiredMemoriesInputSchema>;
interface ArchiveExpiredMemoriesResult {
    archivedCount: number;
}
interface MemoryEmbeddingProvider {
    /** Embed normalized memory text for derived vector retrieval. */
    embedTexts(input: {
        texts: string[];
    }): Promise<{
        costUsd?: number;
        dimensions: number;
        model: string;
        provider: string;
        vectors: number[][];
    }>;
}
type MemorySupersessionInput = z.output<typeof memorySupersessionInputSchema>;
type MemorySupersessionDecision = z.output<typeof memorySupersessionDecisionSchema>;
interface MemorySupersessionDecider {
    /** Classify a new preference against related active preferences. */
    adjudicateSupersession(input: MemorySupersessionInput): Promise<MemorySupersessionDecision> | MemorySupersessionDecision;
}
interface MemoryStoreOptions {
    embedder?: MemoryEmbeddingProvider;
    now?: () => number;
    supersessionDecider?: MemorySupersessionDecider;
}
/** Context-bound storage operations for visible long-term memories. */
interface MemoryStore {
    /** Archive expired memories visible in the current runtime context. */
    archiveExpiredMemories(input?: ArchiveExpiredMemoriesInput): Promise<ArchiveExpiredMemoriesResult>;
    /** Archive a visible memory in the current runtime context. */
    archiveMemory(input: ArchiveMemoryInput): Promise<MemoryRecord>;
    /** Store a memory about the current User. The Source sets access. */
    createMemory(input: CreateMemoryInput): Promise<CreateMemoryResult>;
    /** Store a memory about the current Conversation. The Source sets access. */
    createConversationMemory(input: CreateMemoryInput): Promise<CreateMemoryResult>;
    /** List active memories visible in the current runtime context. */
    listMemories(input: ListMemoriesInput): Promise<MemoryRecord[]>;
    /**
     * Retrieve a broad relevance-ranked candidate window for automatic recall.
     * Prompt admission remains owned by the recall boundary.
     */
    recallMemories(input: SearchMemoriesInput): Promise<MemoryRecord[]>;
    /** Search active memories visible in the current runtime context. */
    searchMemories(input: SearchMemoriesInput): Promise<MemoryRecord[]>;
}
/** Create a context-bound SQL-backed store for explicit memory operations. */
declare function createMemoryStore(db: MemoryDb, context: MemoryRuntimeContext, options?: MemoryStoreOptions): MemoryStore;

/**
 * Authenticated REST access to memory.
 *
 * The signed-in User can read public memory and private memory that they own.
 */

declare const memoryApiSchema: z.ZodObject<{
    content: z.ZodString;
    createdAt: z.ZodISODateTime;
    expiresAt: z.ZodOptional<z.ZodISODateTime>;
    id: z.ZodString;
    kind: z.ZodEnum<{
        preference: "preference";
        procedure: "procedure";
        knowledge: "knowledge";
    }>;
    observedAt: z.ZodISODateTime;
    origin: z.ZodEnum<{
        automatic: "automatic";
        explicit: "explicit";
        other: "other";
    }>;
    sourcePlatform: z.ZodEnum<{
        slack: "slack";
        local: "local";
        web: "web";
    }>;
    visibility: z.ZodEnum<{
        private: "private";
        public: "public";
    }>;
}, z.core.$strict>;
declare const memoryListResponseSchema: z.ZodObject<{
    memories: z.ZodArray<z.ZodObject<{
        content: z.ZodString;
        createdAt: z.ZodISODateTime;
        expiresAt: z.ZodOptional<z.ZodISODateTime>;
        id: z.ZodString;
        kind: z.ZodEnum<{
            preference: "preference";
            procedure: "procedure";
            knowledge: "knowledge";
        }>;
        observedAt: z.ZodISODateTime;
        origin: z.ZodEnum<{
            automatic: "automatic";
            explicit: "explicit";
            other: "other";
        }>;
        sourcePlatform: z.ZodEnum<{
            slack: "slack";
            local: "local";
            web: "web";
        }>;
        visibility: z.ZodEnum<{
            private: "private";
            public: "public";
        }>;
    }, z.core.$strict>>;
    nextCursor: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
declare const memoryDashboardResponseSchema: z.ZodObject<{
    days: z.ZodArray<z.ZodObject<{
        date: z.ZodString;
        personal: z.ZodNumber;
        public: z.ZodNumber;
    }, z.core.$strict>>;
    extractionDays: z.ZodArray<z.ZodObject<{
        costUsd: z.ZodNumber;
        date: z.ZodString;
        events: z.ZodNumber;
    }, z.core.$strict>>;
    extractionHours: z.ZodOptional<z.ZodArray<z.ZodObject<{
        costUsd: z.ZodNumber;
        date: z.ZodString;
        events: z.ZodNumber;
    }, z.core.$strict>>>;
    generatedAt: z.ZodISODateTime;
    hours: z.ZodOptional<z.ZodArray<z.ZodObject<{
        date: z.ZodString;
        personal: z.ZodNumber;
        public: z.ZodNumber;
    }, z.core.$strict>>>;
    recallDays: z.ZodArray<z.ZodObject<{
        costUsd: z.ZodNumber;
        date: z.ZodString;
        events: z.ZodNumber;
    }, z.core.$strict>>;
    recallHours: z.ZodOptional<z.ZodArray<z.ZodObject<{
        costUsd: z.ZodNumber;
        date: z.ZodString;
        events: z.ZodNumber;
    }, z.core.$strict>>>;
    stats: z.ZodObject<{
        active: z.ZodNumber;
        automatic: z.ZodNumber;
        createdThirtyDays: z.ZodNumber;
        embedded: z.ZodNumber;
        explicit: z.ZodNumber;
        knowledge: z.ZodNumber;
        personal: z.ZodNumber;
        preference: z.ZodNumber;
        procedure: z.ZodNumber;
        public: z.ZodNumber;
    }, z.core.$strict>;
}, z.core.$strict>;
type MemoryApi = z.output<typeof memoryApiSchema>;
type MemoryDashboardResponse = z.output<typeof memoryDashboardResponseSchema>;
type MemoryListResponse = z.output<typeof memoryListResponseSchema>;

export { type ArchiveMemoryInput, type CreateMemoryInput, type CreateMemoryResult, type ListMemoriesInput, MEMORY_KINDS, type MemoryApi, type MemoryDashboardResponse, type MemoryDb, type MemoryEmbeddingProvider, type MemoryKind, type MemoryListResponse, type MemoryPluginOptions, type MemoryRecord, type MemoryRuntimeContext, type MemoryStore, type MemoryStoreOptions, type SearchMemoriesInput, createMemoryStore, memoryApiSchema, memoryDashboardResponseSchema, memoryListResponseSchema, memoryPlugin };