import { SerializableClass, Serializable } from './internals/serializable.js';
import { AnyConstructable, ClassConstructor, NamedFunction, AnyFn } from './internals/types.js';

/**
 * Copyright 2025 © BeeAI a Series of LF Projects, LLC
 * SPDX-License-Identifier: Apache-2.0
 */

declare const SerializerSelfRefIdentifier = "__self_ref";
declare const SerializerRefIdentifier = "__ref";
declare class ClassConstructorPlaceholder {
}
declare class RefPlaceholder<T = unknown> {
    protected readonly node: SerializerNode;
    protected readonly factory: SerializeFactory<T>;
    private static EmptyPlaceholder;
    private partialResult;
    constructor(node: SerializerNode, factory: SerializeFactory<T>);
    get value(): T;
    get rawValue(): unknown;
    final(): Promise<T>;
}
interface SerializerNode {
    __class: string;
    __ref: string;
    __value: unknown;
    __serializer: true;
}
declare function isSerializerNode(data: unknown): data is SerializerNode;
interface RootNode<T = any> {
    __version: string;
    __root: T;
}
declare function isRootNode<T>(data: unknown): data is RootNode<T>;
declare const extractClassName: (value: unknown) => string;
declare function primitiveToSerializableClass(value: unknown): SymbolConstructor | ObjectConstructor | FunctionConstructor | BooleanConstructor | StringConstructor | NumberConstructor | BigIntConstructor | {
    new (): {};
} | {
    new (): {};
};
type TraverseObjectFn = (el: {
    key: string;
    path: readonly string[];
    value: any;
}) => Promise<void>;
declare function traverseObject(obj: unknown, handler: TraverseObjectFn, stopFn?: (_obj: unknown) => boolean): Promise<void>;
declare function isSerializationRequired(factory: ClassConstructor | NamedFunction): boolean;
declare function traverseWithUpdate<T = unknown>(_obj: unknown): Generator<{
    value: T;
    update: (value: T) => void;
}>;
declare function shallowCopy<T>(value: T): T;
declare function deepCopy<T>(source: T): Promise<T>;
type Bounded = {
    name: string;
    value: any;
} | AnyConstructable;
declare function toBoundedFunction<T extends AnyFn>(fn: T, binds: [Bounded, ...Bounded[]]): T;
declare namespace toBoundedFunction {
    var symbol: symbol;
}
declare function getFunctionBinds<T extends Function>(fn: T): Bounded[];

/**
 * Copyright 2025 © BeeAI a Series of LF Projects, LLC
 * SPDX-License-Identifier: Apache-2.0
 */

declare function isFunctionDeserializationAllowed(): boolean;
interface SerializeFactory<A = unknown, B = unknown> {
    ref: ClassConstructor<A> | NamedFunction<A>;
    createEmpty?: () => A;
    updateInstance?: (instance: A, update: A) => void | Promise<void>;
    toPlain: (value: A) => B | Promise<B>;
    fromPlain: (value: B, ref: ClassConstructor<A> | NamedFunction<A>) => A | Promise<A>;
}
declare class Serializer {
    private static factories;
    static registerSerializable<A>(ref: SerializableClass<A>, processors?: Partial<Omit<SerializeFactory<Serializable<A>, A>, "ref">>, aliases?: string[]): void;
    static deregister(ref: ClassConstructor | NamedFunction): void;
    static register<A, B = unknown>(ref: ClassConstructor<A> | NamedFunction<A>, processors: Omit<SerializeFactory<A, B>, "ref">, aliases?: string[]): void;
    static getFactory(clsName: string): SerializeFactory;
    static findFactory(value: unknown): {
        targetClass: string;
        factory: SerializeFactory<unknown, unknown>;
        isSelfRef: boolean;
    } | {
        targetClass: string;
        factory: SerializeFactory<any, any>;
        isSelfRef: boolean;
    };
    static hasFactory(clsName: string): boolean;
    static serialize<T>(rawData: T): Promise<string>;
    /** @internal */
    static deserializeWithMeta<T = any>(raw: string, extraClasses?: SerializableClass<unknown>[], keepPlain?: boolean, options?: {
        allowFunctionDeserialization?: boolean;
    }): Promise<RootNode<T>>;
    private static _deserializeWithMetaInner;
    static deserialize<T = any>(raw: string, extraClasses?: SerializableClass<unknown>[], keepPlain?: boolean, options?: {
        allowFunctionDeserialization?: boolean;
    }): Promise<T>;
    protected static _createOutputBuilder<T>(): {
        _container: T;
        get(): T;
        update(path: readonly string[], value: any): void;
        toJSON(): string;
    };
}

export { ClassConstructorPlaceholder as C, RefPlaceholder as R, type SerializeFactory as S, Serializer as a, type RootNode as b, type SerializerNode as c, SerializerRefIdentifier as d, SerializerSelfRefIdentifier as e, deepCopy as f, extractClassName as g, getFunctionBinds as h, isFunctionDeserializationAllowed as i, isRootNode as j, isSerializationRequired as k, isSerializerNode as l, traverseObject as m, traverseWithUpdate as n, primitiveToSerializableClass as p, shallowCopy as s, toBoundedFunction as t };