@dreamingai/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1414 @@
+export interface Memory {
+    id: string;
+    userId: string;
+    appId: string;
+    content: string;
+    memoryType: string;
+    memoryTier: number;
+    importance: number;
+    confidence: number;
+    accessCount: number;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    lastAccessed?: string;
+}
+export interface MemorySearchResult {
+    memory: Memory;
+    relevance: number;
+    decayScore?: number;
+    effectiveScore?: number;
+}
+export interface Entity {
+    id: string;
+    name: string;
+    entityType: string;
+    properties: Record<string, unknown>;
+}
+export interface Triple {
+    id: string;
+    subject: string;
+    predicate: string;
+    object: string;
+    validFrom?: string;
+    validTo?: string;
+    confidence: number;
+}
+export interface OceanProfile {
+    userId: string;
+    openness: number;
+    conscientiousness: number;
+    extraversion: number;
+    agreeableness: number;
+    neuroticism: number;
+    mbtiType?: string;
+    confidence: number;
+    sampleCount: number;
+}
+export interface LinguisticFingerprint {
+    userId: string;
+    formality: number;
+    vocabRichness: number;
+    avgSentenceLength: number;
+    emojiUsage: number;
+    dominantTone: string;
+}
+export interface SleeptimeInsight {
+    id: number;
+    type: string;
+    content: string;
+    createdAt: string;
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+    total: number;
+    offset: number;
+    limit: number;
+    hasMore: boolean;
+}
+export interface MeterStatus {
+    subscriptionTier: string;
+    modelTier: 'efficient' | 'smart' | 'genius';
+    modelTierName: string;
+    modelTierIcon: string;
+    modelTierDescription: string;
+    primaryModel: string;
+    fallbackModel: string;
+    maxTokens: number;
+    availableTiers: Array<{
+        key: string;
+        name: string;
+        icon: string;
+        description: string;
+        primaryModel: string;
+    }>;
+    tierMapping: Record<string, string>;
+    usage: {
+        callsThisMonth: number;
+        tokensThisMonth: number;
+        avgLatencyMs: number;
+        fallbackRate: string;
+    };
+}
+export interface MeterUsage {
+    daily: Array<{
+        day: string;
+        model_tier: string;
+        model_used: string;
+        calls: number;
+        total_tokens_in: number;
+        total_tokens_out: number;
+        avg_latency: number;
+        fallback_count: number;
+    }>;
+    byFeature: Array<{
+        feature: string;
+        model_tier: string;
+        calls: number;
+        total_tokens: number;
+    }>;
+}
+export interface DreamingClientConfig {
+    apiKey: string;
+    appId: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+declare class HttpClient {
+    private baseUrl;
+    private headers;
+    private timeout;
+    constructor(config: DreamingClientConfig);
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}
+export declare class DreamingError extends Error {
+    code: string;
+    status: number;
+    constructor(code: string, message: string, status: number);
+}
+declare class MemoriesClient {
+    private http;
+    constructor(http: HttpClient);
+    create(input: {
+        userId: string;
+        content: string;
+        type?: string;
+        importance?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<Memory>;
+    list(userId: string, options?: {
+        limit?: number;
+        offset?: number;
+        types?: string[];
+    }): Promise<PaginatedResponse<Memory>>;
+    get(id: string): Promise<Memory>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+    search(input: {
+        userId: string;
+        query: string;
+        limit?: number;
+        types?: string[];
+        crossApp?: boolean;
+        includeDecayScore?: boolean;
+    }): Promise<MemorySearchResult[]>;
+    recall(input: {
+        userId: string;
+        query: string;
+        limit?: number;
+        includeDecayScore?: boolean;
+    }): Promise<MemorySearchResult[]>;
+}
+declare class DreamingApiClient {
+    private http;
+    constructor(http: HttpClient);
+    process(input: {
+        userId: string;
+        conversation: Array<{
+            role: string;
+            content: string;
+        }>;
+    }): Promise<{
+        queued: number;
+    }>;
+    consolidate(userId: string): Promise<{
+        promoted: number;
+        merged: number;
+        evicted: number;
+    }>;
+    getInsights(userId: string, limit?: number): Promise<SleeptimeInsight[]>;
+    getStatus(): Promise<Record<string, number>>;
+}
+declare class GraphClient {
+    private http;
+    constructor(http: HttpClient);
+    addEntity(userId: string, name: string, entityType?: string, properties?: Record<string, unknown>): Promise<Entity>;
+    addTriple(userId: string, subject: string, predicate: string, object: string, options?: {
+        validFrom?: string;
+        validTo?: string;
+        confidence?: number;
+    }): Promise<Triple>;
+    query(userId: string, options?: {
+        subject?: string;
+        predicate?: string;
+        object?: string;
+        validAt?: string;
+        limit?: number;
+    }): Promise<Triple[]>;
+    getEntityFacts(userId: string, entityName: string): Promise<Triple[]>;
+}
+declare class PersonalityClient {
+    private http;
+    constructor(http: HttpClient);
+    getOcean(userId: string): Promise<OceanProfile>;
+    analyzeOcean(userId: string, text: string): Promise<OceanProfile>;
+    getFingerprint(userId: string): Promise<LinguisticFingerprint>;
+}
+export type AiState = 'idle' | 'thinking' | 'chatting' | 'creating' | 'learning' | 'dreaming' | 'evolving';
+export interface AiStatus {
+    state: AiState;
+    detail: string;
+    since: number;
+    bgProcesses: string[];
+}
+export interface BrainHealth {
+    state: string;
+    memories: number;
+    memoriesWithEmbeddings: number;
+    memoryBlocks: number;
+    kgEntities: number;
+    hasOcean: boolean;
+    hasFingerprint: boolean;
+    healthy: boolean;
+    uptime: number;
+}
+export interface QuotaUsage {
+    tier: string;
+    memory_entries: number;
+    max_memories: number;
+    shade_count: number;
+    max_shades: number;
+    used_bytes: number;
+    max_bytes: number;
+    storage_used_mb: number;
+    storage_limit_mb: number;
+}
+export type ConsentStatus = 'synced' | 'paused' | 'pending' | 'declined';
+export interface SyncSettings {
+    userId: string;
+    enabled: boolean;
+    categories: Record<string, boolean>;
+    updatedAt: string;
+}
+export interface SyncConsent {
+    id: string;
+    domain: string;
+    name: string;
+    memberCount: number;
+    consentStatus: ConsentStatus;
+    lastSync: string;
+}
+declare class StatusClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Get current AI cognitive state (for orb rendering) */
+    getStatus(userId?: string): Promise<AiStatus>;
+    /** Get detailed brain health metrics (for settings page) */
+    getBrainHealth(userId?: string): Promise<BrainHealth>;
+    /** Get quota usage and limits */
+    getQuota(userId?: string): Promise<QuotaUsage>;
+}
+declare class SyncClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Get user's global sync settings */
+    getSettings(userId?: string): Promise<SyncSettings>;
+    /** Update sync settings (global toggle + category toggles) */
+    updateSettings(input: {
+        userId?: string;
+        enabled?: boolean;
+        categories?: Record<string, boolean>;
+    }): Promise<SyncSettings>;
+    /** Get consent status for all partner workspaces */
+    getConsents(userId?: string, appId?: string): Promise<SyncConsent[]>;
+    /** Accept, pause, resume, or decline sync with a target workspace */
+    updateConsent(input: {
+        userId?: string;
+        targetWorkspaceId: string;
+        action: 'accept' | 'pause' | 'resume' | 'decline';
+        domain?: string;
+        name?: string;
+    }): Promise<SyncConsent>;
+    /** Get privacy exposure toggles */
+    getExposure(userId?: string, appId?: string): Promise<Record<string, boolean>>;
+    /** Update privacy exposure toggles */
+    updateExposure(toggles: Record<string, boolean>, userId?: string): Promise<Record<string, boolean>>;
+}
+declare class ContextClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Get pre-built context string for injection into LLM prompts */
+    getContext(userId: string): Promise<{
+        context: string;
+        memories: number;
+        personality: string;
+    }>;
+    /** Before-chat hook: enrich messages with context (for non-middleware integrations) */
+    beforeChat(input: {
+        userId: string;
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+    }): Promise<Array<{
+        role: string;
+        content: string;
+    }>>;
+    /** After-chat hook: queue conversation for sleeptime processing */
+    afterChat(input: {
+        userId: string;
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+    }): Promise<{
+        queued: number;
+    }>;
+}
+/** Pre-built UI badge for displaying AI tier in partner apps */
+export interface MeterBadge {
+    /** Tier key: 'efficient' | 'smart' | 'genius' */
+    tier: string;
+    /** Display icon emoji */
+    icon: string;
+    /** Human-readable label (e.g., "Smart AI") */
+    label: string;
+    /** CSS-ready hex color for the badge */
+    color: string;
+    /** Short description of the tier */
+    description: string;
+    /** Primary model name (for transparency) */
+    model: string;
+    /** Whether the user can upgrade to a higher tier */
+    canUpgrade: boolean;
+    /** The next tier name if upgradeable */
+    nextTier?: string;
+    /** A ready-to-use upgrade CTA message */
+    upgradeMessage?: string;
+}
+declare class MeterClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Get current model tier status for the authenticated user */
+    getStatus(userId?: string): Promise<MeterStatus>;
+    /** Get detailed usage history */
+    getUsage(userId: string, options?: {
+        days?: number;
+        limit?: number;
+    }): Promise<MeterUsage>;
+    /**
+     * Get a ready-to-use UI badge for displaying the AI tier.
+     * Partners can drop this directly into their app UI.
+     *
+     * @example
+     * ```tsx
+     * const badge = await dreaming.meter.getBadge('user-123');
+     * return (
+     *   <div style={{ background: badge.color, borderRadius: 12, padding: '4px 12px' }}>
+     *     {badge.icon} {badge.label}
+     *   </div>
+     * );
+     * ```
+     */
+    getBadge(userId?: string): Promise<MeterBadge>;
+    /** Quick check: is this user on the highest AI tier? */
+    isGeniusTier(userId?: string): Promise<boolean>;
+    /** Quick check: can this user upgrade to a better AI tier? */
+    canUpgrade(userId?: string): Promise<boolean>;
+    /**
+     * Get a formatted usage summary string for dashboards.
+     *
+     * @example
+     * ```
+     * "🔵 Smart AI — 45 calls, 12.5k tokens this month (avg 230ms)"
+     * ```
+     */
+    getUsageSummary(userId?: string): Promise<string>;
+}
+export declare class DreamingClient {
+    readonly memories: MemoriesClient;
+    readonly dreaming: DreamingApiClient;
+    readonly graph: GraphClient;
+    readonly personality: PersonalityClient;
+    readonly status: StatusClient;
+    readonly sync: SyncClient;
+    readonly context: ContextClient;
+    readonly meter: MeterClient;
+    readonly activities: ActivityClient;
+    readonly constraints: ConstraintClient;
+    readonly chat: ChatClient;
+    readonly knowledge: KnowledgeClient;
+    readonly web: WebClient;
+    readonly identity: IdentityClient;
+    readonly friends: FriendsClient;
+    readonly proactive: ProactiveClient;
+    readonly notifications: NotificationsClient;
+    readonly evolution: EvolutionClient;
+    readonly dna: DnaClient;
+    readonly partnerTokens: PartnerTokensClient;
+    constructor(config: DreamingClientConfig);
+    /**
+     * Flush any buffered activity events before shutdown.
+     * Call this in your app's cleanup/beforeunload handler.
+     */
+    flush(): Promise<void>;
+}
+export interface KnowledgeDoc {
+    docId: string;
+    title: string;
+    chunkCount: number;
+    fileSizeBytes: number;
+    format: string;
+    domain: string;
+    status: string;
+}
+export interface KnowledgeChunk {
+    id: number;
+    doc_id: string;
+    content: string;
+    chunk_index: number;
+    domain: string;
+    topic: string;
+    importance: number;
+    doc_title?: string;
+    relevance?: number;
+}
+export interface KnowledgeModule {
+    module_id: string;
+    enabled: boolean;
+    priority: number;
+    doc_count: number;
+    chunk_count: number;
+}
+declare class KnowledgeClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Upload a document to the knowledge base.
+     * Supports: text, markdown, CSV, JSON, HTML, URL, base64, PDF.
+     * Auto-detects format from filename/content if sourceType is 'auto' or omitted.
+     *
+     * @example
+     * ```typescript
+     * // Upload markdown
+     * await dreaming.knowledge.upload({
+     *   appId: 'my-app',
+     *   title: 'Training Guide',
+     *   content: '# Running Tips\n\nStart slow...',
+     * });
+     *
+     * // Upload CSV data
+     * await dreaming.knowledge.upload({
+     *   appId: 'my-app',
+     *   title: 'Workout Log',
+     *   content: 'date,distance,time\n2024-01-01,5km,28min',
+     *   sourceType: 'csv',
+     * });
+     *
+     * // Upload with constraint auto-linking
+     * await dreaming.knowledge.upload({
+     *   appId: 'my-app',
+     *   userId: 'user-1',
+     *   title: 'Fitness Plan',
+     *   content: pdfBase64,
+     *   sourceType: 'base64',
+     *   feedConstraints: true,  // Auto-creates tags from content
+     * });
+     * ```
+     */
+    upload(options: {
+        appId: string;
+        title: string;
+        content: string;
+        userId?: string;
+        moduleId?: string;
+        sourceType?: string;
+        sourceUrl?: string;
+        filename?: string;
+        scope?: 'app' | 'user';
+        feedConstraints?: boolean;
+        metadata?: Record<string, unknown>;
+    }): Promise<KnowledgeDoc>;
+    /**
+     * Upload content from a URL. Fetches and parses automatically.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.knowledge.uploadUrl({
+     *   appId: 'my-app',
+     *   title: 'Running Tips Article',
+     *   url: 'https://example.com/running-tips',
+     * });
+     * ```
+     */
+    uploadUrl(options: {
+        appId: string;
+        title: string;
+        url: string;
+        moduleId?: string;
+        userId?: string;
+    }): Promise<KnowledgeDoc>;
+    /** List uploaded documents. */
+    listDocs(options?: {
+        appId?: string;
+        moduleId?: string;
+    }): Promise<KnowledgeDoc[]>;
+    /** Get document details. */
+    getDoc(docId: string): Promise<KnowledgeDoc>;
+    /** View chunks of a document. */
+    getChunks(docId: string): Promise<KnowledgeChunk[]>;
+    /**
+     * Search knowledge base with semantic + keyword fallback.
+     *
+     * @example
+     * ```typescript
+     * const results = await dreaming.knowledge.search('running tips', {
+     *   appId: 'active365',
+     *   limit: 5,
+     *   domain: 'fitness',
+     * });
+     * ```
+     */
+    search(query: string, options: {
+        appId: string;
+        domain?: string;
+        limit?: number;
+    }): Promise<KnowledgeChunk[]>;
+    /** Delete a document and all its chunks. */
+    deleteDoc(docId: string): Promise<void>;
+    /**
+     * Enable or disable a document (soft toggle).
+     * Disabled docs are excluded from search and chat context.
+     */
+    toggleDoc(docId: string, enabled: boolean): Promise<void>;
+    /**
+     * List knowledge modules with doc/chunk counts.
+     *
+     * @example
+     * ```typescript
+     * const modules = await dreaming.knowledge.listModules('active365');
+     * // [{ module_id: 'fitness-guides', enabled: true, doc_count: 3, chunk_count: 45 }]
+     * ```
+     */
+    listModules(appId: string): Promise<KnowledgeModule[]>;
+    /**
+     * Enable or disable an entire knowledge module.
+     * All docs in a disabled module are excluded from search.
+     */
+    toggleModule(moduleId: string, options: {
+        appId: string;
+        enabled: boolean;
+    }): Promise<void>;
+    /**
+     * Re-chunk a document with different settings.
+     */
+    reprocess(docId: string, options?: {
+        chunkSize?: number;
+        overlap?: number;
+    }): Promise<KnowledgeDoc>;
+}
+/** Chat context returned from enrich() */
+export interface ChatContext {
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    system?: string;
+    memories: any[];
+    metadata: {
+        memoriesUsed: number;
+        hasPersonality: boolean;
+        hasConstraints: boolean;
+        hasKnowledge: boolean;
+        appPersona: string | null;
+    };
+}
+/** Options for enrich() */
+export interface EnrichOptions {
+    maxMemories?: number;
+    includePersonality?: boolean;
+    includeConstraints?: boolean;
+    includeKnowledge?: boolean;
+    webGrounding?: boolean;
+    format?: 'openai' | 'anthropic' | 'raw';
+}
+/** Options for learn() */
+export interface LearnOptions {
+    metadata?: Record<string, unknown>;
+}
+declare class ChatClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * BEFORE your LLM call: get memory/personality/goal context.
+     *
+     * Returns messages you inject into your conversation.
+     * Default format is OpenAI-compatible.
+     *
+     * @example
+     * ```typescript
+     * const ctx = await dreaming.chat.enrich('user-1', 'How should I train today?');
+     *
+     * // Inject into your OpenAI call:
+     * const response = await openai.chat.completions.create({
+     *   model: 'gpt-4o',
+     *   messages: [...ctx.messages, ...yourConversation],
+     * });
+     * ```
+     */
+    enrich(userId: string, query: string, options?: EnrichOptions): Promise<ChatContext>;
+    /**
+     * AFTER your LLM responds: tell Dreaming to extract memories.
+     *
+     * This queues background tasks: memory extraction, entity detection,
+     * insight generation (goal-aware), and personality evolution.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.chat.learn('user-1', userMessage, aiResponse);
+     * ```
+     */
+    learn(userId: string, userMessage: string, aiResponse: string, options?: LearnOptions): Promise<{
+        learned: boolean;
+        jobsQueued: string[];
+    }>;
+    /**
+     * Full conversation version of learn.
+     */
+    learnFromMessages(userId: string, messages: Array<{
+        role: string;
+        content: string;
+    }>, options?: LearnOptions): Promise<{
+        learned: boolean;
+        jobsQueued: string[];
+    }>;
+    /**
+     * Wrap an OpenAI client call. Memory + personality + goals, one line.
+     *
+     * @example
+     * ```typescript
+     * import OpenAI from 'openai';
+     * const openai = new OpenAI();
+     * const dreaming = new DreamingClient({ ... });
+     *
+     * // This one line gives your GPT memory, personality, and goals:
+     * const reply = await dreaming.chat.wrapOpenAI(openai, 'user-1', [
+     *   { role: 'user', content: 'How should I train today?' }
+     * ], { model: 'gpt-4o' });
+     *
+     * console.log(reply); // Goal-aware, memory-enriched response
+     * ```
+     */
+    wrapOpenAI(openai: any, userId: string, messages: Array<{
+        role: string;
+        content: string;
+    }>, options?: {
+        model?: string;
+        temperature?: number;
+        maxTokens?: number;
+    }): Promise<string>;
+    /**
+     * Wrap a Google Gemini call. Memory + personality + goals, one line.
+     *
+     * @example
+     * ```typescript
+     * import { GoogleGenerativeAI } from '@google/generative-ai';
+     * const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
+     * const dreaming = new DreamingClient({ ... });
+     *
+     * const reply = await dreaming.chat.wrapGemini(genAI, 'user-1',
+     *   'How should I train today?',
+     *   { model: 'gemini-2.0-flash' }
+     * );
+     * ```
+     */
+    wrapGemini(genAI: any, userId: string, userMessage: string, options?: {
+        model?: string;
+        history?: Array<{
+            role: string;
+            parts: Array<{
+                text: string;
+            }>;
+        }>;
+    }): Promise<string>;
+    /**
+     * Wrap an Anthropic Claude call. Memory + personality + goals, one line.
+     *
+     * @example
+     * ```typescript
+     * import Anthropic from '@anthropic-ai/sdk';
+     * const anthropic = new Anthropic();
+     * const dreaming = new DreamingClient({ ... });
+     *
+     * const reply = await dreaming.chat.wrapAnthropic(anthropic, 'user-1', [
+     *   { role: 'user', content: 'How should I train today?' }
+     * ], { model: 'claude-sonnet-4-20250514' });
+     * ```
+     */
+    wrapAnthropic(anthropic: any, userId: string, messages: Array<{
+        role: string;
+        content: string;
+    }>, options?: {
+        model?: string;
+        maxTokens?: number;
+    }): Promise<string>;
+    /**
+     * Generic wrapper for any LLM. You provide the call function.
+     *
+     * @example
+     * ```typescript
+     * const reply = await dreaming.chat.wrap(
+     *   'user-1',
+     *   'How should I train today?',
+     *   async (systemPrompt, userMsg) => {
+     *     // Call your LLM however you want
+     *     return await myCustomLLM.generate(systemPrompt + '\n' + userMsg);
+     *   }
+     * );
+     * ```
+     */
+    wrap(userId: string, userMessage: string, llmCall: (systemPrompt: string, userMessage: string) => Promise<string>, options?: EnrichOptions): Promise<string>;
+}
+/** Constraint types */
+export type ConstraintType = 'goal' | 'sub_goal' | 'task' | 'checkpoint' | 'achievement';
+export type ConstraintStatus = 'active' | 'completed' | 'cancelled' | 'paused' | 'deleted';
+export interface Constraint {
+    id: string;
+    userId: string;
+    appId: string;
+    parentId?: string;
+    constraintType: ConstraintType;
+    title: string;
+    description: string;
+    status: ConstraintStatus;
+    weight: number;
+    priority: number;
+    category: string;
+    domain: string;
+    progress: number;
+    targetValue?: number;
+    currentValue: number;
+    unit: string;
+    deadline?: string;
+    completedAt?: string;
+    cancelledAt?: string;
+    pinned: boolean;
+    createdBy: string;
+    tags?: Array<{
+        tagKey: string;
+        label: string;
+        weight: number;
+        status: string;
+        pinned: boolean;
+    }>;
+    childCount?: number;
+    completedChildren?: number;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ConstraintTag {
+    id: string;
+    userId: string;
+    appId: string;
+    tagKey: string;
+    label: string;
+    category: string;
+    weight: number;
+    status: string;
+    pinned: boolean;
+    source: string;
+    birthReason: string;
+    matchCount: number;
+    constraintCount?: number;
+    createdAt: string;
+}
+export interface ConstraintContext {
+    constraints: Constraint[];
+    tags: ConstraintTag[];
+    contextString: string;
+    totalWeight: number;
+}
+declare class ConstraintClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a goal, sub-goal, task, checkpoint, or achievement.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.constraints.setGoal('user-1', 'Run 5K under 25min', {
+     *   category: 'fitness', weight: 90,
+     *   targetValue: 25, unit: 'min',
+     *   deadline: '2026-06-01',
+     *   tags: ['running', 'cardio'],
+     * });
+     * ```
+     */
+    setGoal(userId: string, title: string, options?: {
+        type?: ConstraintType;
+        parentId?: string;
+        description?: string;
+        weight?: number;
+        priority?: number;
+        category?: string;
+        domain?: string;
+        targetValue?: number;
+        unit?: string;
+        deadline?: string;
+        pinned?: boolean;
+        tags?: string[];
+        metadata?: Record<string, unknown>;
+    }): Promise<Constraint>;
+    /** Create a sub-goal under a parent goal */
+    addSubGoal(userId: string, parentId: string, title: string, options?: Parameters<ConstraintClient['setGoal']>[2]): Promise<Constraint>;
+    /** Create a task under a goal or sub-goal */
+    addTask(userId: string, parentId: string, title: string, options?: Parameters<ConstraintClient['setGoal']>[2]): Promise<Constraint>;
+    /** Create a checkpoint (milestone) */
+    addCheckpoint(userId: string, parentId: string, title: string, options?: Parameters<ConstraintClient['setGoal']>[2]): Promise<Constraint>;
+    /** Record an achievement */
+    addAchievement(userId: string, title: string, options?: Parameters<ConstraintClient['setGoal']>[2]): Promise<Constraint>;
+    /**
+     * List constraints with optional filters.
+     */
+    list(userId: string, options?: {
+        type?: ConstraintType;
+        status?: ConstraintStatus | 'all';
+        category?: string;
+        parentId?: string;
+        pinned?: boolean;
+    }): Promise<Constraint[]>;
+    /**
+     * Update a constraint's weight, status, progress, or other fields.
+     *
+     * @example
+     * ```typescript
+     * // Update progress
+     * await dreaming.constraints.update(goalId, { progress: 75 });
+     *
+     * // Change weight (influences how much AI focuses on this)
+     * await dreaming.constraints.update(goalId, { weight: 30 });
+     *
+     * // Complete a goal
+     * await dreaming.constraints.update(goalId, { status: 'completed' });
+     * ```
+     */
+    update(constraintId: string, updates: {
+        title?: string;
+        description?: string;
+        status?: ConstraintStatus;
+        weight?: number;
+        priority?: number;
+        category?: string;
+        progress?: number;
+        currentValue?: number;
+        targetValue?: number;
+        deadline?: string;
+        pinned?: boolean;
+        reason?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Constraint>;
+    /** Complete a constraint */
+    complete(constraintId: string): Promise<Constraint>;
+    /** Cancel a constraint */
+    cancel(constraintId: string, reason?: string): Promise<Constraint>;
+    /** Pause a constraint (keeps weight but AI won't actively suggest) */
+    pause(constraintId: string): Promise<Constraint>;
+    /** Resume a paused constraint */
+    resume(constraintId: string): Promise<Constraint>;
+    /** Pin a constraint (locks it from fading) */
+    pin(constraintId: string): Promise<Constraint>;
+    /** Unpin a constraint */
+    unpin(constraintId: string): Promise<Constraint>;
+    /** Set the weight (0-100) — how much the AI focuses on this */
+    setWeight(constraintId: string, weight: number, reason?: string): Promise<Constraint>;
+    /** Delete a constraint (soft delete) */
+    delete(constraintId: string): Promise<void>;
+    /** Get change history for a constraint */
+    getHistory(constraintId: string): Promise<Array<{
+        changeType: string;
+        oldValue: string;
+        newValue: string;
+        reason: string;
+        createdAt: string;
+    }>>;
+    /**
+     * Create or update a focus tag.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.constraints.addTag('user-1', 'mindfulness', {
+     *   category: 'wellness', weight: 70, pinned: true,
+     * });
+     * ```
+     */
+    addTag(userId: string, tagKey: string, options?: {
+        label?: string;
+        category?: string;
+        weight?: number;
+        pinned?: boolean;
+        birthReason?: string;
+    }): Promise<ConstraintTag>;
+    /** List tags */
+    listTags(userId: string, options?: {
+        status?: string;
+        category?: string;
+        pinned?: boolean;
+    }): Promise<ConstraintTag[]>;
+    /** Update a tag (weight, pin, category) */
+    updateTag(tagId: string, updates: {
+        weight?: number;
+        pinned?: boolean;
+        status?: string;
+        category?: string;
+        label?: string;
+    }): Promise<ConstraintTag>;
+    /** Pin a tag */
+    pinTag(tagId: string): Promise<ConstraintTag>;
+    /** Set tag weight */
+    setTagWeight(tagId: string, weight: number): Promise<ConstraintTag>;
+    /**
+     * Get the weighted constraint context that the AI uses.
+     * Shows exactly how constraints + tags influence dreaming.
+     */
+    getContext(userId: string): Promise<ConstraintContext>;
+}
+/** A single activity event to track */
+export interface ActivityEvent {
+    userId: string;
+    /** Category of activity: 'screen_view', 'button_click', 'feature_use', 'gesture', etc. */
+    activityType: string;
+    /** Specific name: 'ProductDetail', 'AddToCart', 'SearchQuery', etc. */
+    activityName: string;
+    /** Life domain: 'fitness', 'shopping', 'finance', 'social', etc. */
+    domain?: string;
+    /** Arbitrary data payload */
+    data?: Record<string, unknown>;
+    /** Duration in ms (for timed activities like screen dwell time) */
+    durationMs?: number;
+    /** Session ID (auto-generated if not provided) */
+    sessionId?: string;
+}
+/** Activity summary for a time period */
+export interface ActivitySummary {
+    activityType: string;
+    activityName: string;
+    count: number;
+    totalDurationMs: number;
+    lastAt: string;
+}
+/** Configuration for the activity buffer */
+export interface ActivityBufferConfig {
+    /** Max events to buffer before auto-flush (default: 20) */
+    bufferSize?: number;
+    /** Auto-flush interval in ms (default: 5000 = 5 seconds) */
+    flushIntervalMs?: number;
+    /** Disable auto-flush (for manual control) */
+    disableAutoFlush?: boolean;
+}
+declare class ActivityClient {
+    private http;
+    private buffer;
+    private flushTimer;
+    private sessionId;
+    private bufferSize;
+    private isFlushing;
+    constructor(http: HttpClient, config: DreamingClientConfig & {
+        activityBuffer?: ActivityBufferConfig;
+    });
+    /**
+     * Track a user activity event — SYNCHRONOUS, zero overhead.
+     * Events are queued locally and flushed as a batch automatically.
+     *
+     * @example
+     * ```typescript
+     * // Track a screen view
+     * dreaming.activities.track('user-123', 'screen_view', 'Dashboard');
+     *
+     * // Track a feature interaction with data
+     * dreaming.activities.track('user-123', 'feature_use', 'AIChat', {
+     *   domain: 'productivity',
+     *   data: { messageCount: 5, topic: 'project planning' },
+     *   durationMs: 45000,
+     * });
+     *
+     * // Track a button click
+     * dreaming.activities.track('user-123', 'button_click', 'UpgradeToProBtn', {
+     *   domain: 'billing',
+     * });
+     * ```
+     */
+    track(userId: string, activityType: string, activityName: string, options?: Omit<ActivityEvent, 'userId' | 'activityType' | 'activityName'>): void;
+    /**
+     * Flush buffered events to the server.
+     * Called automatically by the timer/buffer-full, but you can call manually.
+     */
+    flush(): Promise<number>;
+    /**
+     * Query activity history for a user.
+     */
+    getHistory(userId: string, options?: {
+        type?: string;
+        domain?: string;
+        days?: number;
+        limit?: number;
+    }): Promise<{
+        data: ActivityEvent[];
+        summary: ActivitySummary[];
+        total: number;
+    }>;
+    /** Get the current auto-generated session ID */
+    getSessionId(): string;
+    /** Start a new session (generates a new session ID) */
+    newSession(): string;
+    /** Get the number of buffered (unflushed) events */
+    get pendingCount(): number;
+    /** Stop the auto-flush timer (call before app shutdown after flush) */
+    destroy(): void;
+}
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    content: string;
+    description?: string;
+    publishedDate?: string;
+    source: string;
+}
+export interface WebCrawlResult {
+    url: string;
+    content: string;
+    title?: string;
+    description?: string;
+    source: string;
+    length: number;
+}
+export interface WebAccessPolicy {
+    enabled: boolean;
+    maxDailySearches: number;
+    allowedCategories: string[];
+    blockedDomains: string[];
+    requireRelevance: boolean;
+}
+export interface WebDailyUsage {
+    appId: string;
+    date: string;
+    searchCount: number;
+    crawlCount: number;
+    tokensUsed: number;
+}
+declare class WebClient {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Search the web. Respects DNA guardrails (must be enabled for the app).
+     * Results are cached for 24h.
+     *
+     * @example
+     * ```typescript
+     * const results = await dreaming.web.search('5K running tips', {
+     *   appId: 'active365',
+     *   limit: 5,
+     * });
+     * ```
+     */
+    search(query: string, options: {
+        appId: string;
+        limit?: number;
+        format?: 'results' | 'prompt';
+        skipCache?: boolean;
+    }): Promise<WebSearchResult[]>;
+    /**
+     * Search and return formatted system prompt (for direct LLM injection).
+     */
+    searchForPrompt(query: string, appId: string): Promise<string>;
+    /** Crawl a specific URL for content. */
+    crawl(url: string, appId: string): Promise<WebCrawlResult | null>;
+    /** Get the web access policy for an app. */
+    getPolicy(appId: string): Promise<WebAccessPolicy>;
+    /**
+     * Update web access policy.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.web.updatePolicy('active365', {
+     *   enabled: true,
+     *   maxDailySearches: 100,
+     *   blockedDomains: ['facebook.com'],
+     * });
+     * ```
+     */
+    updatePolicy(appId: string, policy: Partial<WebAccessPolicy>): Promise<WebAccessPolicy>;
+    /** Get daily web usage stats for budget monitoring. */
+    getUsage(appId: string, date?: string): Promise<WebDailyUsage>;
+    /** Get user dreaming settings (all toggles). */
+    getSettings(userId: string, appId?: string): Promise<Record<string, boolean>>;
+    /** Update user dreaming settings (toggle features on/off). */
+    updateSettings(userId: string, settings: Record<string, boolean>, appId?: string): Promise<Record<string, boolean>>;
+}
+export interface UserIdentity {
+    userId: string;
+    appId: string;
+    userDisplayName: string;
+    userPreferredName: string;
+    userFullName: string;
+    aiName: string;
+    aiDefaultName: string;
+    source: string;
+    syncToHq: boolean;
+    syncFromHq: boolean;
+    effectiveAiName?: string;
+    effectiveUserName?: string;
+}
+export interface SocialPerson {
+    id: string;
+    userId: string;
+    appId: string;
+    personName: string;
+    relationship: string;
+    relationshipDetail: string;
+    nickname: string;
+    status: string;
+    mentionCount: number;
+    sentiment: number;
+    isCrossApp: boolean;
+    source: string;
+}
+declare class IdentityClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Get user identity (names, AI name, sync status). */
+    get(userId: string, appId?: string): Promise<UserIdentity>;
+    /** Update user identity (display name, preferred name, etc). */
+    update(userId: string, appId: string, updates: Partial<UserIdentity>): Promise<UserIdentity>;
+    /** Get the effective AI name for this user in this app. */
+    getAiName(userId: string, appId?: string): Promise<string>;
+    /** Set a custom AI name (user-chosen or partner default). */
+    setAiName(userId: string, appId: string, aiName: string, isPartnerDefault?: boolean): Promise<string>;
+    /** Get people the user knows (family, friends, colleagues). */
+    getSocialCircle(userId: string, appId?: string, relationship?: string): Promise<SocialPerson[]>;
+    /** Add a person to the user's social circle. */
+    addPerson(userId: string, appId: string, person: {
+        name: string;
+        relationship: string;
+        relationshipDetail?: string;
+        nickname?: string;
+        sentiment?: number;
+    }): Promise<SocialPerson>;
+    /** Sync identity from HQ to a partner app. */
+    syncFromHq(userId: string, appId: string): Promise<UserIdentity>;
+}
+export interface FriendConnection {
+    id: string;
+    user_a_id: string;
+    user_b_id: string;
+    status: string;
+    connection_type: string;
+    trust_level: number;
+    interaction_count: number;
+    friend_user_id?: string;
+    shared_count?: number;
+    exchange_count?: number;
+}
+export interface SharedMemory {
+    id: number;
+    connection_id: string;
+    source_user_id: string;
+    content: string;
+    domain: string;
+    memory_type: string;
+    importance: number;
+}
+declare class FriendsClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Send a friend request. */
+    request(userId: string, friendUserId: string, options?: {
+        connectionType?: string;
+        sharedDomains?: string[];
+        message?: string;
+    }): Promise<FriendConnection>;
+    /** Accept a friend connection. */
+    accept(connectionId: string, options?: {
+        sharedDomains?: string[];
+        autoCommunicate?: boolean;
+    }): Promise<FriendConnection>;
+    /** Reject or block a connection. */
+    reject(connectionId: string, block?: boolean): Promise<void>;
+    /** List all connections for a user. */
+    list(userId: string): Promise<FriendConnection[]>;
+    /** Get connection details. */
+    get(connectionId: string): Promise<FriendConnection>;
+    /** Trigger an AI-to-AI exchange. */
+    exchange(connectionId: string, topic?: string, maxRounds?: number): Promise<{
+        connectionId: string;
+        exchangeRounds: number;
+        exchanges: any[];
+        trustLevel: number;
+    }>;
+    /** Get exchange conversation history. */
+    conversations(connectionId: string, limit?: number): Promise<any[]>;
+    /** Get shared memories for a connection. */
+    sharedMemories(connectionId: string, limit?: number): Promise<SharedMemory[]>;
+    /** Share a specific memory with a friend. */
+    shareMemory(connectionId: string, userId: string, content: string, domain?: string, importance?: number): Promise<SharedMemory>;
+    /** Update connection settings. */
+    update(connectionId: string, settings: {
+        userId?: string;
+        autoCommunicate?: boolean;
+        communicationFreq?: string;
+        connectionType?: string;
+        sharedDomains?: string[];
+    }): Promise<void>;
+}
+export interface ProactiveSuggestion {
+    id: number;
+    userId: string;
+    appId: string;
+    type: string;
+    content: string;
+    priority: number;
+    trigger: string;
+    createdAt: string;
+}
+declare class ProactiveClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Trigger proactive evaluation for a user. */
+    evaluate(userId: string, appId?: string): Promise<{
+        triggered: boolean;
+        suggestion?: ProactiveSuggestion;
+    }>;
+    /** Get pending proactive suggestions. */
+    getSuggestions(userId: string, appId?: string, limit?: number): Promise<ProactiveSuggestion[]>;
+    /** Dismiss a proactive suggestion. */
+    dismiss(suggestionId: number | string): Promise<void>;
+}
+export interface NotificationPrefs {
+    channel: string;
+    pushToken: string;
+    pushPlatform: string;
+    quietStart: string;
+    quietEnd: string;
+    maxDaily: number;
+    enabled: boolean;
+}
+export interface BehaviorSignal {
+    id: number;
+    userId: string;
+    signalType: string;
+    value: number;
+    context: Record<string, unknown>;
+    createdAt: string;
+}
+declare class NotificationsClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Mark notifications as read. */
+    markRead(ids: (number | string)[]): Promise<void>;
+    /** Act on a proactive suggestion. */
+    act(suggestionId: number | string, action: string): Promise<any>;
+    /** Get notification preferences. */
+    getPrefs(userId: string, appId?: string): Promise<NotificationPrefs>;
+    /** Update notification preferences. */
+    updatePrefs(userId: string, prefs: Partial<NotificationPrefs>, appId?: string): Promise<NotificationPrefs>;
+    /** Register a push notification token. */
+    registerPushToken(userId: string, token: string, platform: 'ios' | 'android' | 'web', appId?: string): Promise<void>;
+    /** Get behavior timeline (activity/mood history). */
+    getTimeline(userId: string, options?: {
+        days?: number;
+        limit?: number;
+    }): Promise<any[]>;
+    /** Get behavior signals. */
+    getSignals(userId: string, type?: string): Promise<BehaviorSignal[]>;
+    /** Get behavior summary. */
+    getSummary(userId: string): Promise<any>;
+}
+export interface LifeDomain {
+    id: string;
+    userId: string;
+    name: string;
+    category: string;
+    importance: number;
+    progress: number;
+    status: string;
+}
+export interface AppFeature {
+    id: string;
+    appId: string;
+    featureName: string;
+    category: string;
+    description: string;
+}
+declare class EvolutionClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Track a single activity event. */
+    trackActivity(activity: {
+        userId: string;
+        appId?: string;
+        activityType: string;
+        category?: string;
+        duration?: number;
+        intensity?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<any>;
+    /** Track a batch of activities. */
+    trackBatch(activities: Array<{
+        userId: string;
+        appId?: string;
+        activityType: string;
+        category?: string;
+        duration?: number;
+        metadata?: Record<string, unknown>;
+    }>): Promise<{
+        inserted: number;
+    }>;
+    /** Get activity history. */
+    getActivities(userId: string, options?: {
+        category?: string;
+        limit?: number;
+        days?: number;
+    }): Promise<any[]>;
+    /** Get user's life domains. */
+    getDomains(userId: string): Promise<LifeDomain[]>;
+    /** Create a life domain. */
+    createDomain(domain: {
+        userId: string;
+        name: string;
+        category?: string;
+        importance?: number;
+    }): Promise<LifeDomain>;
+    /** Update domain progress. */
+    updateProgress(domainId: string, progress: number, note?: string): Promise<any>;
+    /** Get domain progress history. */
+    getDomainHistory(domainId: string, limit?: number): Promise<any[]>;
+    /** Register an app feature. */
+    registerFeature(appId: string, feature: {
+        featureName: string;
+        category?: string;
+        description?: string;
+    }): Promise<AppFeature>;
+    /** Emit an app event. */
+    emitEvent(appId: string, event: {
+        eventType: string;
+        userId?: string;
+        payload?: Record<string, unknown>;
+    }): Promise<any>;
+    /** Get app context (features, recent events). */
+    getAppContext(appId: string, userId?: string): Promise<any>;
+    /** Get or set user state (mood, role, context). */
+    getUserState(userId: string): Promise<any>;
+    /** Update user state. */
+    setUserState(userId: string, state: Record<string, unknown>): Promise<any>;
+}
+export interface AppDna {
+    appId: string;
+    appName: string;
+    discipline: string;
+    personaName: string;
+    boundaries: string;
+    defaultDomains: string[];
+    rootKnowledge: string[];
+    webAccess: Record<string, unknown>;
+}
+declare class DnaClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Get app DNA configuration. */
+    get(appId: string): Promise<AppDna>;
+    /** Register or update app DNA. */
+    update(appId: string, dna: Partial<AppDna>): Promise<AppDna>;
+    /** Seed a new user's brain with app defaults. */
+    seedUser(appId: string, userId: string): Promise<any>;
+    /** List all registered apps. */
+    listApps(): Promise<AppDna[]>;
+}
+export interface PartnerToken {
+    id: string;
+    name: string;
+    key: string;
+    status: number;
+    quotaLimit: number;
+    usedQuota: number;
+    expiresAt?: string;
+}
+declare class PartnerTokensClient {
+    private http;
+    constructor(http: HttpClient);
+    /** Create a child token. */
+    create(options: {
+        name: string;
+        quotaLimit?: number;
+        models?: string[];
+        expiresIn?: string;
+        group?: string;
+    }): Promise<PartnerToken>;
+    /** List partner's tokens. */
+    list(): Promise<PartnerToken[]>;
+    /** Revoke a token. */
+    revoke(tokenId: string): Promise<void>;
+    /** Update token settings. */
+    update(tokenId: string, updates: Partial<{
+        quotaLimit: number;
+        group: string;
+        expiresAt: string;
+    }>): Promise<PartnerToken>;
+    /** Get token usage stats. */
+    getUsage(tokenId: string): Promise<any>;
+}
+export default DreamingClient;
+//# sourceMappingURL=index.d.ts.map