import type { EntityHistoryRecord, EntityListParams, EntityListResult, EntityQueryRequest } from "../../types.js";
import type { GConstructor, EntityServerClientBase } from "../../client/base.js";
export declare function EntityMixin<TBase extends GConstructor<EntityServerClientBase>>(Base: TBase): {
    new (...args: any[]): {
        /**
         * 트랜잭션을 시작하고 활성 트랜잭션 ID를 저장합니다.
         *
         * 인증은 반드시 붙여야 합니다(기본값 withAuth=true). 여기에 false 를 주면 HMAC 서명도
         * Bearer 토큰도 붙지 않아 ES 가 401 로 거절합니다 — 커밋·롤백과 같은 조건이어야 합니다.
         */
        transStart(): Promise<string>;
        /** 활성 트랜잭션(또는 전달된 transactionId)을 롤백합니다. */
        transRollback(transactionId?: string): Promise<{
            ok: boolean;
        }>;
        /**
         * 활성 트랜잭션(또는 전달된 transactionId)을 커밋합니다.
         *
         * @returns `results` 배열: commit된 각 작업의 `entity`, `action`, `seq`
         */
        transCommit(transactionId?: string): Promise<{
            ok: boolean;
            results: Array<{
                entity: string;
                action: string;
                seq: number;
            }>;
        }>;
        /** 엔티티 설정 메타데이터를 조회합니다. */
        meta<T = unknown>(entity: string): Promise<{
            ok: boolean;
            data: T;
        }>;
        /** 엔티티 데이터를 저장 없이 검증합니다. */
        validate<T = unknown>(entity: string, data: Record<string, unknown>): Promise<T>;
        /** 시퀀스 ID로 엔티티 단건을 조회합니다. */
        get<T = unknown>(entity: string, seq: number, opts?: {
            skipHooks?: boolean;
        }): Promise<{
            ok: boolean;
            data: T;
        }>;
        /** 조건으로 엔티티 단건을 조회합니다. data 컬럼을 완전히 복호화하여 반환합니다. */
        find<T = unknown>(entity: string, conditions?: Record<string, unknown>, opts?: {
            skipHooks?: boolean;
        }): Promise<{
            ok: boolean;
            data: T;
        }>;
        /** 페이지네이션/정렬/필터 조건으로 엔티티 목록을 조회합니다. */
        list<T = unknown>(entity: string, params?: EntityListParams): Promise<{
            ok: boolean;
            data: EntityListResult<T>;
        }>;
        /**
         * 엔티티 총 건수를 조회합니다.
         *
         * @param conditions 필터 조건 (예: `{ status: "active" }`)
         */
        count(entity: string, conditions?: Record<string, unknown>): Promise<{
            ok: boolean;
            count: number;
        }>;
        /**
         * 커스텀 SQL로 엔티티를 조회합니다.
         *
         * SELECT 전용이며 인덱스 테이블만 조회 가능합니다. JOIN 지원.
         */
        query<T = unknown>(entity: string, req: EntityQueryRequest): Promise<{
            ok: boolean;
            data: {
                items: T[];
                count: number;
            };
        }>;
        /** 엔티티 데이터를 생성/수정(Submit)합니다. `seq`가 없으면 INSERT, 있으면 UPDATE입니다. */
        submit(entity: string, data: Record<string, unknown>, opts?: {
            transactionId?: string;
            skipHooks?: boolean;
        }): Promise<{
            ok: boolean;
            seq: number;
        }>;
        /** 시퀀스 ID로 엔티티를 삭제합니다(`hard=true`면 하드 삭제, 기본은 소프트 삭제). */
        delete(entity: string, seq: number, opts?: {
            transactionId?: string;
            hard?: boolean;
            skipHooks?: boolean;
        }): Promise<{
            ok: boolean;
            deleted: number;
        }>;
        /** 엔티티 단건의 변경 이력을 조회합니다. */
        history<T = unknown>(entity: string, seq: number, params?: Pick<EntityListParams, "page" | "limit">): Promise<{
            ok: boolean;
            data: EntityListResult<EntityHistoryRecord<T>>;
        }>;
        /** 특정 이력 시점으로 엔티티를 롤백합니다. */
        rollback(entity: string, historySeq: number): Promise<{
            ok: boolean;
        }>;
        baseUrl: string;
        token: string;
        anonymousPacketToken: string;
        apiKey: string;
        hmacSecret: string;
        encryptRequests: boolean;
        debugPlainSecret: string;
        csrfEnabled: boolean;
        csrfHeaderName: string;
        csrfCookieName: string;
        csrfRefresher: (() => Promise<void>) | null;
        requestAbortControllers: Map<string, AbortController>;
        activeTxId: string | null;
        initialHealthFired: boolean;
        keepSession: boolean;
        refreshBuffer: number;
        onTokenRefreshed?: (accessToken: string, expiresIn: number) => void;
        onSessionExpired?: (error: Error) => void;
        onHealthChange?: (online: boolean) => void;
        sessionRefreshToken: string | null;
        refreshTimer: ReturnType<typeof setTimeout> | null;
        healthTickTimer: ReturnType<typeof setInterval> | null;
        healthTickPromise: Promise<unknown> | null;
        realtimeEnabled: boolean;
        realtimePath: string;
        realtimeAutoReconnect: boolean;
        realtimeReconnectDelayMs: number;
        realtimeStatus: import("../../types.js").RealtimeConnectionStatus;
        realtimeSocket: WebSocket | null;
        realtimeConnectPromise: Promise<void> | null;
        realtimeReconnectTimer: ReturnType<typeof setTimeout> | null;
        realtimeShouldReconnect: boolean;
        realtimeMessageListeners: Set<import("../../types.js").RealtimeMessageListener>;
        realtimeStatusListeners: Set<import("../../types.js").RealtimeStatusListener>;
        realtimeEventListeners: Map<string, Set<import("../../types.js").RealtimeMessageListener>>;
        configure(options: Partial<import("../../types.js").EntityServerClientOptions>): void;
        fireInitialHealth(): void;
        setToken(token: string): void;
        setAccessTokenFromResponse(token: string): void;
        syncRealtimeWithToken(): void;
        setAnonymousPacketToken(token: string): void;
        setApiKey(apiKey: string): void;
        setHmacSecret(secret: string): void;
        setEncryptRequests(value: boolean): void;
        setCsrfEnabled(enabled: boolean): void;
        addRealtimeListener(listener: import("../../types.js").RealtimeMessageListener): void;
        removeRealtimeListener(listener: import("../../types.js").RealtimeMessageListener): void;
        addRealtimeStatusListener(listener: import("../../types.js").RealtimeStatusListener): void;
        removeRealtimeStatusListener(listener: import("../../types.js").RealtimeStatusListener): void;
        addRealtimeEventListener(eventName: string, listener: import("../../types.js").RealtimeMessageListener): void;
        removeRealtimeEventListener(eventName: string, listener: import("../../types.js").RealtimeMessageListener): void;
        connectRealtime(): Promise<void>;
        disconnectRealtime(reason?: string): void;
        sendRealtime(message: import("../../types.js").RealtimeEnvelope | Record<string, unknown>): boolean;
        subscribeRealtime(subscriptions: string[]): boolean;
        unsubscribeRealtime(subscriptions: string[]): boolean;
        startHealthTick(intervalMs?: number, runImmediately?: boolean): void;
        stopHealthTick(): void;
        scheduleKeepSession(refreshToken: string, expiresIn: number, refreshFn: (rt: string) => Promise<{
            access_token: string;
            expires_in: number;
        }>): void;
        clearRefreshTimer(): void;
        stopKeepSession(): void;
        applyRealtimeOptions(options?: boolean | import("../../types.js").RealtimeClientOptions): void;
        buildRealtimeUrl(): string;
        handleRealtimeMessage(payload: unknown): void;
        scheduleRealtimeReconnect(reason: string): void;
        clearRealtimeReconnectTimer(): void;
        setRealtimeStatus(status: import("../../types.js").RealtimeConnectionStatus, reason?: string, error?: Error): void;
        applyCsrfHealth(): void;
        readRequestBody<T = Record<string, unknown>>(body: ArrayBuffer | Uint8Array | string | T | null | undefined, contentType?: string, requireEncrypted?: boolean): T;
        get reqOpts(): import("../../client/request.js").RequestOptions;
        prepareRequest(_withAuth: boolean): Promise<void>;
        get http(): {
            get<T>(path: string, withAuth?: boolean, extraHeaders?: Record<string, string>, requestConfig?: import("../../client/request.js").EntityRequestConfig): Promise<T>;
            post<T>(path: string, body?: unknown, withAuth?: boolean, extraHeaders?: Record<string, string>, requestConfig?: import("../../client/request.js").EntityRequestConfig): Promise<T>;
            put<T>(path: string, body?: unknown, withAuth?: boolean, extraHeaders?: Record<string, string>, requestConfig?: import("../../client/request.js").EntityRequestConfig): Promise<T>;
            patch<T>(path: string, body?: unknown, withAuth?: boolean, extraHeaders?: Record<string, string>, requestConfig?: import("../../client/request.js").EntityRequestConfig): Promise<T>;
            delete<T>(path: string, body?: unknown, withAuth?: boolean, extraHeaders?: Record<string, string>, requestConfig?: import("../../client/request.js").EntityRequestConfig): Promise<T>;
        };
        request<T>(method: string, path: string, body?: unknown, withAuth?: boolean, extraHeaders?: Record<string, string>, requestConfig?: import("../../client/request.js").EntityRequestConfig): Promise<T>;
        requestBinary(method: string, path: string, body?: unknown, withAuth?: boolean): Promise<ArrayBuffer>;
        requestForm<T>(method: string, path: string, form: FormData, withAuth?: boolean, onUploadProgress?: (loaded: number, total: number) => void): Promise<T>;
        requestFormBinary(method: string, path: string, form: FormData, withAuth?: boolean): Promise<ArrayBuffer>;
    };
} & TBase;