import type { Transferable } from '../types/transferable';
declare type SerializedObject = {
    [_: string]: Serialized;
};
export declare type Serialized = null | void | boolean | number | string | Boolean | Number | String | Date | RegExp | ArrayBuffer | ArrayBufferView | ImageData | Array<Serialized> | SerializedObject;
declare type RegisterOptions<T> = {
    omit?: ReadonlyArray<keyof T>;
    shallow?: ReadonlyArray<keyof T>;
};
/**
 * Register the given class as serializable.
 *
 * @param options
 * @param options.omit List of properties to omit from serialization (e.g., cached/computed properties)
 * @param options.shallow List of properties that should be serialized by a simple shallow copy, rather than by a recursive call to serialize().
 *
 * @private
 */
export declare function register<T extends any>(name: string, klass: {
    new (...args: any): T;
}, options?: RegisterOptions<T>): void;
/**
 * Serialize the given object for transfer to or from a web worker.
 *
 * For non-builtin types, recursively serialize each property (possibly
 * omitting certain properties - see register()), and package the result along
 * with the constructor's `name` so that the appropriate constructor can be
 * looked up in `deserialize()`.
 *
 * If a `transferables` array is provided, add any transferable objects (i.e.,
 * any ArrayBuffers or ArrayBuffer views) to the list. (If a copy is needed,
 * this should happen in the client code, before using serialize().)
 *
 * @private
 */
export declare function serialize(input: unknown, transferables?: Array<Transferable> | null): Serialized;
export declare function deserialize(input: Serialized): unknown;
export {};
//# sourceMappingURL=web_worker_transfer.d.ts.map