import { QuickBase, QuickBaseOptions, QuickBaseRequest, QuickBaseResponseDeleteRecords } from 'quickbase';
import { QBField, QBFieldJSON } from 'qb-field';
export declare class QBRecord<RecordData extends QBRecordData = QBRecordData> {
    readonly CLASS_NAME = "QBRecord";
    static readonly CLASS_NAME = "QBRecord";
    static readonly VERSION: string;
    /**
     * The default settings of a `QuickBase` instance
     */
    static defaults: QBRecordOptions;
    /**
     * An internal id (guid) used for tracking/managing object instances
     */
    id: string;
    private _qb;
    private _tableId;
    private _fids;
    private _fields;
    private _data;
    constructor(options?: Partial<QBRecordOptions<RecordData>>);
    clear(): this;
    delete({ requestOptions }?: QuickBaseRequest): Promise<QuickBaseResponseDeleteRecords>;
    get<F extends keyof RecordData>(field: F): RecordData[F];
    get<F extends string>(field: F): F extends keyof RecordData ? RecordData[F] : any;
    getFid<T extends keyof RecordData>(field: T): number;
    getFid(field: number, byId: true): string;
    getFid(field: string | number, byId?: false): number;
    getFids(): QBFids<RecordData>;
    getField(id: number, returnIndex: true): number | undefined;
    getField(id: number, returnIndex?: false): QBField | undefined;
    getFields(): QBField[];
    getTableId(): string;
    getTempToken({ requestOptions }?: QuickBaseRequest): Promise<void>;
    load({ clist, query, requestOptions }?: QBRecordLoad): Promise<Record<any, any>>;
    loadSchema({ requestOptions }?: QuickBaseRequest): Promise<QBField[]>;
    save({ fidsToSave, mergeFieldId, requestOptions }?: QuickBaseRequest & {
        fidsToSave?: (keyof RecordData | number)[];
        mergeFieldId?: number;
    }): Promise<Record<any, any>>;
    set<F extends keyof RecordData>(field: F, value: RecordData[F]): this;
    set<F extends string>(field: F, value: F extends keyof RecordData ? RecordData[F] : any): this;
    setTableId(tableId: string): this;
    setFid<T extends keyof RecordData>(name: T, id: number): this;
    setFid(name: string | number, id: number): this;
    setFids(fields: Record<any, number>): this;
    setFields(fields: QBField[]): this;
    /**
     * Rebuild the QBRecord instance from serialized JSON
     *
     * @param json QBRecord serialized JSON
     */
    fromJSON(json: string | QBRecordJSON<RecordData>): this;
    /**
     * Serialize the QBRecord instance into JSON
     */
    toJSON(fidsToConvert?: (string | number)[]): QBRecordJSON<RecordData>;
    /**
     * Create a new QBRecord instance from serialized JSON
     *
     * @param json QBRecord serialized JSON
     */
    static fromJSON<T extends QBRecordData = QBRecordData>(json: string | QBRecordJSON<T>): QBRecord<T>;
    /**
     * Test if a variable is a `qb-record` object
     *
     * @param obj A variable you'd like to test
     */
    static IsQBRecord<T extends QBRecordData = QBRecordData>(obj: any): obj is QBRecord<T>;
    /**
     * Returns a new QBRecord instance built off of `options`, that inherits configuration data from the passed in `data` argument.
     *
     * @param options QBRecord instance options
     * @param data Quick Base Record data
     */
    static NewRecord<T extends QBRecordData = QBRecordData>(options: Partial<QBRecordOptions<T>>, data?: Partial<T>): QBRecord<T>;
}
export declare const replaceUndefinedWithString: (val: any) => any;
export declare type QBRecordLoad = QuickBaseRequest & {
    query?: string;
    clist?: string | number[];
};
export declare type QBRecordData = Record<any, any>;
export declare type QBFids<T extends QBRecordData> = {
    [K in keyof T]: number;
};
export declare type QBRecordOptions<RecordData extends QBRecordData = {
    recordid: number;
    primaryKey: number;
}> = {
    quickbase: QuickBase | QuickBaseOptions;
    tableId: string;
    fids: Partial<QBFids<RecordData>>;
    recordid?: number;
    primaryKey?: number;
};
export declare type QBRecordJSON<RecordData extends QBRecordData = {
    recordid: number;
    primaryKey: number;
}> = {
    quickbase: QuickBaseOptions;
    tableId: string;
    fids: QBFids<RecordData>;
    recordid: string | number;
    primaryKey: string | number;
    fields: QBFieldJSON[];
    data: RecordData;
};