export function encodePrefix(K: any, prefix: any): any;
/**
 * @interface
 * @typedef {IAny[]} _IAnyArray
 */
export class IEncodable {
    /**
     * @param {decoding.Decoder} _decoder
     * @return {IEncodable}
     */
    static decode(_decoder: decoding.Decoder): IEncodable;
    /**
     * @param {...any} _args
     */
    constructor(..._args: any[]);
    /**
     * @param {encoding.Encoder} _encoder
     */
    encode(_encoder: encoding.Encoder): void;
}
/**
 * @typedef {IEncodable} IEncodableKey
 * @property {function(...any):Uint8Array} [prefix]
 */
/**
 * @template {IAny} V
 * @implements IEncodable
 */
export class AnyValue<V extends IAny> implements IEncodable {
    /**
     * @param {decoding.Decoder} decoder
     * @return {AnyValue<any>}
     */
    static decode(decoder: decoding.Decoder): AnyValue<any>;
    /**
     * @param {V} v
     */
    constructor(v: V);
    v: V;
    /**
     * @param {encoding.Encoder} encoder
     */
    encode(encoder: encoding.Encoder): void;
}
/**
 * @implements IEncodable
 */
export class NoValue implements IEncodable {
    /**
     * @param {decoding.Decoder} _decoder
     * @return {NoValue}
     */
    static decode(_decoder: decoding.Decoder): NoValue;
    /**
     * @param {null} v
     */
    constructor(v: null);
    v: any;
    /**
     * @param {encoding.Encoder} _encoder
     */
    encode(_encoder: encoding.Encoder): void;
}
/**
 * @implements IEncodable
 */
export class CryptoKeyValue implements IEncodable {
    /**
     * @param {decoding.Decoder} decoder
     * @return {Promise<CryptoKeyValue>}
     */
    static decode(decoder: decoding.Decoder): Promise<CryptoKeyValue>;
    /**
     * @param {CryptoKey} key
     */
    constructor(key: CryptoKey);
    key: CryptoKey;
    /**
     * @param {encoding.Encoder} _encoder
     */
    encode(_encoder: encoding.Encoder): void;
}
/**
 * @implements IEncodable
 */
export class AutoKey implements IEncodable {
    /**
     * @param {decoding.Decoder} decoder
     * @return {IEncodable}
     */
    static decode(decoder: decoding.Decoder): IEncodable;
    /**
     * @param {number} v
     */
    constructor(v: number);
    v: number;
    /**
     * @param {encoding.Encoder} encoder
     */
    encode(encoder: encoding.Encoder): void;
}
/**
 * @implements IEncodable
 */
export class Uint32Key implements IEncodable {
    /**
     * @param {decoding.Decoder} decoder
     * @return {IEncodable}
     */
    static decode(decoder: decoding.Decoder): IEncodable;
    /**
     * @param {number} v
     */
    constructor(v: number);
    v: number;
    /**
     * @param {encoding.Encoder} encoder
     */
    encode(encoder: encoding.Encoder): void;
}
/**
 * Note that this implementation should be polyfilled by node.js/browser.js. This is just an
 * implementation that works exactly like the native implementation (however, it's quite
 * inefficient).
 *
 * @implements IEncodableKey
 */
export class BinaryKey implements IEncodableKey {
    /**
     * @param {decoding.Decoder} decoder
     * @return {IEncodable}
     */
    static decode(decoder: decoding.Decoder): IEncodable;
    /**
     * @param {Uint8Array} prefix
     */
    static prefix(prefix: Uint8Array): Uint8Array;
    /**
     * @param {Uint8Array} v
     */
    constructor(v: Uint8Array);
    v: Uint8Array;
    /**
     * @param {encoding.Encoder} encoder
     */
    encode(encoder: encoding.Encoder): void;
}
/**
 * @implements IEncodable
 */
export class StringKey implements IEncodable {
    /**
     * @param {decoding.Decoder} decoder
     * @return {IEncodable}
     */
    static decode(decoder: decoding.Decoder): IEncodable;
    /**
     * @param {string} prefix
     */
    static prefix(prefix: string): Uint8Array;
    /**
     * @param {string} v
     */
    constructor(v: string);
    v: string;
    /**
     * @param {encoding.Encoder} encoder
     */
    encode(encoder: encoding.Encoder): void;
}
/**
 * @implements IEncodable
 */
export class StringValue implements IEncodable {
    /**
     * @param {decoding.Decoder} decoder
     * @return {IEncodable}
     */
    static decode(decoder: decoding.Decoder): IEncodable;
    /**
     * @param {string} v
     */
    constructor(v: string);
    v: string;
    /**
     * @param {encoding.Encoder} encoder
     */
    encode(encoder: encoding.Encoder): void;
}
/**
 * @template { { iat: number } } PAYLOAD
 * @template {any} [HEADER=any]
 *
 * @todo could implement check verifying that this is indeed a jwt string. If so, we can use binary
 * encoding and also support hashes.
 * @implements IEncodable
 */
export class JwtValue<PAYLOAD extends {
    iat: number;
}, HEADER extends unknown = any> extends StringValue implements IEncodable {
    /**
     * @param {string} v
     */
    constructor(v: string);
    /**
     * @param {CryptoKey} publicKey
     * @return {Promise<{ header: HEADER, payload: PAYLOAD }>}
     */
    verify(publicKey: CryptoKey): Promise<{
        header: HEADER;
        payload: PAYLOAD;
    }>;
    /**
     * Decode the value without verifying it.
     * @return { { header: HEADER, payload: PAYLOAD } }
     */
    unsafeDecode(): {
        header: HEADER;
        payload: PAYLOAD;
    };
}
/**
 * @template {typeof IEncodable} KEY
 * @template {typeof IEncodable} VALUE
 * @template {typeof IEncodable} MKEY
 *
 * @typedef {Object} ITableIndex
 * @property {MKEY} ITableIndex.key
 * @property {function(InstanceType<KEY>,InstanceType<VALUE>):InstanceType<MKEY>} ITableIndex.mapper
 */
/**
 * @template {typeof IEncodable} KEY
 * @template {typeof IEncodable} VALUE
 *
 * @typedef {Object} ITableDef
 * @property {KEY} ITableDef.key
 * @property {VALUE} ITableDef.value
 * @property {{[key: string]: ITableIndex<KEY,VALUE,any>}} [ITableDef.indexes]
 */
/**
 * @template {typeof IEncodable} VAL
 *
 * @typedef {{ [key: string]: VAL }} IObjectDef
 */
/**
 * @typedef {Object} IDbDef
 * @property {{ [key: string]: ITableDef<any,any> }} [IDbDef.tables]
 * @property {{ [key: string]: IObjectDef<any> }} [IDbDef.objects]
 */
/**
 * @template {typeof IEncodable} KEY
 *
 * @typedef {Object} StartEndRangeOption
 * @property {InstanceType<KEY>|FirstKeyParam<KEY>} [start]
 * @property {boolean} [startExclusive]
 * @property {InstanceType<KEY>|FirstKeyParam<KEY>} [end]
 * @property {boolean} [endExclusive]
 * @property {boolean} [reverse]
 * @property {number} [limit] Number of items to receive
 */
/**
 * @template {typeof IEncodable} KEY
 *
 * @typedef {Object} PrefixedRangeOption
 * @property {KeyPrefixArg<KEY>} PrefixedRangeOption.prefix
 * @property {boolean} [reverse]
 * @property {number} [limit] Number of items to receive
 */
/**
 * @template {typeof IEncodable} KEY
 *
 * @typedef {PrefixedRangeOption<KEY>|StartEndRangeOption<KEY>} RangeOption
 */
/**
 * @template {IEncodable} KEY
 * @template {IEncodable} VALUE
 * @template {IEncodable|undefined} FKEY
 *
 * @interface
 * @typedef {Object} ICursor
 * @property {KEY} ICursor.key
 * @property {VALUE} ICursor.value
 * @property {FKEY} ICursor.fkey
 * @property {function():void} stop
 */
/**
 * @template {typeof IEncodable} KEY
 * @template {typeof IEncodable} VALUE
 * @template {{[key: string]: ITableIndex<any, any, any>}} INDEX
 * @template {IEncodable | undefined} FKEY
 *
 * @interface
 */
export class ITableReadonly<KEY extends typeof IEncodable, VALUE extends typeof IEncodable, INDEX extends {
    [key: string]: ITableIndex<any, any, any>;
}, FKEY extends IEncodable | undefined> {
    /**
     * @type {{ [Indexname in keyof INDEX]: IndexedTableReadonly<INDEX[Indexname]["key"], VALUE, KEY, {}> }}
     */
    indexes: { [Indexname in keyof INDEX]: IndexedTableReadonly<INDEX[Indexname]["key"], VALUE, KEY, {}>; };
    /**
     * @param {InstanceType<KEY>|FirstKeyParam<KEY>} _key
     * @return {Promise<InstanceType<VALUE>|null>}
     */
    get(_key: InstanceType<KEY> | FirstKeyParam<KEY>): Promise<InstanceType<VALUE> | null>;
    /**
     * @param {RangeOption<KEY>} [_range]
     * @return {Promise<Array<{ key: InstanceType<KEY>, value: InstanceType<VALUE>, fkey: FKEY }>>}
     */
    getEntries(_range?: RangeOption<KEY> | undefined): Promise<Array<{
        key: InstanceType<KEY>;
        value: InstanceType<VALUE>;
        fkey: FKEY;
    }>>;
    /**
     * @param {RangeOption<KEY>} [_range]
     * @return {Promise<Array<InstanceType<VALUE>>>}
     */
    getValues(_range?: RangeOption<KEY> | undefined): Promise<Array<InstanceType<VALUE>>>;
    /**
     * @param {RangeOption<KEY>} [_range]
     * @return {Promise<Array<InstanceType<KEY>>>}
     */
    getKeys(_range?: RangeOption<KEY> | undefined): Promise<Array<InstanceType<KEY>>>;
    /**
     * @param {RangeOption<KEY>} _range
     * @param {function(ICursor<InstanceType<KEY>,InstanceType<VALUE>,FKEY>):void|Promise<void>} _f
     * @return {Promise<void>}
     */
    iterate(_range: RangeOption<KEY>, _f: (arg0: ICursor<InstanceType<KEY>, InstanceType<VALUE>, FKEY>) => void | Promise<void>): Promise<void>;
}
/**
 * @template {typeof IEncodable} KEY
 * @template {typeof IEncodable} VALUE
 * @template {{[key: string]: ITableIndex<KEY,VALUE,any>}} INDEX
 * @template {IEncodable|undefined} FKEY
 *
 * @interface
 * @extends ITableReadonly<KEY,VALUE,INDEX,FKEY>
 */
export class ITable<KEY extends typeof IEncodable, VALUE extends typeof IEncodable, INDEX extends {
    [key: string]: ITableIndex<KEY, VALUE, any>;
}, FKEY extends IEncodable | undefined> extends ITableReadonly<KEY, VALUE, INDEX, FKEY> {
    constructor();
    /**
     * @type {{ [Indexname in keyof INDEX]: IndexedTable<INDEX[Indexname]["key"], VALUE, KEY, {}> }}
     */
    indexes: { [Indexname in keyof INDEX]: IndexedTable<INDEX[Indexname]["key"], VALUE, KEY, {}>; };
    /**
     * @param {InstanceType<KEY>|FirstKeyParam<KEY>} _key
     * @param {InstanceType<VALUE>|FirstKeyParam<VALUE>} _value
     */
    set(_key: InstanceType<KEY> | FirstKeyParam<KEY>, _value: InstanceType<VALUE> | FirstKeyParam<VALUE>): void;
    /**
     * Only works with AutoKey
     *
     * @param {InstanceType<VALUE>|FirstKeyParam<VALUE>} _value
     * @return {Promise<InstanceType<KEY>>}
     */
    add(_value: InstanceType<VALUE> | FirstKeyParam<VALUE>): Promise<InstanceType<KEY>>;
    /**
     * @param {InstanceType<KEY>|FirstKeyParam<KEY>} _key
     * @return {Promise<void>}
     */
    remove(_key: InstanceType<KEY> | FirstKeyParam<KEY>): Promise<void>;
    /**
     * @param {RangeOption<KEY>} _range
     * @return {Promise<void>}
     */
    removeRange(_range: RangeOption<KEY>): Promise<void>;
}
/**
 * @todo move to utils. dont export via common
 * @todo rename MKEY to FKEY and change the order
 *
 * @template {typeof IEncodable} MKEY
 * @template {typeof IEncodable} VALUE
 * @template {typeof IEncodable} KEY
 * @template {{[key: string]: ITableIndex<any, any, any>}} INDEX
 *
 * @implements ITableReadonly<MKEY,VALUE,INDEX,InstanceType<KEY>>
 */
export class IndexedTableReadonly<MKEY extends typeof IEncodable, VALUE extends typeof IEncodable, KEY extends typeof IEncodable, INDEX extends {
    [key: string]: ITableIndex<any, any, any>;
}> implements ITableReadonly<MKEY, VALUE, INDEX, InstanceType<KEY>> {
    /**
     * @param {ITable<MKEY,KEY,INDEX,undefined>} t
     * @param {ITable<KEY,VALUE,INDEX,undefined>} source
     * @param {ITableIndex<any,any,any>} def
     */
    constructor(t: ITable<MKEY, KEY, INDEX, undefined>, source: ITable<KEY, VALUE, INDEX, undefined>, def: ITableIndex<any, any, any>);
    t: ITable<MKEY, KEY, INDEX, undefined>;
    source: ITable<KEY, VALUE, INDEX, undefined>;
    indexDef: ITableIndex<any, any, any>;
    /**
     * @type {{ [Indexname in keyof INDEX]: IndexedTableReadonly<INDEX[Indexname]["key"],VALUE,MKEY,{}> }}
     */
    indexes: { [Indexname in keyof INDEX]: IndexedTableReadonly<INDEX[Indexname]["key"], VALUE, MKEY, {}>; };
    /**
     * @param {InstanceType<MKEY>|FirstKeyParam<MKEY>} mkey
     * @return {Promise<InstanceType<VALUE>|null>}
     */
    get(mkey: InstanceType<MKEY> | FirstKeyParam<MKEY>): Promise<InstanceType<VALUE> | null>;
    /**
     * @param {RangeOption<MKEY>} [range]
     * @return {Promise<Array<{ key: InstanceType<MKEY>, value: InstanceType<VALUE>, fkey: InstanceType<KEY>}>>}
     */
    getEntries(range?: RangeOption<MKEY> | undefined): Promise<Array<{
        key: InstanceType<MKEY>;
        value: InstanceType<VALUE>;
        fkey: InstanceType<KEY>;
    }>>;
    /**
     * @param {RangeOption<MKEY>} [range]
     * @return {Promise<Array<InstanceType<VALUE>>>}
     */
    getValues(range?: RangeOption<MKEY> | undefined): Promise<Array<InstanceType<VALUE>>>;
    /**
     * @param {RangeOption<MKEY>} [range]
     * @return {Promise<Array<InstanceType<MKEY>>>}
     */
    getKeys(range?: RangeOption<MKEY> | undefined): Promise<Array<InstanceType<MKEY>>>;
    /**
     * @param {RangeOption<MKEY>} range
     * @param {function(ICursor<InstanceType<MKEY>,InstanceType<VALUE>,InstanceType<KEY>>):void} f
     * @return {Promise<void>}
     */
    iterate(range: RangeOption<MKEY>, f: (arg0: ICursor<InstanceType<MKEY>, InstanceType<VALUE>, InstanceType<KEY>>) => void): Promise<void>;
}
/**
 * @todo move to utils. dont export via common
 * @todo rename MKEY to FKEY and change the order
 *
 * @template {typeof IEncodable} KEY
 * @template {typeof IEncodable} VALUE
 * @template {typeof IEncodable} MKEY
 * @template {{[key: string]: ITableIndex<any, any, any>}} INDEX
 *
 * @extends IndexedTableReadonly<KEY, VALUE, MKEY, INDEX>
 */
export class IndexedTable<KEY extends typeof IEncodable, VALUE extends typeof IEncodable, MKEY extends typeof IEncodable, INDEX extends {
    [key: string]: ITableIndex<any, any, any>;
}> extends IndexedTableReadonly<KEY, VALUE, MKEY, INDEX> {
    /**
     * @param {InstanceType<KEY>|FirstKeyParam<KEY>} key
     * @return {Promise<void>}
     */
    remove(key: InstanceType<KEY> | FirstKeyParam<KEY>): Promise<void>;
    /**
     * @param {RangeOption<KEY>} range
     * @return {Promise<void>}
     */
    removeRange(range: RangeOption<KEY>): Promise<void>;
}
/**
 * @template {IObjectDef<any>} ODef
 *
 * @interface
 */
export class IObjectReadonly<ODef extends IObjectDef<any>> {
    /**
     * @template {keyof ODef} Key
     * @param {Key} _key
     * @return {Promise<InstanceType<ODef[Key]>|null>}
     */
    get<Key extends keyof ODef>(_key: Key): Promise<InstanceType<ODef[Key]> | null>;
}
/**
 * @template {IObjectDef<any>} ODef
 *
 * @interface
 * @extends IObjectReadonly<ODef>
 */
export class IObject<ODef extends IObjectDef<any>> extends IObjectReadonly<ODef> {
    /**
     * @template {keyof ODef} Key
     * @param {Key} _key
     * @param {InstanceType<ODef[Key]>|FirstKeyParam<ODef[Key]>} _value
     */
    set<Key extends keyof ODef>(_key: Key, _value: InstanceType<ODef[Key]> | FirstKeyParam<ODef[Key]>): void;
    /**
     * @template {keyof ODef} Key
     * @param {Key} _key
     */
    remove<Key_1 extends keyof ODef>(_key: Key_1): void;
}
/**
 * @template {IDbDef} DEF
 *
 * @interface
 */
export class ITransaction<DEF extends IDbDef> {
    /**
     * @param {IDB<DEF>} _db
     */
    constructor(_db: IDB<DEF>);
    /**
     * @type {{ [Tablename in keyof DEF["tables"]]: ITable<NonNullable<DEF["tables"]>[Tablename]["key"],NonNullable<DEF["tables"]>[Tablename]["value"],Defined<NonNullable<DEF["tables"]>[Tablename]["indexes"]>,undefined> }}
     */
    tables: DEF["tables"] extends infer T ? { [Tablename in keyof T]: ITable<NonNullable<DEF["tables"]>[Tablename]["key"], NonNullable<DEF["tables"]>[Tablename]["value"], Defined<NonNullable<DEF["tables"]>[Tablename]["indexes"]>, undefined>; } : never;
    /**
     * @type {{ [Objectname in keyof DEF["objects"]]: IObject<NonNullable<DEF["objects"][Objectname]>> }}
     */
    objects: DEF["objects"] extends infer T_1 ? { [Objectname in keyof T_1]: IObject<NonNullable<DEF["objects"][Objectname]>>; } : never;
}
/**
 * @template {IDbDef} DEF
 *
 * @interface
 */
export class ITransactionReadonly<DEF extends IDbDef> {
    /**
     * @param {IDB<DEF>} _db
     */
    constructor(_db: IDB<DEF>);
    /**
     * @type {{ [Tablename in keyof DEF["tables"]]:ITableReadonly<NonNullable<DEF["tables"]>[Tablename]["key"],NonNullable<DEF["tables"]>[Tablename]["value"],Defined<NonNullable<DEF["tables"]>[Tablename]["indexes"]>,undefined> }}
     */
    tables: DEF["tables"] extends infer T ? { [Tablename in keyof T]: ITableReadonly<NonNullable<DEF["tables"]>[Tablename]["key"], NonNullable<DEF["tables"]>[Tablename]["value"], Defined<NonNullable<DEF["tables"]>[Tablename]["indexes"]>, undefined>; } : never;
}
/**
 * @template {IDbDef} DEF
 *
.* @interface
 */
export class IDB<DEF extends IDbDef> {
    /**
     * @template T
     * @param {function(ITransaction<DEF>): Promise<T>|T} _f
     * @return {Promise<T>}
     */
    transact<T>(_f: (arg0: ITransaction<DEF>) => T | Promise<T>): Promise<T>;
    /**
     * @template T
     * @param {function(ITransactionReadonly<DEF>): Promise<T>|T} _f
     * @return {Promise<T>}
     */
    transactReadonly<T_1>(_f: (arg0: ITransactionReadonly<DEF>) => T_1 | Promise<T_1>): Promise<T_1>;
    /**
     * @return {Promise<void>}
     */
    destroy(): Promise<void>;
}
/**
 * Note that inheritance is not supported by intention.
 */
export const unexpectedContentTypeException: Error;
export type Defined<T extends Object | undefined> = T & {};
export type IAny = string | number | bigint | boolean | Uint8Array | _IAnyArray | {
    [key: string]: IAny;
} | null | undefined;
export type FirstKeyParam<T extends new (...args: any) => any> = T extends abstract new (arg: infer P) => any ? P : never;
export type KeyPrefixArg<T extends unknown> = T extends {
    prefix: (arg: infer P) => Uint8Array;
} ? P : Uint8Array;
export type _IAnyArray = IAny[];
export type IEncodableKey = IEncodable;
export type ITableIndex<KEY extends typeof IEncodable, VALUE extends typeof IEncodable, MKEY extends typeof IEncodable> = {
    key: MKEY;
    mapper: (arg0: InstanceType<KEY>, arg1: InstanceType<VALUE>) => InstanceType<MKEY>;
};
export type ITableDef<KEY extends typeof IEncodable, VALUE extends typeof IEncodable> = {
    key: KEY;
    value: VALUE;
    indexes?: {
        [key: string]: ITableIndex<KEY, VALUE, any>;
    } | undefined;
};
export type IObjectDef<VAL extends typeof IEncodable> = {
    [key: string]: VAL;
};
export type IDbDef = {
    tables?: {
        [key: string]: ITableDef<any, any>;
    } | undefined;
    objects?: {
        [key: string]: IObjectDef<any>;
    } | undefined;
};
export type StartEndRangeOption<KEY extends typeof IEncodable> = {
    start?: InstanceType<KEY> | FirstKeyParam<KEY> | undefined;
    startExclusive?: boolean | undefined;
    end?: InstanceType<KEY> | FirstKeyParam<KEY> | undefined;
    endExclusive?: boolean | undefined;
    reverse?: boolean | undefined;
    /**
     * Number of items to receive
     */
    limit?: number | undefined;
};
export type PrefixedRangeOption<KEY extends typeof IEncodable> = {
    prefix: KeyPrefixArg<KEY>;
    reverse?: boolean | undefined;
    /**
     * Number of items to receive
     */
    limit?: number | undefined;
};
export type RangeOption<KEY extends typeof IEncodable> = PrefixedRangeOption<KEY> | StartEndRangeOption<KEY>;
export type ICursor<KEY extends IEncodable, VALUE extends IEncodable, FKEY extends IEncodable | undefined> = {
    key: KEY;
    value: VALUE;
    fkey: FKEY;
    stop: () => void;
};
import * as encoding from 'lib0/encoding';
import * as decoding from 'lib0/decoding';
//# sourceMappingURL=common.d.ts.map