/**
 * Core Entity System
 * DO NOT MODIFY THIS FILE - You may break the entity functionality
 *
 * This module provides:
 * - EntityContext: Unified context for all entity operations
 * - EntityClass: Interface that all entity types implement
 * - EntityBase: Base class with instance methods for state management
 * - Entity: Local storage-backed entity class (replaces IndexedEntity)
 */
import type { IntegrationClient } from './core-integrations';
export interface EntityDOStub {
    getDoc<T>(key: string): Promise<{
        v: number;
        data: T;
    } | null>;
    casPut<T>(key: string, expectedV: number, data: T): Promise<{
        ok: boolean;
        v: number;
    }>;
    del(key: string): Promise<boolean>;
    has(key: string): Promise<boolean>;
    bulkCreate(items: Array<{
        key: string;
        data: unknown;
    }>): Promise<Array<{
        key: string;
        v: number;
        data: unknown;
    }>>;
    bulkUpdate(updates: Array<{
        key: string;
        data: Record<string, unknown>;
    }>): Promise<Array<{
        key: string;
        ok: boolean;
        v: number;
        data: unknown;
    }>>;
    bulkDelete(keys: string[]): Promise<number>;
    queryEntities(options?: {
        limit?: number;
        offset?: number;
        cursor?: string | null;
        filters?: Record<string, unknown>;
        search?: {
            query: string;
            fields: string[];
        };
        sort?: {
            field: string;
            order: 'asc' | 'desc';
        };
    }): Promise<{
        items: Array<{
            key: string;
            v: number;
            data: unknown;
        }>;
        total: number;
        hasMore: boolean;
        next: string | null;
    }>;
    countEntities(filters?: Record<string, unknown>): Promise<number>;
    exportAll(): Promise<Array<{
        key: string;
        v: number;
        data: unknown;
    }>>;
    importAll(items: Array<{
        key: string;
        v: number;
        data: unknown;
    }>): Promise<{
        imported: number;
    }>;
}
import type { Env } from './core-utils';
/**
 * EntityContext - Unified context for all entity operations
 * Both Entity and IntegrationEntity use this same context type
 */
export interface EntityContext {
    env: Env;
    client?: IntegrationClient;
}
/**
 * Options for list operations
 */
export interface ListOptions {
    limit?: number;
    offset?: number;
    cursor?: string | null;
    filters?: Record<string, unknown>;
    search?: {
        query: string;
        fields: string[];
    };
    sort?: {
        field: string;
        order: 'asc' | 'desc';
    };
}
/**
 * Paginated result from list operations
 */
export interface PaginatedResult<T> {
    items: T[];
    total: number;
    next: string | null;
    hasMore: boolean;
}
/**
 * EntityClass - Unified interface for ALL entity types
 *
 * Both Entity (local storage) and IntegrationEntity (external API) implement this.
 * All static CRUD methods take ctx as the first parameter for consistency.
 */
export interface EntityClass<T extends {
    id: string;
}> {
    readonly entityName: string;
    readonly schema?: Record<string, unknown>;
    list(ctx: EntityContext, options?: ListOptions): Promise<PaginatedResult<T>>;
    get(ctx: EntityContext, id: string): Promise<T | null>;
    create(ctx: EntityContext, data: Partial<T>): Promise<T>;
    update(ctx: EntityContext, id: string, data: Partial<T>): Promise<T>;
    delete(ctx: EntityContext, id: string): Promise<void>;
}
/**
 * Type-safe entity registry
 * Maps entity names to their class implementations
 */
export declare const entityRegistry: Map<string, EntityClass<{
    id: string;
}>>;
/**
 * Register an entity class with the registry
 */
export declare function registerEntity<T extends {
    id: string;
}>(entityClass: EntityClass<T>): void;
/**
 * Register multiple entity classes at once
 */
export declare function registerEntities(classes: readonly EntityClass<{
    id: string;
}>[]): void;
export type Doc<T> = {
    v: number;
    data: T;
};
export interface EntityStatics<S, T extends EntityBase<S>> {
    new (env: Env, id: string): T;
    readonly entityName: string;
    readonly initialState: S;
}
/**
 * EntityBase - Internal base class with instance methods for state management
 *
 * Provides CAS-based (Compare-And-Swap) state mutations for optimistic concurrency.
 * Extended by Entity class which adds static CRUD methods.
 */
export declare abstract class EntityBase<State> {
    protected _state: State;
    protected _version: number;
    protected readonly stub: EntityDOStub;
    protected readonly _id: string;
    protected readonly entityName: string;
    protected readonly env: Env;
    constructor(env: Env, id: string);
    get id(): string;
    get state(): State;
    protected key(): string;
    save(next: State): Promise<void>;
    protected ensureState(): Promise<State>;
    mutate(updater: (current: State) => State): Promise<State>;
    getState(): Promise<State>;
    patch(p: Partial<State>): Promise<void>;
    exists(): Promise<boolean>;
    delete(): Promise<boolean>;
}
type EntityState<T> = T extends new (env: Env, id: string) => Entity<infer S> ? S : never;
type EntityCtor = new (env: Env, id: string) => Entity<{
    id: string;
}>;
type EntityCtorStatic<TCtor> = TCtor & {
    entityName: string;
    keyOf(state: EntityState<TCtor>): string;
    seedData?: ReadonlyArray<EntityState<TCtor>>;
};
/**
 * Entity - Local storage-backed entity class
 *
 * Implements the unified EntityClass interface for local DO-backed storage.
 * All methods take EntityContext as the first parameter.
 *
 * @example
 * ```typescript
 * export class TodoEntity extends Entity<Todo> {
 *   static readonly entityName = 'Todo';
 *   static readonly initialState: Todo = { id: '', title: '', completed: false };
 * }
 *
 * // Usage:
 * const ctx = { env };
 * const todos = await TodoEntity.list(ctx, { limit: 50 });
 * const todo = await TodoEntity.get(ctx, 'todo-123');
 * await TodoEntity.create(ctx, { title: 'New task' });
 * ```
 */
export declare abstract class Entity<S extends {
    id: string;
}> extends EntityBase<S> {
    static readonly entityName: string;
    static readonly schema?: Record<string, unknown>;
    static keyOf<U extends {
        id: string;
    }>(state: U): string;
    /**
     * List entities with server-side filtering, search, sort, and pagination.
     * All query operations run in SQL via EntityDO.queryEntities().
     */
    static list<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext, options?: ListOptions): Promise<PaginatedResult<EntityState<TCtor>>>;
    /**
     * Get a single entity by ID
     */
    static get<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext, id: string): Promise<EntityState<TCtor> | null>;
    /**
     * Count entities with optional filters
     */
    static count<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext, filters?: Record<string, unknown>): Promise<number>;
    /**
     * Create a new entity
     */
    static create<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext, data: Partial<EntityState<TCtor>>): Promise<EntityState<TCtor>>;
    /**
     * Update an existing entity (throws if missing)
     */
    static update<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext, id: string, data: Partial<EntityState<TCtor>>): Promise<EntityState<TCtor>>;
    /**
     * Delete an entity
     */
    static delete<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext, id: string): Promise<void>;
    /**
     * Ensure seed data exists (for initial data population)
     */
    static ensureSeed<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext): Promise<void>;
    /**
     * Create multiple entities in a single RPC call to the DO.
     * Generates UUIDs for items without an id. Returns all created items.
     */
    static createMany<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext, dataArray: Partial<EntityState<TCtor>>[]): Promise<EntityState<TCtor>[]>;
    /**
     * Update multiple entities in a single RPC call to the DO.
     * Each update must include an id. Throws if any items are not found.
     */
    static updateMany<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext, updates: (Partial<EntityState<TCtor>> & {
        id: string;
    })[]): Promise<EntityState<TCtor>[]>;
    /**
     * Delete multiple entities in a single RPC call to the DO.
     * Returns the count of items that actually existed and were deleted.
     */
    static deleteMany<TCtor extends EntityCtor>(this: EntityCtorStatic<TCtor>, ctx: EntityContext, ids: string[]): Promise<number>;
    protected ensureState(): Promise<S>;
}
import type { Hono } from 'hono';
/**
 * Mount entity routes on the Hono app
 * Provides internal API for entity CRUD from workspace (cross-app operations)
 */
export declare function entityRoutes(app: Hono<{
    Bindings: Env;
}>): void;
export {};