import { PartialFieldInfo } from '@protobuf-ts/runtime';
import { WireType } from '@protobuf-ts/runtime';

export declare class ArrayWrapper<T> extends ValueWrapper<T[]> {
    getTypeName(): string;
}

export declare function autoTypeToClass(typeName: string): typeof UnknownWrapper;

export declare function autoTypeToField(key: string, dataValue: ValueWrapper<unknown>): PartialFieldInfo;

export declare class BoolWrapper extends ValueWrapper<boolean> {
    getTypeName(): string;
}

export declare class BytesWrapper extends ValueWrapper<Uint8Array> {
    getTypeName(): string;
}

export declare class ChainProto extends ProtoBufBase {
    push<T>(data: T): this;
}

export declare function decodeProtoBuf<T>(typeName: string, message: any, fieldNo: number, wireType: WireType, data: Uint8Array, encodeBytes?: (data: Uint8Array) => T): void;

export declare class DoubleWrapper extends ValueWrapper<number> {
    getTypeName(): string;
}

export declare type ExtractSchema<T> = Omit<{
    [K in keyof T]: T[K] extends ProtoBufBase ? ExtractSchema<T[K]> : ExtractType<T[K]>;
}, keyof ProtoBufBase>;

export declare type ExtractType<T> = T extends ArrayWrapper<infer V> ? V[] : T extends ValueWrapper<infer U> ? U : T extends ProtoBufBase ? ExtractSchema<T> : T;

export declare class Fixed32Wrapper extends ValueWrapper<number> {
    getTypeName(): string;
}

export declare class Fixed64Wrapper extends ValueWrapper<bigint> {
    getTypeName(): string;
}

export declare class FloatWrapper extends ValueWrapper<number> {
    getTypeName(): string;
}

export declare class Int32Wrapper extends ValueWrapper<number> {
    getTypeName(): string;
}

export declare class Int64Wrapper extends ValueWrapper<bigint> {
    getTypeName(): string;
}

export declare function PBArray<T>(field: number | undefined, data: T, opt?: boolean, value?: T[]): Omit<T, keyof ProtoBufBase>[];

export declare function PBBool(field?: number, opt?: boolean, value?: boolean): boolean;

export declare function PBBytes(field?: number, opt?: boolean, value?: Uint8Array<ArrayBuffer>): Uint8Array;

export declare function PBDouble(field?: number, opt?: boolean, value?: number): number;

export declare function PBFixed32(field?: number, opt?: boolean, value?: number): number;

export declare function PBFixed64(field?: number, opt?: boolean, value?: bigint): bigint;

export declare function PBFloat(field?: number, opt?: boolean, value?: number): number;

export declare function PBInt32(field?: number, opt?: boolean, value?: number): number;

export declare function PBInt64(field?: number, opt?: boolean, value?: bigint): bigint;

export declare function PBSFixed32(field?: number, opt?: boolean, value?: number): number;

export declare function PBSFixed64(field?: number, opt?: boolean, value?: bigint): bigint;

export declare function PBSInt32(field?: number, opt?: boolean, value?: number): number;

export declare function PBSInt64(field?: number, opt?: boolean, value?: bigint): bigint;

export declare function PBString(field?: number, opt?: boolean, value?: string): string;

export declare function PBUint32(field?: number, opt?: boolean, value?: number): number;

export declare function PBUint64(field?: number, opt?: boolean, value?: bigint): bigint;

export declare function ProtoBuf<T extends ProtoBufBase>(field: number, valueClass: new () => T): T;

export declare function ProtoBuf<T extends ProtoBufBase>(valueClass: new () => T): T;

export declare class ProtoBufBase {
    _fieldId: number;
    generateFields(): PartialFieldInfo[];
    assignFields(fields: {
        [key: string]: unknown;
    }): void;
    toObject(): Omit<this, keyof ProtoBufBase>;
    encode(): Uint8Array;
    decode(data: Uint8Array): this;
    then(callback: (data: this) => void): void;
}

export declare function ProtoBufDecode<T>(data: Uint8Array, encodeBytes?: (data: Uint8Array) => T): object;

export declare function ProtoBufEx<T extends ProtoBufBase, U extends ExtractSchema<T>>(valueClass: new () => T, value?: U): T;

export declare function ProtoBufIn<T>(field: number, data: T): T;

export declare function ProtoBufIn<T>(data: T): T;

export declare function ProtoBufQuick<T extends {}, U extends T>(pb: T, data: U): ProtoBufBase;

export declare function proxyClassProtobuf<T extends ProtoBufBase>(protobuf: T): T;

export declare class SFixed32Wrapper extends ValueWrapper<number> {
    getTypeName(): string;
}

export declare class SFixed64Wrapper extends ValueWrapper<bigint> {
    getTypeName(): string;
}

export declare class SInt32Wrapper extends ValueWrapper<number> {
    getTypeName(): string;
}

export declare class SInt64Wrapper extends ValueWrapper<bigint> {
    getTypeName(): string;
}

export declare class StringWrapper extends ValueWrapper<string> {
    getTypeName(): string;
}

export declare class UInt32Wrapper extends ValueWrapper<number> {
    getTypeName(): string;
}

export declare class UInt64Wrapper extends ValueWrapper<bigint> {
    getTypeName(): string;
}

export declare class UnknownWrapper extends ValueWrapper<unknown> {
    getTypeName(): string;
}

export declare function UnWrap<T>(data: T): T;

export declare class ValueWrapper<T> {
    _value: T;
    _fieldId: number;
    _opt: boolean;
    _callback?: Function;
    constructor(field: number, value: T, opt: boolean, callback?: Function);
    get value(): T;
    set value(newValue: T);
    getTypeName(): string;
    getFieldId(): number;
    getField(key: string): PartialFieldInfo;
}

export { }