@kevisual/noco/dist/app.d.ts

一个轻量级的 NocoDB API SDK，支持表记录操作和 Base 管理功能。

type MakeRequestOptions = {
    params?: Record<string, any>;
    data?: Record<string, any>;
    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
    json?: boolean;
    isFromData?: boolean;
    body?: any;
    headers?: Record<string, string>;
};
declare class Query {
    baseURL: string;
    token: string;
    constructor({ baseURL, token }: {
        baseURL: string;
        token: string;
    });
    makeRequest(endpoint: string, options: MakeRequestOptions): Promise<any>;
}
type ResponseList<T = any> = {
    code: number;
    data: {
        list: T[];
        pageInfo?: {
            totalRows?: number;
            page?: number;
            pageSize?: number;
            isFirstPage?: boolean;
            isLastPage?: boolean;
        };
    };
};
type Result<T = any> = {
    code: number;
    data: T;
};

type BaseOptions$2 = {
    query: Query;
};
type BaseInfo = {
    id?: string;
    title: string;
    description?: string;
    config?: Record<string, any>;
    color?: string;
    meta?: Record<string, any>;
    order?: number;
    prefix?: string;
    status?: string;
    type?: string;
    created_at?: string;
    updated_at?: string;
};
type CreateBaseData = {
    title: string;
    description?: string;
    color?: string;
    meta?: Record<string, any>;
    config?: Record<string, any>;
};
type UpdateBaseData = {
    id?: string;
    title?: string;
    description?: string;
    color?: string;
    meta?: Record<string, any>;
    config?: Record<string, any>;
};
type BaseListResult = {
    code: number;
    list: BaseInfo[];
    pageInfo?: {
        totalRows?: number;
        page?: number;
        pageSize?: number;
        isFirstPage?: boolean;
        isLastPage?: boolean;
    };
};
type BaseResult = {
    code: number;
    data?: BaseInfo;
    message?: string;
};
/**
 * NocoDB Base 管理服务
 * @url https://nocodb.com/apis/v2/meta
 */
declare class MetaBases {
    query: Query;
    constructor(options?: BaseOptions$2);
    /**
     * 列出所有 bases
     */
    list(workspaceId: string): Promise<BaseListResult>;
    /**
     * 创建新的 base
     */
    create(data: CreateBaseData): Promise<BaseResult>;
    /**
     * 获取指定 base 的信息
     */
    get(baseId: string): Promise<BaseResult>;
}

type BaseOptions$1 = {
    query: Query;
};
type TableMetaInfo = {
    id: string;
    source_id: string;
    base_id: string;
    table_name: string;
    title: string;
    type: string;
    meta: any;
    schema: any;
    enabled: boolean;
    mm: boolean;
    tags: string | null;
    pinned: boolean | null;
    deleted: boolean | null;
    order: number;
    created_at: string;
    updated_at: string;
    description: string;
    synced: boolean;
    created_by: string | null;
    owned_by: string | null;
    uuid: string | null;
    password: string | null;
    fk_custom_url_id: string | null;
    views?: Array<any>;
    columns?: Array<any>;
    columnsById?: Record<string, any>;
    columnHash?: string;
};
declare class MetaTables {
    query: Query;
    constructor(options?: BaseOptions$1);
    /**
     * 列出所有 tables
     */
    list(baseId: string): Promise<ResponseList<TableMetaInfo>>;
    createTable(baseId: string, data: CreateTableData): Promise<{
        code: number;
        data: TableMetaInfo;
    }>;
    getTableMeta(tableId: string): Promise<{
        code: number;
        data: TableMetaInfo;
    }>;
    createColumn(tableId: string, data: any): Promise<{
        code: number;
        data: any;
    }>;
}
type CreateColumnData = {
    title: string;
    uidt?: ColumnTypes;
    description?: string;
    /** id 自增的必填项 */
    pk?: boolean;
    /**
     * 是否为主键 primay 的值
     */
    pv?: boolean;
    /** 是否必填 */
    rqd?: boolean;
    /** 单元格默认值 */
    cdf?: string;
    /**
     * 列选项配置
     */
    colOptions?: {
        options?: Array<{
            title: string;
            color?: string;
            [key: string]: any;
        }>;
    };
    /**
     * 其他元信息
     */
    meta?: Record<string, any>;
};
declare const columnTypes: readonly ["SingleLineText", "LongText", "PhoneNumber", "Email", "URL", "Number", "Decimal", "Percent", "Currency", "Duration", "Date", "Time", "DateTime", "Year", "SingleSelect", "MultiSelect", "User", "Attachment", "Checkbox", "Rating", "Button", "Formula", "Barcode", "QRCode", "Links", "LinkToAnotherRecord", "Lookup", "Rollup", "ID", "CreatedTime", "LastModifiedTime", "CreatedBy", "LastModifiedBy", "GeoData", "Geometry", "JSON", "SpecificDBType"];
type ColumnTypes = typeof columnTypes[number];
type CreateTableData = {
    table_name?: string;
    title: string;
    description?: string;
    columns: CreateColumnData[];
    [key: string]: any;
};

type WebhookOptions = {
    query: Query;
};
declare class Webhook {
    private query?;
    constructor(options?: WebhookOptions);
    listTableWebhooks(tableId: string): Promise<ResponseList<WebhookItem>>;
    createTableWebhook(tableId: string, data: WebhookItemCore): Promise<any>;
    updateTableWebhook(hookId: string, data: WebhookItemCore): Promise<any>;
    deleteTableWebhook(hookId: string): Promise<any>;
}
declare const operations: string[];
type WebhookOperation = typeof operations[number];
/**
 * Webhook 项目类型定义
 */
type WebhookItem = {
    id: string;
    source_id: string;
    base_id: string;
    fk_model_id: string;
    title: string;
    description: string;
    env: string;
    type: 'manual' | null;
    operation: WebhookOperation[];
    async: boolean;
    payload: boolean;
    url: string;
    headers: Record<string, string>;
    condition: boolean;
    notification: string;
    retries: number;
    retry_interval: number;
    timeout: number;
    active: boolean;
    created_at: string;
    updated_at: string;
    version: string;
    trigger_field: boolean;
    trigger_fields: any[];
};
type WebhookItemCore = {
    id?: string;
    title: string;
    description?: string | null;
    operation: WebhookOperation | WebhookOperation[];
    /**
     * Webhook 触发的 json的
     * 不能为空对象
     * @example '{"type":"URL","include_user":false,"payload":{"method":"POST","body":"{{ json event }}","headers":[{"enabled":false,"name":"","value":""}],"parameters":[{"enabled":false,"name":"tableId","value":"mecdgojq151iwk9"}],"path":"https://kevision.xiongxiao.me/api/router","auth":""},"trigger_form":false}'
     */
    notification: string | Record<string, any>;
    /**
     * 内置必填
     */
    event: string;
    /**
     * 内置必填
     */
    version?: string;
    /**
     * 是否启用
     */
    active?: boolean;
};
type WebhookNotification = {
    type: 'URL' | 'Email' | 'DingTalk' | 'WeCom' | 'FeiShu';
    include_user: boolean;
    payload: {
        method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH';
        /**
         * 请求体
         * {{ json event }}
         */
        body: string;
        headers: Array<{
            enabled: boolean;
            name: string;
            value: string;
        }>;
        parameters: Array<{
            enabled: boolean;
            name: string;
            value: string;
        }>;
        path: string;
        auth: string;
    };
    trigger_form: boolean;
};

type MetaOptions = {
    query: Query;
};
/**
 * NocoDB Meta API 管理类
 * 统一管理所有的 meta 相关操作
 */
declare class Meta {
    query: Query;
    bases: MetaBases;
    tables: MetaTables;
    webhooks: Webhook;
    constructor(options?: MetaOptions);
}

/**
 * https://nocodb.com/docs/product-docs/developer-resources/rest-apis#v3-where-query-parameter
 */
type QueryParams = {
    /**
     * fields=field1,field2
     */
    fields?: string | string[];
    /**
     * sort=field1,-field2
     */
    sort?: string | string[];
    /**
     * where=(field1,eq,value1)~and(field2,eq,value2)
     */
    where?: string;
    offset?: number;
    limit?: number;
    viewId?: string;
    [key: string]: any;
};
type ResultList<T = any> = {
    code: number;
    data: {
        list: T[];
        pageInfo?: {
            totalRows?: number;
            page?: number;
            pageSize?: number;
            isFirstPage?: boolean;
            isLastPage?: boolean;
        };
    };
};
type Id = string | number;
/**
 * @url https://nocodb.com/apis/v2/data#tag/Table-Records
 */
declare class Record$1 {
    query: Query;
    table: string;
    meta: Meta;
    constructor({ query, table, meta }: {
        query: Query;
        table: string;
        meta?: Meta;
    });
    list<T = any>(params?: QueryParams): Promise<ResultList<T>>;
    create(data: any): Promise<any>;
    read(id: Id): Promise<any>;
    update(data: {
        Id?: Id;
        [key: string]: any;
    }): Promise<any>;
    delete(data: {
        Id?: Id;
    }): Promise<any>;
    count(): Promise<any>;
    listLinks(linkFieldId: Id, Id: Id): Promise<any>;
    updateLinks(linkFieldId: Id, Id: Id, data: any): Promise<any>;
    deleteLinks(linkFieldId: Id, Id: Id): Promise<any>;
    getTableMeta(): Promise<{
        code: number;
        data: {
            id: string;
            source_id: string;
            base_id: string;
            table_name: string;
            title: string;
            type: string;
            meta: any;
            schema: any;
            enabled: boolean;
            mm: boolean;
            tags: string | null;
            pinned: boolean | null;
            deleted: boolean | null;
            order: number;
            created_at: string;
            updated_at: string;
            description: string;
            synced: boolean;
            created_by: string | null;
            owned_by: string | null;
            uuid: string | null;
            password: string | null;
            fk_custom_url_id: string | null;
            views?: Array<any>;
            columns?: Array<any>;
            columnsById?: globalThis.Record<string, any>;
            columnHash?: string;
        };
    }>;
    getTableSchema(): Promise<Result<TableSchema>>;
}
type Schema<T = {}> = {
    [key: string]: any;
} & T;
type TableSchema<T = {}> = {
    columns: {
        id: string;
        name: string;
        type: string;
        required: boolean;
        primary: boolean;
        options: any;
    }[];
    schema: Schema<T>;
};

declare class Upload {
    private query;
    constructor(query: Query);
    /**
     * 创建上传, 上传后，自动返回的数据是列表
     * @param opts
     * @returns
     */
    createUpload(opts: UploadOpts): Promise<{
        code: number;
        list: UploadItem[];
    }>;
}
type UploadOpts = {
    path?: string;
    mimeType?: string;
    file: any;
    size?: number;
    title: string;
    url?: string;
};
type UploadItem = {
    /**
     * nocodb 资源路径
     */
    path: string;
    /**
     * 文件标题
     */
    title: string;
    /**
     * 文件大小，单位字节
     */
    size: number;
    /**
     * 文件 MIME 类型
     */
    mimetype: string;
    width: number;
    height: number;
    /**
     * 签名后的完整访问路径
     */
    signedPath: string;
};

type NocoApiOptions = {
    table?: string;
    token?: string;
    baseURL?: string;
};
declare class NocoApi {
    query: Query;
    record: Record$1;
    meta: Meta;
    upload: Upload;
    constructor(options?: NocoApiOptions);
    get baseURL(): string;
    set baseURL(url: string);
    getTableByName(table: string, baseId: string): Promise<{
        id: string;
        source_id: string;
        base_id: string;
        table_name: string;
        title: string;
        type: string;
        meta: any;
        schema: any;
        enabled: boolean;
        mm: boolean;
        tags: string | null;
        pinned: boolean | null;
        deleted: boolean | null;
        order: number;
        created_at: string;
        updated_at: string;
        description: string;
        synced: boolean;
        created_by: string | null;
        owned_by: string | null;
        uuid: string | null;
        password: string | null;
        fk_custom_url_id: string | null;
        views?: Array<any>;
        columns?: Array<any>;
        columnsById?: globalThis.Record<string, any>;
        columnHash?: string;
    }>;
    /**
     *
     * @param baseId
     * @param data
     */
    createExampleTable(baseId: string, data?: ExampleTableData): Promise<{
        code: number;
        data: {
            id: string;
            source_id: string;
            base_id: string;
            table_name: string;
            title: string;
            type: string;
            meta: any;
            schema: any;
            enabled: boolean;
            mm: boolean;
            tags: string | null;
            pinned: boolean | null;
            deleted: boolean | null;
            order: number;
            created_at: string;
            updated_at: string;
            description: string;
            synced: boolean;
            created_by: string | null;
            owned_by: string | null;
            uuid: string | null;
            password: string | null;
            fk_custom_url_id: string | null;
            views?: Array<any>;
            columns?: Array<any>;
            columnsById?: globalThis.Record<string, any>;
            columnHash?: string;
        };
    }>;
}
type ExampleTableData = {
    title?: string;
    description?: string;
    columns?: any[];
};

type BaseOptions = {
    query: Query;
};
declare class ApiToken {
    query: Query;
    constructor(options?: BaseOptions);
    getTokenList(data: {
        baseId: string;
    }): Promise<any>;
    createToken(data: {
        baseId?: string;
        description?: string;
        fk_user_id?: string;
    }): Promise<any>;
    deleteToken(data: {
        baseId: string;
        tokenId: string;
    }): Promise<any>;
}

type Options = {
    query: Query;
};
declare class Users {
    query?: Query;
    constructor(options?: Options);
    listUsers(baseId?: string): Promise<ResponseList<UserItem>>;
    createUser(baseId: string, data: Partial<UserItem>): Promise<UserItem>;
    deleteUser(userId: string): Promise<{
        code: number;
        message: string;
    }>;
}
declare const userRoles: readonly ["no-access", "commenter", "editor", "guest", "owner", "viewer", "creator"];
type UserRole = typeof userRoles[number];
type UserItem = {
    email: string;
    display_name: string;
    invite_token: string;
    id: string;
    meta?: any;
    main_roles?: string;
    base_id?: string;
    roles: UserRole;
    created_at: string;
};

export { ApiToken, Meta, MetaBases, NocoApi, Query, Record$1 as Record, Upload, Users, Webhook };
export type { BaseInfo, BaseListResult, BaseOptions$2 as BaseOptions, BaseResult, CreateBaseData, CreateColumnData, CreateTableData, ExampleTableData, MetaOptions, NocoApiOptions, QueryParams, ResponseList, Result, Schema, TableSchema, UpdateBaseData, WebhookItem, WebhookItemCore, WebhookNotification, WebhookOptions };