zotero-types
Version:
This package contains type definitions for Zotero (https://www.zotero.org/) plugin.
265 lines (234 loc) • 8.71 kB
TypeScript
/// <reference path="dataObject.d.ts" />
declare namespace _ZoteroTypes {
interface DataObjects<T extends Zotero.DataObject = Zotero.DataObject> {
idColumn: string;
table: string;
relationsTable: string;
primaryFields: string[];
_primaryDataSQLWhere: "WHERE 1";
primaryDataSQLFrom: string;
primaryDataSQL: string;
init(): Promise<void>;
_loadIDsAndKeys(): Promise<void>;
isPrimaryField(field: string): boolean;
/**
* Retrieves one or more already-loaded items
*
* If an item hasn't been loaded, an error is thrown
*
* @param {Array|Integer} ids An individual object id or an array of object ids
* @return {Zotero.[Object]|Array<Zotero.[Object]>} A Zotero.[Object], if a scalar id was passed;
* otherwise, an array of Zotero.[Object]
*/
get(id: number): T;
get(ids: number[]): T[];
/**
* Retrieves (and loads, if necessary) one or more items
*
* @param {Array|Integer} ids An individual object id or an array of object ids
* @param {Object} [options]
* @param {Boolean} [options.noCache=false] - Don't add object to cache after loading
* @return {Promise<Zotero.DataObject|Zotero.DataObject[]>} - A promise for either a data object,
* if a scalar id was passed, or an array of data objects, if an array of ids was passed
*/
getAsync(id: number, options?: { noCache: boolean }): Promise<T>;
getAsync(ids: number[], options?: { noCache: boolean }): Promise<T[]>;
/**
* Get all loaded objects
*
* @return {Zotero.DataObject[]}
*/
getLoaded(): T[];
/**
* Return objects in the trash
*
* @param {Integer} libraryID - Library to search
* @param {Boolean} [asIDs] - Return object ids instead of objects
* @param {Integer} [days]
* @param {Integer} [limit]
* @return {Promise<Zotero.DataObject[]|Integer[]>}
*/
getDeleted(
libraryID: number,
asIDs?: boolean,
days?: number,
limit?: number,
): Promise<Array<number | T>>;
getAllIDs(libraryID: number): Promise<number[]>;
getAllKeys(libraryID: number): Promise<string[]>;
parseLibraryKey(libraryKey: string): { libraryID: number; key: string };
/**
* Retrieves an object by its libraryID and key
*
* @param {Integer} libraryID
* @param {String} key
* @return {Zotero.DataObject} Zotero data object, or FALSE if not found
*/
getByLibraryAndKey(
libraryID: number,
key: string,
options?: unknown,
): T | false;
/**
* Asynchronously retrieves an object by its libraryID and key
*
* @param {Integer} libraryID
* @param {String} key
* @param {Object} [options]
* @param {Boolean} [options.noCache=false] - Don't add object to cache after loading
* @return {Promise<Zotero.DataObject>} - Promise for a data object, or FALSE if not found
*/
getByLibraryAndKeyAsync(
libraryID: number,
key: string,
options?: { noCache: boolean },
): Promise<T | false>;
exists(id: number): boolean;
/**
* @return {Object} Object with 'libraryID' and 'key'
*/
getLibraryAndKeyFromID(
id: number,
): false | { libraryID: number; key: string };
getIDFromLibraryAndKey(libraryID: number, key: string): number | false;
/**
* @returns Array of id of object
*/
getOlder(libraryID: number, date: Date): Promise<number[]>;
/**
* @returns Array of id of object
*/
getNewer(
libraryID: number,
date: Date,
ignoreFutureDates?: boolean,
): Promise<number[]>;
/**
* Gets the latest version for each object of a given type in the given library
*
* @return {Promise<Object>} - A promise for an object with object keys as keys and versions
* as properties
*/
getObjectVersions(
libraryID: number,
keys?: string[],
): Promise<{ [key: string]: number }>;
/**
* Bulk-load data type(s) of given objects if not loaded
*
* This would generally be used to load necessary data for cross-library search results, since those
* results might include objects in libraries that haven't yet been loaded.
*
* @param {Zotero.DataObject[]} objects
* @param {String[]} [dataTypes] - Data types to load, defaulting to all types
* @return {Promise}
*/
loadDataTypes(objects: T[], dataTypes?: string[]): Promise<void>;
/**
* Loads data for a given data type
* @param {String} dataType
* @param {Integer} libraryID
* @param {Integer[]} [ids]
*/
_loadDataTypeInLibrary(
dataType: string,
libraryID: number,
ids: number[],
): Promise<void>;
loadAll(libraryID: number, ids?: number[]): Promise<void>;
/**
* Sort an array of collections or items from top-level to deepest, grouped by level
*
* All top-level objects are returned, followed by all second-level objects, followed by
* third-level, etc. The order within each level is undefined.
*
* This is used to sort higher-level objects first in upload JSON, since otherwise the API would
* reject lower-level objects for having missing parents.
*
* @param {Zotero.DataObject[]} objects - An array of objects
* @return {Zotero.DataObject[]} - A sorted array of objects
*/
sortByLevel<T>(objects: T[]): T[];
/**
* Sort an array of collections or items from top-level to deepest, grouped by parent
*
* Child objects are included before any sibling objects. The order within each level is undefined.
*
* This is used to sort higher-level objects first in upload JSON, since otherwise the API would
* reject lower-level objects for having missing parents.
*
* @param {Zotero.DataObject[]} objects - An array of data objects
* @return {Zotero.DataObject[]} - A sorted array of data objects
*/
sortByParent<T>(objects: T[]): T[];
/**
* Flatten API JSON relations object into an array of unique predicate-object pairs
*
* @param {Object} relations - Relations object in API JSON format, with predicates as keys
* and arrays of URIs as objects
* @return {Array[]} - Predicate-object pairs
*/
flattenRelations(
relations: ObjectRelations,
): Array<[RelationsPredicate, ZoteroObjectURI]>;
/**
* Reload loaded data of loaded objects
*
* @param {Array|Number} ids - An id or array of ids
* @param {Array} [dataTypes] - Data types to reload (e.g., 'primaryData'), or all loaded
* types if not provided
* @param {Boolean} [reloadUnchanged=false] - Reload even data that hasn't changed internally.
* This should be set to true for data that was
* changed externally (e.g., globally renamed tags).
*/
reload(
ids: number,
dataTypes: string[],
reloadUnchanged?: boolean,
): Promise<undefined | true>;
reloadAll(libraryID: number): Promise<void>;
registerObject(obj: T): void;
dropDeadObjectsFromCache(): void;
/**
* Clear object from internal array
*
* @param int[] ids objectIDs
*/
unload(ids: number[]): void;
/**
* Set the version of objects, efficiently
*
* @param {Integer[]} ids - Ids of objects to update
* @param {Boolean} version
*/
updateVersion(ids: number[], version: number): Promise<void>;
/**
* Set the sync state of objects, efficiently
*
* @param {Integer[]} ids - Ids of objects to update
* @param {Boolean} synced
*/
updateSynced(ids: number[], synced?: boolean): Promise<void>;
isEditable(obj: T): boolean;
getPrimaryDataSQLPart(part: string): string;
/**
* Delete one or more objects from the database and caches
*
* @param {Integer|Integer[]} ids - Object ids
* @param {Object} [options] - See Zotero.DataObject.prototype.erase
* @param {Function} [options.onProgress] - f(progress, progressMax)
* @return {Promise}
*/
erase(
ids: number | number[],
options?: Zotero.DataObject.EraseOptions & {
onProgress?: (progress: number, progressMax: number) => void;
},
): Promise<void>;
_loadIDsAndKeys(): Promise<void>;
}
type ObjectType = "collection" | "item" | "search";
}
declare namespace Zotero {
const DataObjects: _ZoteroTypes.DataObjects;
}