qb-table/dist/qb-table.d.ts

A lightweight abstraction layer for Quick Base

import { QuickBase, QuickBaseOptions, QuickBaseResponseDeleteTable, QuickBaseResponseDeleteRecords, QuickBaseResponseRunQuery, QuickBaseRequestRunQuery, QuickBaseRequest, QuickBaseResponseGetTable } from 'quickbase';
import { QBField, QBFieldJSON, QBFieldAttributeSavable } from 'qb-field';
import { QBFids, QBRecord, QBRecordData } from 'qb-record';
import { QBReport, QBReportRunResponse, QBReportRunRequest } from 'qb-report';
export declare class QBTable<RecordData extends QBRecordData = QBRecordData, CustomGetSet extends Object = Record<any, any>> {
    readonly CLASS_NAME = "QBTable";
    static readonly CLASS_NAME = "QBTable";
    /**
     * The loaded library version
     */
    static readonly VERSION: string;
    /**
     * The default settings of a `QuickBase` instance
     */
    static defaults: QBTableOptions;
    /**
     * An internal id (guid) used for tracking/managing object instances
     */
    id: string;
    private _qb;
    private _appId;
    private _tableId;
    private _fids;
    private _fields;
    private _records;
    private _reports;
    private _data;
    constructor(options?: Partial<QBTableOptions<RecordData>>);
    clear(): this;
    delete({ requestOptions }?: QuickBaseRequest): Promise<QuickBaseResponseDeleteTable>;
    deleteRecord({ record, requestOptions }: {
        record: QBRecord<RecordData>;
    } & QuickBaseRequest): Promise<QuickBaseResponseDeleteRecords>;
    deleteRecords({ individually, records, requestOptions }?: {
        individually?: boolean;
        records?: QBRecord<RecordData>[];
    } & QuickBaseRequest): Promise<QuickBaseResponseDeleteRecords>;
    get(attribute: 'id' | 'appId' | 'tableId'): string;
    get<P extends keyof QuickBaseResponseGetTable>(attribute: P): QuickBaseResponseGetTable[P];
    get<P extends keyof CustomGetSet>(attribute: P): CustomGetSet[P];
    get<P extends string>(attribute: P): P extends keyof QuickBaseResponseGetTable ? QuickBaseResponseGetTable[P] : (P extends keyof CustomGetSet ? CustomGetSet[P] : any);
    getAppId(): string;
    getFid<T extends keyof RecordData>(field: T): number;
    getFid(field: string | number, byId?: false | undefined): number;
    getFid(field: number, byId: true): string;
    getFids(): QBFids<RecordData>;
    getField(id: number, returnIndex: true): number | undefined;
    getField(id: number, returnIndex?: false): QBField | undefined;
    getFields(): QBField[];
    getNRecords(): number;
    getRecord<T extends keyof RecordData>(value: RecordData[T], fieldName: T, returnIndex: true): number;
    getRecord<T extends keyof RecordData>(value: RecordData[T], fieldName: T, returnIndex?: false): QBRecord<RecordData> | undefined;
    getRecord(value: any, fieldName: string, returnIndex: true): number;
    getRecord(value: any, fieldName?: string, returnIndex?: false | undefined): QBRecord<RecordData> | undefined;
    getRecords(): QBRecord<RecordData>[];
    getReport(id: string): QBReport<RecordData> | undefined;
    getReports(): QBReport<RecordData>[];
    getTableId(): string;
    getTempToken({ requestOptions }?: QuickBaseRequest): Promise<void>;
    loadField({ field, requestOptions }: QuickBaseRequest & {
        field: number | QBField;
    }): Promise<QBField>;
    loadFields({ requestOptions }?: QuickBaseRequest): Promise<QBField[]>;
    loadReport({ report, requestOptions }: QuickBaseRequest & {
        report: string | QBReport<RecordData>;
    }): Promise<QBReport<RecordData>>;
    loadReports({ requestOptions }?: QuickBaseRequest): Promise<QBReport<RecordData>[]>;
    loadSchema({ requestOptions }?: QuickBaseRequest): Promise<QuickBaseResponseGetTable & {
        fields: QBField[];
        reports: QBReport<RecordData>[];
    }>;
    loadTable({ requestOptions }?: QuickBaseRequest): Promise<QuickBaseResponseGetTable>;
    private _runQueryAll;
    runQuery({ fids, groupBy, options, select, sortBy, where, returnAll, requestOptions }?: QBTableRunQueryOptions): Promise<QBTableRunQueryResponse<RecordData>>;
    runReport({ report, skip, top, requestOptions }: QBReportRunRequest & {
        report: string | QBReport<RecordData>;
    }): Promise<QBReportRunResponse<RecordData>>;
    saveFields({ attributesToSave, requestOptions }?: {
        attributesToSave?: QBFieldAttributeSavable[];
    } & QuickBaseRequest): Promise<QBField[]>;
    saveRecords({ individually, fidsToSave, recordsToSave, mergeFieldId, requestOptions }?: {
        individually?: boolean;
        fidsToSave?: (keyof RecordData | number)[];
        mergeFieldId?: number;
        recordsToSave?: QBRecord<RecordData>[];
    } & QuickBaseRequest): Promise<QBRecord<RecordData>[]>;
    saveTable({ attributesToSave, requestOptions }?: {
        attributesToSave?: string[];
    } & QuickBaseRequest): Promise<QuickBaseResponseGetTable>;
    set(attribute: 'id' | 'tableId' | 'appid', value: string): this;
    set<P extends keyof QuickBaseResponseGetTable>(attribute: P, value: QuickBaseResponseGetTable[P]): this;
    set<P extends keyof CustomGetSet>(attribute: P, value: CustomGetSet[P]): this;
    set<P extends string>(attribute: P, value: P extends keyof QuickBaseResponseGetTable ? QuickBaseResponseGetTable[P] : (P extends keyof CustomGetSet ? CustomGetSet[P] : any)): this;
    setAppId(appId: 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;
    setTableId(tableId: string): this;
    upsertField(options: QBField | Partial<QBFieldJSON['data']>, autoSave?: boolean): Promise<QBField>;
    upsertFields(fields: (Partial<QBFieldJSON> | QBField)[], autoSave?: boolean): Promise<QBField[]>;
    upsertRecord(options?: QBRecord<RecordData> | Partial<RecordData>, autoSave?: boolean): Promise<QBRecord<RecordData>>;
    upsertRecords(records: (QBRecord<RecordData> | Partial<RecordData>)[], autoSave?: boolean): Promise<QBRecord<RecordData>[]>;
    /**
     * Test if a variable is a `qb-record` object
     *
     * @param obj A variable you'd like to test
     */
    static IsQBTable<T extends QBRecordData = QBRecordData, K extends Object = Record<any, any>>(obj: any): obj is QBTable<T, K>;
    static NewRecord<T extends QBRecordData, K extends Object>(table: QBTable<T, K>, data?: Partial<T>): QBRecord<T>;
    static ToCSV<T extends QBRecordData, K extends Object>(table: QBTable<T, K>, columns: (keyof T)[], data?: QBRecord<T>[]): string;
}
export declare type QBTableOptions<RecordData extends QBRecordData = {}> = {
    quickbase: QuickBaseOptions | QuickBase;
    appId: string;
    tableId: string;
    fids: Partial<QBFids<RecordData>>;
};
export declare type QBTableRunQueryOptions = {
    fids?: Record<string, number>;
    returnAll?: boolean;
} & Pick<QuickBaseRequestRunQuery, 'select' | 'where' | 'options' | 'sortBy' | 'groupBy' | 'requestOptions'>;
export declare type QBTableRunQueryResponse<RecordData extends QBRecordData = {}> = Pick<QuickBaseResponseRunQuery, 'metadata'> & {
    records: QBRecord<RecordData>[];
    fields: QBField[];
};