@luminocity/lemonate-gateway 7.7.0

package/dist/index.d.ts

@@ -0,0 +1,4368 @@
+import moment from 'moment';
+import { AxiosInstance, ResponseType } from 'axios';
+import WebSocket from 'isomorphic-ws';
+import FormData from 'form-data';
+import { WebsocketProvider } from 'y-websocket';
+import * as awarenessProtocol from 'y-protocols/awareness';
+import { CollabDocument } from '@/collabstate/CollabDocument';
+
+declare class Snapshot {
+    id: string;
+    type: string;
+    data: any;
+    constructor(id: string, type: string, data: any);
+}
+
+declare class Storage {
+    databaseName: string;
+    collectionName: string;
+    size: number;
+    type: number;
+    private _impl;
+    constructor(databaseName: string, collectionName: string, type?: number, sizeMb?: number);
+    init(): Promise<any>;
+    _keys(): Promise<any>;
+    fixKey(key: string): string;
+    _set(key: string, data: any): Promise<any>;
+    _clear(): Promise<any>;
+    _get(key: string, mimeType?: string): Promise<any>;
+    _remove(key: string): Promise<any>;
+}
+
+declare class ItemCache$1 extends Storage {
+    apiClient: ApiClient;
+    cache: Map<string, any>;
+    urlToIdMap: Map<string, string>;
+    logging: boolean;
+    ready: boolean;
+    usePublicApi: boolean;
+    quota: number;
+    size: number;
+    usePersistentStorage: boolean;
+    saveIndex: Function;
+    constructor(usePublicApi: boolean, usePersistentStorage: boolean, apiClient: ApiClient, persistentStorageSizeMb: number);
+    init(): Promise<void>;
+    getQuota(): number;
+    setQuota(value: any): void;
+    getCount(): number;
+    getSize(): number;
+    initFromStorage(): Promise<void>;
+    addToStorage(object: any, blob: any): Promise<void>;
+    waitUntilReady(): Promise<void>;
+    findObject(id: string): any;
+    getEntries(): MapIterator<any>;
+    clear(): void;
+    clearMemory(): void;
+    checkQuota(increase?: number): void;
+    removeObjectFromCache(id: string): void;
+    getIdFromUrl(url: string): string | null | undefined;
+    getById(id: string): any;
+    getObjectUrl(url: string): any;
+    getBufferById(id: string): Promise<ArrayBuffer | null>;
+    getBlobById(id: string): Promise<Blob | null>;
+    loadFromStorage(object: any): Promise<boolean>;
+    getCacheKey(id: any, lodLevel: any): any;
+    _getLodLevelUrl(itemId: any, lodLevel: any): any;
+    loadItem(id: any, lodLevel: any, loadingProgressFunc: any): Promise<any>;
+    addItemToCache(id: string, lodLevel?: any, hash?: any, loadingProgressFunc?: Function): Promise<any>;
+    getObjectCount(): number;
+    getObjectSize(): number;
+    handleRename({ id, newName }: {
+        id: any;
+        newName: any;
+    }): void;
+}
+
+declare class FolderCache extends Storage {
+    apiClient: ApiClient;
+    ready: boolean;
+    maxNumItems: number;
+    constructor(apiClient: ApiClient);
+    init(): Promise<void>;
+    clear(): Promise<any>;
+    checkStorage(): Promise<void>;
+    getFolderListing(id: string): Promise<any>;
+    getItemListing(folderId: string): Promise<any>;
+    getFolderACLs(id: string, timeout: number): Promise<any>;
+    refreshCacheForFolder(folderId: string): Promise<void>;
+    addFolderListing(folderId: string, listing: any[]): Promise<void>;
+    addItemListing(folderId: string, itemListing: any): Promise<void>;
+    addACL(folderId: string, acls: any[]): Promise<void>;
+}
+
+declare class ThumbCache extends Storage {
+    apiClient: ApiClient;
+    constructor(apiClient: ApiClient);
+    clear(): void;
+    _loadThumbnail(size: number, id: string): Promise<any>;
+    get(id: string, size: number, hash?: string, timestamp?: number): Promise<any>;
+}
+
+declare class EventEmitter {
+    private _debugMode;
+    private _listeners;
+    private _onceListeners;
+    private _catchAllListeners;
+    private _capturedEvents;
+    private _capturedAccumulatedDuration;
+    constructor();
+    setDebugMode(mode: boolean): void;
+    $clear(): void;
+    clearCatchAllListeners(): void;
+    listenerCount(eventType: string): number;
+    $hasListener(eventType: string): boolean;
+    $catchAll(func: Function, owner: any): void;
+    $on(eventType: string, func: Function, owner?: any): void;
+    $once(eventType: string, func: Function, owner?: any): void;
+    $off(eventType: string, func: Function, owner?: any): number;
+    $offByOwner(eventType: string, owner?: any): number;
+    $emitSync(eventType: string, ...args: any[]): Promise<any[]> | null;
+    $emit(eventType: string, ...args: any[]): Promise<unknown>;
+}
+
+/**
+ * To generate the return type of a function based on the options that are
+ * supplied to it as an object, without having to define every combination
+ * manually, we use a generic mapped type that can determine the returned type
+ * at compile-time.
+ *
+ * The mapped type is complicated and consists of the following parts:
+ *
+ *
+ * A map of options and how they effect the returned type:
+ * type ItemOptionsMap = {
+ *      returnClonedFrom: { clonedFrom?: string },
+ *      withThumbnails: { thumbnails?: string[] };
+ *  };
+ *
+ * An object where every available item option is mapped to the type it accepts.
+ * This can be written by hand in case different options require different values,
+ * or it can be generated if they're all of the same type:
+ * type ItemOptions = {
+ *      [K in keyof ItemOptionsMap]?: boolean;
+ * };
+ *
+ * Turn an object of item options into a union of their values:
+ * type ItemOptionsUnion<O extends ItemOptions> = Extract<{
+ *      [K in keyof O]: O[K] extends true ? K : never
+ * }[keyof O], keyof ItemOptionsMap>;
+ *
+ * For example:
+ * {
+ *      returnClonedFrom: true,
+ *      withThumbnails: true
+ * }
+ * will be turned into: "returnClonedFrom" | "withThumbnails".
+ *
+ * Finally we can generate the return type from the base type (Item in this case)
+ * and the modifications based on the supplied options:
+ * type ItemWithOptions<O extends ItemOptions> = Item & UnionToIntersection<ItemOptionsMap[OptionsUnion<O>]>;
+ *
+ *
+ * To make this easier to use, these individual steps are combined into a OptionsUnion and OptionalResponses type.
+ * They can be used like this:
+ * type ItemWithOptions<O extends ItemOptions> = Item & OptionalResponses<ItemOptions, ItemOptionsMap, O>;
+ */
+type OptionsUnion<OptionParameters, SelectedOptions extends OptionParameters> = Extract<{
+    [K in keyof SelectedOptions]: SelectedOptions[K] extends (true | string) ? K : never;
+}[keyof SelectedOptions], keyof OptionParameters>;
+type OptionalResponses<OptionParameters, OptionResponses extends {
+    [Option in keyof OptionParameters]: any;
+}, SelectedOptions extends OptionParameters> = UnionToIntersection<OptionResponses[OptionsUnion<OptionParameters, SelectedOptions>]>;
+/**
+ * Turn a union of objects into an intersection of objects.
+ * Taken from https://stackoverflow.com/a/50375286.
+ */
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+type AllOrNothing<T> = {
+    [K in keyof T]?: never;
+} | T;
+
+type Acl = {
+    group?: string;
+    user?: string;
+    can: string[];
+}[];
+type Attachments = {
+    name?: string;
+    queryParam?: number;
+    index?: number;
+    perceptiveHash?: string;
+    filesize?: number;
+    mimeType?: string;
+    hash?: string;
+    storages?: string[];
+    storageHash?: string;
+}[];
+declare class Item {
+    _id: string;
+    name: string;
+    folder: string;
+    folderPath: string[];
+    links?: {
+        to: string;
+        usage: string;
+    }[];
+    attributes?: Record<string, unknown>;
+    userAttributes?: Record<string, unknown>;
+    filename?: string;
+    createdAt: string;
+    updatedAt: string;
+    version: {
+        major: number;
+        minor: number;
+        revision: number;
+    };
+    filesize?: number;
+    hash?: string;
+    mimeType?: string;
+    type: string;
+    packageType?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    acl?: Acl;
+    visibility: number;
+    properties: Record<string, string>;
+    allowConversation?: boolean;
+    conversation?: string;
+    tags?: string[];
+    contributors?: string[];
+    description?: string;
+    shortDescription?: string;
+    userAttributeTemplate?: string;
+    categories?: string[];
+    attachments?: Attachments;
+    license?: string;
+    quotaUser?: string;
+    quotaGroup?: string;
+    itemSize?: number;
+    totalSize?: number;
+    flags?: string[];
+    perceptiveHash?: string;
+    unpackagedSize?: number;
+    location?: string;
+    itemFlag?: {
+        isStaffPick: boolean;
+        isGame: boolean;
+        featureWeight: number;
+    };
+    constructor(data: any);
+}
+declare class AggregatedItem extends Item {
+    links?: {
+        to: string;
+        usage: string;
+        stopRecursion?: boolean;
+    }[];
+    thumbnails?: {
+        _id: string;
+        data: string;
+        size: number;
+    }[];
+    fieldSets?: {
+        name: string;
+        fields: any[];
+    }[];
+    fields?: any[];
+    userFields?: any[];
+    additionalUserAttributes?: Record<string, unknown>;
+    readonly isAggregatedItem: boolean;
+    constructor(data: any);
+}
+type ItemOptionsMap = {
+    returnClonedFrom: {
+        clonedFrom?: string;
+    };
+    withThumbnails: {
+        thumbnails?: string[];
+    };
+};
+type ItemOptions = {
+    returnClonedFrom?: boolean;
+    withThumbnails?: boolean;
+};
+type ItemWithOptions<O extends ItemOptions> = Item & OptionalResponses<ItemOptions, ItemOptionsMap, O>;
+type FolderListing = {
+    parent: {
+        _id: string;
+        name: string;
+        parent?: string;
+        createdAt: string;
+        createdBy?: string;
+        updatedAt: string;
+        updatedBy?: string;
+        acl?: Acl;
+    };
+    children: {
+        _id: string;
+        name: string;
+        parent?: string;
+        createdAt: string;
+        createdBy?: string;
+        updatedAt: string;
+        updatedBy?: string;
+        acl?: Acl;
+        contentSize?: number;
+        allowWrite?: boolean;
+        allowPublish?: boolean;
+    }[];
+};
+type FolderListingWithItem = {
+    children: {
+        item: {
+            _id: string;
+            name: string;
+            folder?: string;
+            visibility: number;
+            createdAt: string;
+            createdBy?: string;
+            updatedAt: string;
+            updatedBy?: string;
+            filesize?: number;
+            filename?: string;
+            acl?: Acl;
+            hash?: string;
+            mimeType?: string;
+            type: string;
+            packageType?: string;
+            allowConversation?: boolean;
+            attachments?: Attachments;
+        };
+    }[];
+};
+type FolderListingWithItemStats = {
+    children: {
+        item: {
+            counts: {
+                views?: number;
+                downloads?: number;
+                trafficBytes?: number;
+            };
+        };
+    }[];
+};
+type FolderListingWithItemLatestPackage = {
+    children: {
+        item: {
+            latestPackage?: string;
+        };
+    }[];
+};
+type FolderListingOptionsMap = {
+    resolveNames: {};
+    folderAsItemType: FolderListingWithItem;
+    folderAsItemName: FolderListingWithItem;
+    folderAsItemFlag: FolderListingWithItem;
+    withStats: FolderListingWithItemStats;
+    returnLatestPackage: FolderListingWithItemLatestPackage;
+};
+type FolderListingOptions = {
+    resolveNames?: boolean;
+    folderAsItemType?: string;
+    folderAsItemName?: string;
+    folderAsItemFlag?: string;
+    withStats?: boolean;
+    returnLatestPackage?: boolean;
+};
+type FolderListingWithOptions<O extends FolderListingOptions> = FolderListing & OptionalResponses<FolderListingOptions, FolderListingOptionsMap, O>;
+type ItemQuery = {
+    _id: string;
+    name: string;
+    type: string;
+    mimeType?: string;
+    packageType?: string;
+    hash?: string;
+    acl?: Acl;
+    visibility?: number;
+    folder?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    createdAt: string;
+    updatedAt: string;
+    quotaUser?: string;
+    quotaGroup?: string;
+    tags?: string[];
+    contributors?: string[];
+    categories?: string[];
+    links?: {
+        to: string;
+        usage: string;
+    }[];
+    license?: string;
+    filesize?: number;
+    filename?: string;
+    itemSize?: number;
+    totalSize?: number;
+}[];
+type ItemQueryOptionsMap = {
+    fulltext: {
+        score: number;
+    }[];
+    client: {};
+    types: {};
+    includePackagedTypes: {};
+    onlyPackagedTypes: {};
+    name: {};
+    folderName: {};
+    user: {};
+    categories: {};
+    licenses: {};
+    tags: {};
+    flags: {};
+    contributors: {};
+    anyCategories: {};
+    anyTags: {};
+    anyFlags: {};
+    anyContributors: {};
+    mimeType: {};
+    quotaUser: {};
+    quotaGroup: {};
+    attribute: {};
+    attributeValue: {};
+    userAttribute: {};
+    userAttributeValue: {};
+    withAttributes: {
+        attributes?: Record<string, unknown>;
+    }[];
+    withUserAttributes: {
+        userAttributes?: Record<string, unknown>;
+    }[];
+    withProperties: {
+        properties: Record<string, string>;
+    }[];
+    withAttachmentInfo: {
+        attachments: {
+            name?: string;
+            index?: number;
+            queryParam?: number;
+            filesize?: number;
+            mimeType?: string;
+            hash?: string;
+        }[];
+    }[];
+    withStats: {
+        counts: {
+            views?: number;
+            downloads?: number;
+            trafficBytes?: number;
+        };
+    }[];
+    withThumbnailCount: {
+        thumbnailCount: number;
+    }[];
+    withFolderName: {
+        folderName?: string;
+    }[];
+    withLatestPackage: {
+        latestPackage?: any;
+    }[];
+    resolveQuotaUser: {
+        quotaUserObject?: {
+            _id: string;
+            name: string;
+        };
+    }[];
+    resolveQuotaGroup: {
+        quotaGroupObject?: {
+            _id: string;
+            name: string;
+        };
+    }[];
+    userAttributeTemplate: {};
+    dateFrom: {};
+    dateTo: {};
+    sort: {};
+    sortOrder: {};
+    pageSize: {};
+    pageIndex: {};
+    isStaffPick: {
+        featureWeight?: number;
+    }[];
+};
+type ItemQueryOptionsBase = {
+    fullText?: string;
+    client?: string;
+    types?: string[];
+    includePackagedTypes?: boolean;
+    onlyPackagedTypes?: boolean;
+    name?: string;
+    folderName?: string;
+    user?: string;
+    categories?: string;
+    licenses?: string;
+    tags?: string[];
+    flags?: string[];
+    contributors?: string[];
+    anyCategories?: boolean;
+    anyTags?: boolean;
+    anyFlags?: boolean;
+    anyContributors?: boolean;
+    mimeType?: string;
+    quotaUser?: string;
+    quotaGroup?: string;
+    returnIdOnly?: boolean;
+    returnCountOnly?: boolean;
+    returnHashesAndDatesOnly?: boolean;
+    withAttributes?: boolean;
+    withUserAttributes?: boolean;
+    withProperties?: boolean;
+    withAttachmentInfo?: boolean;
+    withStats?: boolean;
+    withThumbnailCount?: boolean;
+    withFolderName?: boolean;
+    withLatestPackage?: boolean;
+    resolveQuotaUser?: boolean;
+    resolveQuotaGroup?: boolean;
+    userAttributeTemplate?: string;
+    dateFrom?: string;
+    dateTo?: string;
+    sort?: string;
+    sortOrder?: string;
+    pageSize?: number;
+    pageIndex?: number;
+    isStaffPick?: boolean;
+};
+type ItemQueryOptions = ItemQueryOptionsBase & AllOrNothing<{
+    attribute: string;
+    attributeValue: string;
+}> & AllOrNothing<{
+    userAttribute: string;
+    userAttributeValue: string;
+}>;
+type ItemQueryWithOptions<O extends ItemQueryOptions> = O["returnCountOnly"] extends true ? number : O["returnIdOnly"] extends true ? {
+    _id: string;
+}[] : O["returnHashesAndDatesOnly"] extends true ? {
+    _id: string;
+    hash?: string;
+    updatedAt: string;
+}[] : ItemQuery & OptionalResponses<ItemQueryOptions, ItemQueryOptionsMap, O>;
+type Me = {
+    _id: string;
+    name: string;
+    displayName?: string;
+    client: string;
+    clientId: string;
+    memberships: {
+        permissions?: string[];
+        admin?: boolean;
+        primary?: boolean;
+        contacts?: {
+            addedAt?: string;
+            user?: string;
+        }[];
+        client: string;
+        paymentSetup?: string;
+        storageQuotaGb?: number;
+        storageUsedGb?: number;
+        trafficQuotaGb?: number;
+        usedTrafficQuotaBytes?: number;
+        allowedJobtypes?: string[];
+        allowedDatatypes?: string[];
+        allowedFeatures?: string[];
+        attributes?: Record<string, unknown>;
+        properties?: Record<string, unknown>;
+    }[];
+    account: string;
+    superadmin?: boolean;
+    admin?: boolean;
+    location?: string;
+    permissions?: string[];
+    groups: {
+        _id: string;
+        name: string;
+        hasFolder: boolean;
+    }[];
+    emailToConfirm?: string;
+    emailConfirmationDate?: string;
+    paymentSetup?: {
+        cardInfo: {
+            last4?: string;
+            brand?: string;
+            exp_month?: number;
+            exp_year?: number;
+        };
+        currency: string;
+        address: {
+            email?: string;
+            name?: string;
+            street?: string;
+            zipcode?: string;
+            city?: string;
+            country?: string;
+        };
+    };
+    storageQuotaGb: number;
+    storageUsedGb: number;
+    features: string[];
+};
+type UserInfo = {
+    avatar?: string;
+    initials: string;
+    name?: string;
+    displayName?: string;
+    properties?: Record<string, unknown>;
+};
+type BaseBlogArticle = {
+    _id: string;
+    title: string;
+    tags: string[];
+    slug?: string;
+};
+type ProgressCallback = (percent: number, loaded: number, total: number | undefined) => void;
+type ConversationEntry = {
+    _id: string;
+    text: string;
+    createdBy: {
+        _id: string;
+        name: string;
+    };
+    createdAt: string;
+    liked: boolean;
+    numLikes?: number;
+    location?: string;
+};
+type JobState = {
+    _id: string;
+    state?: number;
+    error?: string;
+    log?: string;
+    progress?: number;
+    startedAt?: string;
+    stoppedAt?: string;
+    attempts?: number;
+};
+
+declare class UserCache {
+    apiClient: ApiClient;
+    cache: Map<string, Promise<UserInfo>>;
+    /**
+     *
+     * @param apiClient {ApiClient}
+     */
+    constructor(apiClient: ApiClient);
+    /**
+     *
+     * @param id {string}
+     * @return {Promise<*>}
+     */
+    resolve(id: string): Promise<UserInfo | undefined>;
+}
+
+declare class GroupCache {
+    apiClient: ApiClient;
+    cache: Map<string, any>;
+    constructor(apiClient: ApiClient);
+    resolve(id: string): Promise<any>;
+}
+
+declare class AttachmentCache {
+    apiClient: ApiClient;
+    cache: Map<string, any>;
+    constructor(apiClient: ApiClient);
+    get(itemId: string, attachmentName: string, queryParam: number, index: number, forcePublic?: boolean): Promise<any>;
+    invalidateAttachment(itemId: string, attachmentName: string, queryParam?: number, index?: number): void;
+}
+
+declare class JobEntry {
+    id: string;
+    job?: JobState;
+    nextCheckMs: number;
+    constructor(id: string, nextCheckMs: number, job?: JobState);
+}
+declare class JobManager {
+    apiClient: ApiClient;
+    jobs: Map<string, JobEntry>;
+    constructor(apiClient: any);
+    getJobs(): JobEntry[];
+    execute(type: string, elements: any[], parameters: any[], progressCallback?: Function | undefined): Promise<JobState>;
+}
+
+type PublishedVersion = {
+    itemId: string;
+    folderId: string;
+    version: string;
+    name: string;
+    filesize: number;
+    visibility: number;
+};
+declare class Publisher {
+    apiClient: ApiClient;
+    itemRepo: ItemRepo;
+    jobManager: JobManager;
+    items: any[];
+    hasExternalResources: boolean;
+    totalSize: number;
+    affectedFolderIds: Set<string>;
+    constructor(apiClient: ApiClient);
+    _updateQuota(): void;
+    getPreviousVersions(projectFolderId: string, subfolderName: string): Promise<PublishedVersion[]>;
+    verify(item: any): Promise<boolean>;
+    getItems(): any[];
+    unpackToProject(packageItemId: string, projectFolderId: string, subdirectoryName: string | undefined, updateCallback: Function | undefined): Promise<string | undefined>;
+    copyItemToProject(itemId: string, projectFolderId: string, subdirectoryName: string, updateCallback?: Function): Promise<string>;
+    copyItemsToProject(itemIds: any[], projectFolderId: string, subdirectoryName: string, updateCallback?: Function): Promise<{
+        oldId: string;
+        newId: string;
+    }[]>;
+    copyToProject(projectFolderId: string, subdirectoryName: string, updateCallback: Function | undefined): Promise<{
+        oldId: string;
+        newId: string;
+    }[]>;
+    unpublish(packageId: string): Promise<void>;
+    publish(item: any, name: string, projectFolderId: string, subfolderPath: string, makePublic: boolean, copyExternal: boolean, createNewPackage: boolean): Promise<void>;
+}
+
+declare class Snapshotable {
+    ownerItem: PreparedItem | undefined;
+    constructor(ownerItem?: PreparedItem | undefined);
+    createSnapshot(): void;
+    restoreFromSnapshot(snapshot: Snapshot, parent: any): void;
+    rollbackFromSnapshot(snapshot: Snapshot): void;
+    _getElementById(id: string, array: any[]): any;
+    _rollbackArray(array: any[], arraySnapshot: Snapshot[], elementCreator: any): void;
+}
+
+declare class ScriptField extends Snapshotable {
+    id: string;
+    name: string | undefined;
+    displayName: string | undefined;
+    value: any;
+    script: Script | undefined;
+    type: string | undefined;
+    datatype: string | undefined;
+    minValue: number | undefined;
+    maxValue: number | undefined;
+    order: number;
+    inject: any | undefined;
+    info: string | undefined;
+    constructor(script?: Script | undefined, name?: string | undefined, value?: any | undefined, item?: PreparedItem | undefined);
+    getId(): string;
+    setName(name: string | undefined): void;
+    setOrder(order: number): void;
+    setInfo(info: string): void;
+    clone(fieldOverrides?: Map<string, string>): ScriptField;
+    clearDefinition(): void;
+    setDefinition(def: any): void;
+    _toBoolean(value: any): any;
+    _updateDisplayName(): void;
+    _parseTypeParams(text: string, expectedCount: number): string[] | null;
+    createSnapshot(): Snapshot;
+}
+
+type ScriptItem = {
+    value: PreparedItem | undefined;
+    linkableItems: string[];
+    linkableTypes: string[];
+};
+declare class Script extends Snapshotable {
+    id: string | undefined;
+    block: Block | undefined;
+    fields: ScriptField[];
+    item: ScriptItem | null;
+    deferInitCall: boolean;
+    constructor(id?: string | Snapshot | undefined, block?: Block | undefined, item?: PreparedItem | undefined, scriptItem?: PreparedItem | undefined);
+    getId(): string | undefined;
+    makeIdsUnique(map: Map<string, string>, force?: boolean): void;
+    transformNodeIds(map: Map<string, string>): void;
+    clone(cloneIdMapping?: Map<string, string>): Script;
+    createFieldsFromDefinition(fieldDefArray?: any[]): void;
+    clearFieldTypes(): void;
+    addField(scriptField: ScriptField): void;
+    createSnapshot(): Snapshot;
+    restoreFromSnapshot(snapshot: Snapshot, block: Block | undefined): void;
+    rollbackFromSnapshot(snapshot: Snapshot): void;
+}
+
+declare class Block extends Snapshotable {
+    id: string;
+    parent: Block | undefined;
+    type: string | undefined;
+    name: string;
+    displayName: string;
+    fields: Field[];
+    blocks: Block[];
+    isSelected: boolean;
+    isExpanded: boolean;
+    scripts: Script[];
+    inputs: any[];
+    outputs: any[];
+    posX: number;
+    posY: number;
+    constructor(id?: string | Snapshot | undefined, parent?: Block | undefined, type?: string | undefined, name?: string | undefined, displayName?: string | undefined, item?: PreparedItem | undefined);
+    getId(): string;
+    refreshFieldDependencies(): void;
+    resetFieldValues(withChildren?: boolean): void;
+    makeIdsUnique(map?: Map<string, string>, force?: boolean): Map<string, string>;
+    transformNodeIds(map: Map<string, string>): void;
+    clone(proxyItem: PreparedItem | undefined, cloneScripts?: boolean, fieldOverrides?: any, keepBlockIds?: boolean): Block;
+    getDescendantBlocks(descendantBlocks?: Block[]): Block[];
+    setFields(fields: Field[]): void;
+    setInputs(inputs: any[]): void;
+    setOutputs(outputs: any[]): void;
+    setPosition(x: number, y: number): void;
+    setSelected(value: boolean): void;
+    setExpanded(value: boolean): void;
+    getRoot(): Block;
+    forEachField(func: (field: Field) => void): void;
+    findField(name: string): Field | null;
+    findBlock(id: string): Block | null;
+    removeBlock(block: Block): void;
+    addBlock(block: Block, position: number): void;
+    moveBlock(block: Block, position: number): void;
+    moveToPosition(position: number): void;
+    moveBlockToParent(newParent: Block, position?: number): void;
+    moveToParent(parentId: string, position?: number): void;
+    getField(name: string): Field | null;
+    hasTag(tag: string): boolean;
+    hasOneTag(tags: string[]): boolean;
+    getNameFieldValue(): any;
+    getActiveFieldValue(): any;
+    createSnapshot(dontRecurseIntoBlocks?: boolean): Snapshot;
+    restoreFromSnapshot(snapshot: Snapshot, parent: Block | undefined): void;
+    rollbackFromSnapshot(snapshot: Snapshot, dontRecurseIntoBlocks?: boolean): void;
+    _getFieldByName(name: string, fields: Field[]): Field | null;
+}
+
+declare class Connection extends Snapshotable {
+    id: string;
+    srcNode: string;
+    srcSlot: number;
+    destNode: string;
+    destSlot: number;
+    posX: number;
+    posY: number;
+    constructor(data: any, item: PreparedItem);
+    getId(): string;
+    setPosition(x: number, y: number): void;
+    getPosX(): number;
+    getPosY(): number;
+    getSrcNode(): string;
+    getDestNode(): string;
+    getSrcSlot(): number;
+    getDestSlot(): number;
+    setSrcNode(value: string): void;
+    setDestNode(value: string): void;
+    setSrcSlot(value: number): void;
+    setDestSlot(value: number): void;
+    clone(): Connection;
+    createSnapshot(): Snapshot;
+    restoreFromSnapshot(snapshot: Snapshot): void;
+    rollbackFromSnapshot(snapshot: Snapshot): void;
+}
+
+declare class ItemCache {
+    itemCache: Map<string, any>;
+    apiGateway: ApiGateway;
+    constructor(apiGateway: any);
+    clear(): void;
+    getItem(id: string): Promise<any>;
+}
+
+declare class LinkableItemsCache {
+    linkableItemsCache: Map<string, any[]>;
+    apiGateway: ApiGateway;
+    itemCache: ItemCache;
+    usePublicApi: boolean;
+    constructor(apiGateway: ApiGateway, itemCache: ItemCache, usePublicApi?: boolean);
+    clear(): void;
+    resolveItem(id: string, linkableItems: any[]): any;
+    loadLinkableItems(item: any, field: Field): Promise<any[] | undefined>;
+}
+
+declare class Template {
+    fields: Field[];
+    constructor(fields: Field[]);
+    clone(): Template;
+    /**
+     * Changes the default values of the template
+     * @param fieldValues object an object with new values for every field that should be changed
+     */
+    specialize(fieldValues: any): this;
+    instantiate(): Field[];
+}
+
+type TemplateEntry = {
+    typeName: string;
+    displayName: string;
+    template: Template;
+    inputs: any[];
+    outputs: any[];
+};
+
+declare class Field extends Snapshotable {
+    name: string;
+    displayName: string;
+    type: string | undefined;
+    info?: string;
+    preload: boolean;
+    loadingManagerRule: string;
+    item: PreparedItem | undefined;
+    itemRepo: ItemRepo | undefined;
+    condition: any;
+    conditionFields: Field[];
+    conditionFieldNames: string[];
+    dependantFields: Field[];
+    dependenciesInitialized: boolean;
+    linkableTypes: string[];
+    linkableItemsCache: LinkableItemsCache | undefined;
+    collapsed: boolean;
+    presets: any[];
+    datatype: string | null;
+    defaultValue: any;
+    minValue: any;
+    maxValue: any;
+    language: string | null;
+    widget: string | null;
+    length: number | null;
+    labelType: string | null;
+    blocks: Block[];
+    connections: Connection[];
+    templates: TemplateEntry[];
+    elementName: string | null;
+    private _id;
+    private _internalValue;
+    private _internalOptions;
+    private _updateConditions;
+    private _hidden;
+    get hidden(): boolean;
+    get id(): string;
+    get options(): string[];
+    set options(value: string[]);
+    get value(): any;
+    set value(value: any);
+    get linkableItems(): Promise<any[] | undefined> | never[];
+    constructor(name: string | Snapshot, displayName?: string | undefined, type?: string | undefined, value?: any | undefined, item?: PreparedItem | undefined, itemRepo?: ItemRepo | undefined, linkableItemsCache?: LinkableItemsCache | undefined);
+    updateConditions(): void;
+    getId(): string;
+    resetValue(): void;
+    makeIdsUnique(map?: Map<string, string>, force?: boolean): Map<string, string>;
+    transformNodeIds(map: any): void;
+    findBlock(id: any): Block | null;
+    clone(proxyItem?: PreparedItem | undefined, keepBlockIds?: boolean): Field;
+    _processDependencies(): void;
+    _getConditionField(name: string): Field | null;
+    _calculateConditionField(name: string, value: any): boolean;
+    _calculateConditionBlock(condition: any): boolean;
+    refreshFieldDependencies(): void;
+    refreshDependantFields(fieldMap: Map<string, Field>, dependantFields?: Field[]): void;
+    setCondition(condition: any): void;
+    _scanConditions(condition: any): void;
+    forEachField(func: (field: Field) => void): void;
+    setInfo(info: string): void;
+    setPreload(preload: boolean): void;
+    setLoadingManagerRule(rule: string): void;
+    setLinkableTypes(types: string[]): void;
+    setDefaultValue(value: any): void;
+    setMinValue(value: any): void;
+    setMaxValue(value: any): void;
+    setOptions(options: string[]): void;
+    setDatatype(datatype: string): void;
+    setLanguage(language: any): void;
+    setLength(length: any): void;
+    setWidget(widget: any): void;
+    setBlocks(blocks: any): void;
+    setConnections(connections: any): void;
+    setTemplates(templates: any): void;
+    setElementName(name: any): void;
+    setCollapsed(value: any): void;
+    setPresets(value: any): void;
+    setLabelType(value: string): void;
+    createSnapshot(dontRecurseIntoBlocks?: boolean): Snapshot;
+    restoreFromSnapshot(snapshot: Snapshot): void;
+    rollbackFromSnapshot(snapshot: any): void;
+}
+
+declare class PreparedItem extends AggregatedItem {
+    links?: {
+        to: string;
+        usage: string;
+        stopRecursion?: boolean;
+        item?: PreparedItem;
+    }[];
+    instanceId: string;
+    isDirty: boolean;
+    fieldInstances: Field[];
+    userFieldInstances: Field[];
+    packageContent?: PreparedItem;
+    packageType?: string;
+    public: boolean;
+    readOnly: boolean;
+    isPackaged: boolean;
+    packageItem?: PreparedItem;
+    readonly isPreparedItem: boolean;
+    resultingAcl?: Acl;
+    constructor(data: any);
+    markDirty(): void;
+    makeIdsUnique(): void;
+    clone(makeIdsUnique?: boolean): PreparedItem;
+    findBlock(id: string): Block | null;
+    refreshFieldDependencies(): void;
+    forEachItem(func: (item: PreparedItem) => void): void;
+    forEachFieldInstance(func: (field: Field) => void): void;
+    toString(): string;
+}
+
+declare class UploadItem {
+    name: string;
+    blob: Blob;
+    processing: boolean;
+    progress: number;
+    size: number;
+    type?: string;
+    collectionType?: string;
+    collectionEntryName?: string;
+    action?: string;
+    actions?: string[];
+    folderName?: string;
+    itemType?: string;
+    constructor(name: string, blob: Blob, ext: string);
+}
+type DetectionResult = {
+    valid: boolean;
+    assetType?: string;
+    itemCount?: number;
+    folderName?: string;
+    reason?: string;
+};
+type ItemEntry = {
+    _id: string;
+    name: string;
+    type: string;
+    size: number;
+    path: string;
+    item: PreparedItem;
+    external: boolean;
+};
+declare class AssetCreator {
+    apiClient: ApiClient;
+    itemRepo: ItemRepo;
+    jobManager: JobManager;
+    items: ItemEntry[];
+    mainItem: any;
+    totalSize: number;
+    oldMainItemId?: string;
+    originalItemIds: string[];
+    affectedFolderIds: Set<string>;
+    packageId?: string;
+    converter?: Function;
+    supportedExtensions: string[];
+    hasExternalResources: boolean;
+    constructor(apiClient: ApiClient);
+    _updateQuota(): void;
+    _addAffectedFolder(folder: any): void;
+    getAffectedFolderIds(): string[];
+    /**
+     * Return list of supported file extensions
+     * @return {*[string]}
+     */
+    getSupportedExtensions(): string[];
+    /**
+     * Set a converter function. That way items can be converted before uploading
+     * @param converter
+     */
+    setConverter(converter: Function): void;
+    setItems(items: any[]): void;
+    /**
+     * Scan an item Id for all required items that are linked by it. Returns a list of items
+     * @param itemId Item Id to search. Typically a project item.
+     * @return {Promise<[]|any[]|*>}
+     */
+    scan(itemId: string): Promise<ItemEntry[]>;
+    /**
+     * Get previously scanned items
+     * @return {[]|any[]|*}
+     */
+    getItems(): ItemEntry[];
+    /**
+     * Save the main item's changes back to cloud
+     * @return {Promise<void>}
+     */
+    saveMainItemChanges(): Promise<void>;
+    /**
+     * Create a folder for an asset.
+     * @param {number} rootFolderId Root folder id of where the asset should be created
+     * @param {string} path Path to the actual asset folder
+     * @return {Promise<*>} Promise that resolves to the folder's Id
+     */
+    createAssetFolder(rootFolderId: any, path: any): Promise<any>;
+    /**
+     * Creates the standard folder path for an asset based on type and name
+     * @param item
+     * @return {string}
+     */
+    createStandardAssetFolderPath(item: any): string;
+    /**
+     * Execute any actions on the items
+     * @return {Promise<void>}
+     */
+    executeActions(): Promise<any>;
+    /**
+     * Create an asset from already existing items
+     * @param {string} assetFolderId The asset folder's Id
+     * @param {boolean} moveItems Move the items or copy them.
+     * @param {function} updateCallback callback for progress. It will be passed the job object of the copy
+     * @return {Promise<*>}
+     */
+    createAsset(assetFolderId: string, moveItems?: boolean, updateCallback?: Function): Promise<any>;
+    /**
+     * Create a package from the main item. The package will have the name of the main item
+     * @param {string} subfolderPath subfolder path to where the package should be created. Default is published/<version>
+     * @param {boolean} makePublic make the package public. Default is true
+     * @param {boolean} copyExternal Copy external items into the package. Default is false
+     * @return {Promise<void>}
+     */
+    createPackage(subfolderPath: string, makePublic?: boolean, copyExternal?: boolean): Promise<void>;
+    /**
+     * Replace any references to the old main item id with the package id
+     * @return {Promise<void>}
+     */
+    replaceReferences(): Promise<void>;
+    /**
+     * Delete the original items
+     * @return {Promise<void>}
+     */
+    deleteOriginalItems(): Promise<void>;
+    /**
+     * Send a folder refresh event for all affected folders
+     */
+    sendFolderRefreshEvent(): void;
+    /**
+     * Process uploaded files and unpackage any included ZIP files. Returns a list of processed items with their type, blob
+     * and possible actions.
+     * @param {Array<File>} files files to process
+     * @return {Promise<*[]>} List of processed files
+     */
+    processUploads(files: File[]): Promise<UploadItem[]>;
+    /**
+     * Detect assets to be created from the processed files
+     * @param processedFiles
+     */
+    detectAssets(processedFiles: any[]): DetectionResult;
+    _filterUploadFiles(files: any[]): any[];
+    /**
+     * Create a new empty item with default values
+     * @return {Object}
+     */
+    createNewItem(): {
+        name: string;
+        type: string;
+        description: string;
+        shortDescription: string;
+        tags: never[];
+        flags: string[];
+        categories: never[];
+        license: string;
+        allowConversation: boolean;
+        version: {
+            major: number;
+            minor: number;
+            revision: number;
+        };
+    };
+    /**
+     * Create asset from processed files. If successful, this function will fill _id and folder fields in itemData and store it so it
+     * can be used with the createPackage() method.
+     * @param {Array<object>} processedFiles processed files list to use for the asset
+     * @param {string} assetBaseFolderId base folder ID for assets. Below this folder there will be an asset type folder like "textures" and then a folder for the asset.
+     * @param {Object} itemData item properties. most notable name and type
+     * @param {string} itemData.name name of the asset
+     * @param {string} itemData.type type of the asset. the processed files need to be compatible with that type
+     * @param {string} itemData.shortDescription
+     * @param {string} itemData.description
+     * @param {string} itemData.tags
+     * @param {string} itemData.categories
+     * @param {boolean} forceReplace if true, the asset will replace anything that already exists in the target location
+     * @param {boolean} [returnFolderInfo] if true, the function will return an object containing the item and the parent folder.
+     * @return {Promise<any>}
+     */
+    createAssetFromFiles(processedFiles: any[], assetBaseFolderId: string, itemData: any, forceReplace?: boolean, returnFolderInfo?: boolean): Promise<any>;
+}
+
+declare class Serializer {
+    apiClient: ApiClient;
+    itemRepo: ItemRepo;
+    constructor(apiClient: ApiClient);
+    /**
+     * Grab elements from the project and serialize them
+     * @param {PreparedItem} item source item to grab from
+     * @param {Field} field source field to grab from
+     * @param {Block[]} blocks the blocks to serialize
+     * @param {object} options
+     * @param {boolean} [options.withChildren] return children of block also
+     * @param {boolean} [options.returnArray] return result as array, not json string
+     * @param {boolean} [options.omitPath] don't return path
+     * @return {string|*[]}
+     */
+    grab(item: PreparedItem, field: Field, blocks: Block[], options: any): string | any[];
+    /**
+     * Put elements in the project
+     * @param msg the data to use to create new elements in the project
+     * @param field the field name
+     * @param targetBlock the target block to put the elements in case the data contains blocks
+     * @param {object} options
+     * @param {boolean} [options.dontCopyScripts] if true, scripts will not be copied
+     * @param {boolean} [putOptions.fieldOverrides] if true, field overrides will be applied to new blocks
+     */
+    put(msg: any, field: Field, targetBlock: Block, options?: any): Promise<any[]>;
+    /**
+     * Validate the clipboard message and parse it if necessary.
+     * @param msg the message to be validated
+     * @return {object}
+     */
+    validateMessage(msg: any): any;
+    /**
+     * Clone a block from the source block to the new parent block.
+     * @param {object} srcBlock source block to grab from
+     * @param {string} field source field to grab from
+     * @param {object} newParentBlock new parent block to place the cloned block into
+     * @param {PreparedItem} grabFromItem item to grab from.
+     * @param {object} putOptions
+     * @param {boolean} [putOptions.dontCopyScripts] if true, scripts will not be copied
+     * @param {boolean} [putOptions.fieldOverrides] if true, field overrides will be applied to new blocks
+     * @return {object}
+     */
+    clone(srcBlock: Block, field: Field, newParentBlock: Block, grabFromItem: PreparedItem, putOptions?: any): Promise<any[]>;
+    _updateScriptFieldReferences(oldBlockSerialized: any, newBlock: Block): void;
+    _putBlock(entry: any, field: Field, targetBlock: Block, options?: any, attachToParent?: boolean): Promise<any>;
+    _createUnproxifiedBlock(type: string, fieldOverrides: any, scriptsData: any[], field: Field, ownerItem: PreparedItem): Promise<Block | null>;
+    _proxifyAndAttachTree(root: Block, parent: Block, ownerItem: PreparedItem): any;
+    _findItemById(id: string): PreparedItem | undefined;
+    _findItemField(item: PreparedItem, fieldName: string): Field | null;
+    _findParentBlock(item: PreparedItem, fieldName: string, path: string): Block | null;
+    _getBlockTemplate(field: Field, name: string): TemplateEntry | null;
+    _getBlockIndex(block: Block): number;
+    _getBlockPath(block: Block): string;
+    private _serializeBlockFields;
+    private _serializeScripts;
+}
+
+declare const eventBus: EventEmitter;
+
+declare global {
+    interface Array<T> {
+        pushAll(array: Array<T>): void;
+        removeObject(obj: T): void;
+        moveObjectToArray(object: T, targetArray: T[], targetIndex?: number): boolean;
+        removeByFilterFunc(func: (t: T) => boolean): number;
+        clone(): Array<T>;
+    }
+}
+
+type CollabUser = {
+    id: string;
+    key: number;
+    name: string;
+    avatar?: string;
+    color: string;
+    itsMe: boolean;
+};
+declare class Collab {
+    apiClient: ApiClient;
+    collabDocument: CollabDocument;
+    yWebsocketProvider?: WebsocketProvider;
+    item?: PreparedItem;
+    awareness?: awarenessProtocol.Awareness;
+    users: CollabUser[];
+    avatars: Map<string, string | undefined>;
+    constructor(apiClient: ApiClient);
+    isActive(): boolean;
+    getAwarenessStates(): Map<number, {
+        [p: string]: any;
+    }>;
+    getUsersList(): CollabUser[];
+    private _getUser;
+    getLocalState(): {
+        [x: string]: any;
+    } | null;
+    setLocalStateField(key: string, value: any): void;
+    private _updateUsersList;
+    startCollaboration(item: PreparedItem): Promise<boolean>;
+    endCollaboration(): void;
+}
+
+/**
+ * @fileoverview ApiClient class for handling API interactions with the Lumino cloud service.
+ * @module ApiClient
+ */
+
+/**
+ * Enumeration for item visibility levels.
+ * @readonly
+ * @enum {number}
+ */
+declare const ItemVisibility: {
+    Draft: number;
+    Private: number;
+    NotListed: number;
+    Public: number;
+};
+
+type ApiClientOptions = {
+    host: "auto" | string;
+    viewerHost: "auto" | string;
+    collabHost: "auto" | string;
+    accessToken: string | null;
+    apiToken: string | null;
+    https: boolean;
+    wsAutoReconnect: boolean;
+    wsAutoConnect: boolean;
+    viewerHttps: boolean;
+    collabHttps: boolean;
+    forcePublicApi: boolean;
+    usePersistentStorage: boolean;
+    storageSizeMib: number;
+    requestClientId: string | null;
+    path: string;
+    websocketPath: string;
+    debug: boolean;
+};
+/**
+ * Class representing an ApiClient.
+ * @extends EventEmitter
+ */
+declare class ApiClient extends EventEmitter {
+    accessToken: string | null;
+    apiToken: string | null;
+    options: ApiClientOptions;
+    forcePublicApi: boolean;
+    usePublicApi: boolean;
+    usePersistentStorage: boolean;
+    storageSizeMib: number;
+    requestClientId: string | null;
+    webProtocol: "https" | "http";
+    wsProtocol: "wss" | "ws";
+    viewerProtocol: "https" | "http";
+    collabProtocol: "wss" | "ws";
+    restUrl: string;
+    wsUrl: string;
+    viewerUrl: string;
+    collabUrl: string;
+    itemRepo: ItemRepo;
+    itemCache: ItemCache$1;
+    folderCache: FolderCache;
+    thumbCache: ThumbCache;
+    userCache: UserCache;
+    groupCache: GroupCache;
+    attachmentCache: AttachmentCache;
+    jobManager: JobManager;
+    serializer: Serializer;
+    collab: Collab;
+    eventBus: typeof eventBus;
+    api: AxiosInstance;
+    ws: WebSocket | null;
+    cachedMe: Me | null;
+    profiler: {
+        start: (name: string, msg: string) => {
+            done: () => void;
+        };
+    } | null;
+    wsLastPing: Date | null;
+    last2faCode: string;
+    /**
+     * Create an ApiClient.
+     * @param {Object} options - Configuration options.
+     */
+    constructor(options?: Partial<ApiClientOptions>);
+    initCaches(): Promise<[void, void, any]>;
+    clearCaches(): void;
+    isDevPlatform(): boolean;
+    isOnLocalhost(): boolean;
+    isDevOrLocalhost(): boolean;
+    clearIndexedDb(name: string): Promise<void>;
+    logout(): Promise<void>;
+    setDebugMode(mode: boolean): void;
+    /**
+     * Connect to the websocket.
+     * @param {boolean} force - Force reconnection if already connected.
+     */
+    websocketConnect(force?: boolean): void;
+    /**
+     * Disconnect from the websocket.
+     */
+    websocketDisconnect(): void;
+    /**
+     * Send a message over the websocket.
+     * @param data - The message to send.
+     */
+    websocketSend(data: string): void;
+    getCollab(): Collab;
+    getCollabUrl(): string;
+    /**
+     * Get a new Publisher instance.
+     * @returns {Publisher} The Publisher instance.
+     */
+    getPublisher(): Publisher;
+    /**
+     * Get a new AssetCreator instance
+     * @return {AssetCreator} The AssetCreator instance.
+     */
+    getAssetCreator(): AssetCreator;
+    /**
+     * Get the Job Manager instance.
+     * @returns {JobManager} The Job Manager instance.
+     */
+    getJobManager(): JobManager;
+    /**
+     * Get the Thumbnail Cache instance.
+     * @returns {ThumbCache} The Thumbnail Cache instance.
+     */
+    getThumbCache(): ThumbCache;
+    /**
+     * Get the Item Cache instance.
+     * @returns {ItemCache} The Item Cache instance.
+     */
+    getItemCache(): ItemCache$1;
+    /**
+     * Get the Item Repository instance.
+     * @returns {ItemRepo} The Item Repository instance.
+     */
+    getItemRepo(): ItemRepo;
+    /**
+     * Get the visibility of the root item.
+     * @returns {number} The visibility level.
+     */
+    getRootVisibility(): number;
+    /**
+     * Get the Event Bus instance.
+     * @returns {Object} The Event Bus instance.
+     */
+    getEventBus(): EventEmitter;
+    /**
+     * Retrieve instance of the serializer
+     * @return {*}
+     */
+    getSerializer(): Serializer;
+    /**
+     * Set the force public API option.
+     * @param {boolean} value - The value to set.
+     */
+    setForcePublicApi(value: any): void;
+    /**
+     * Update the use of the public API based on the current configuration.
+     * @private
+     */
+    _updateUsePublicApi(): void;
+    /**
+     * Set the API token.
+     * @param {string} token - The API token.
+     */
+    setApiToken(token: any): void;
+    /**
+     * Set the access token.
+     * @param {string} token - The access token.
+     */
+    setAccessToken(token: any): void;
+    /**
+     * Get the API token.
+     * @returns {string} The API token.
+     */
+    getApiToken(): string | null;
+    /**
+     * Get the access token.
+     * @returns The access token.
+     */
+    getAccessToken(): string | null;
+    /**
+     * Update the base URL.
+     * @param {string} host - The new host.
+     */
+    updateBaseUrl(host: any): void;
+    /**
+     * Set the API base URL.
+     * @param url - The new API base URL.
+     */
+    setApiBaseUrl(url: string): void;
+    /**
+     * Set the WebSocket base URL.
+     * @param {string} url - The new WebSocket base URL.
+     */
+    setWsBaseUrl(url: any): void;
+    /**
+     * Set the request client ID.
+     * @param {string} id - The client ID.
+     */
+    setRequestClientId(id: any): void;
+    /**
+     * Get the API base URL.
+     * @returns {string} The API base URL.
+     */
+    getApiBaseUrl(): string;
+    /**
+     * Get the WebSocket base URL.
+     * @returns {string} The WebSocket base URL.
+     */
+    getWsBaseUrl(): string;
+    /**
+     * Get the viewer base URL.
+     * @returns {string} The viewer base URL.
+     */
+    getViewerBaseUrl(): string;
+    /**
+     * Set the profiler.
+     * @param {Object} profiler - The profiler instance.
+     * @throws {Error} If the profiler does not provide a start function.
+     */
+    setProfiler(profiler: any): void;
+    /**
+     * Logs in a user using two-factor authentication.
+     *
+     * @param account - The account identifier (username or email).
+     * @param password - The account password.
+     * @param client - The client identifier.
+     */
+    login2FA(account: string, password: string, client: string): Promise<void>;
+    /**
+     * Confirms the two-factor authentication code for a user.
+     *
+     * @param account - The account identifier (username or email).
+     * @param code - The 2FA code.
+     * @returns The session token.
+     */
+    confirm2FA(account: string, code: string): Promise<string>;
+    /**
+     * Checks if the user is authenticated.
+     *
+     * @returns {boolean} - True if the user is authenticated, false otherwise.
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Checks if a feature is enabled. For this to work, cachedMe must be filled so at least one
+     * call to me() must have been made.
+     * @param feature
+     */
+    isFeatureEnabled(feature: any): boolean;
+    /**
+     * Resolves the user or group information for a given item.
+     *
+     * @param {Object} item - The item containing user or group information.
+     * @param {string} item.quotaUser - The user quota identifier.
+     * @param {string} item.quotaGroup - The group quota identifier.
+     * @param {string} item.createdBy - The identifier of the user who created the item.
+     * @returns {Promise<Object>} - A promise that resolves to an object containing the resolved user or group information.
+     */
+    resolveUserOrGroupInfoForItem(item: any): Promise<any>;
+    /**
+     * Start an operation that is being monitored for its running time. If it runs too long, events will be produced.
+     * @param name
+     * @return {{runningMs: number, name, startTimeMs: DOMHighResTimeStamp, finish: op.finish, reportProgress: op.reportProgress, percent: number}}
+     * @private
+     */
+    _startOp(name: any): {
+        id: string;
+        name: any;
+        startTimeMs: number;
+        runningMs: number;
+        percent: number;
+        reportProgress: (percent: any) => void;
+        interval: NodeJS.Timeout | null;
+        finish: () => void;
+    };
+    _createOpName(method: any, resource: any): string;
+    addAuthenticationHeaders(headers: any): void;
+    /**
+     * Execute an API request.
+     * @param method - HTTP method.
+     * @param resource - API resource path.
+     * @param data - Request payload.
+     * @param options - Options object
+     * @param options.responseType - Response type.
+     * @param options.withNext - Include pagination cursor.
+     * @param options.progressCallback - Upload progress callback.
+     * @param options.emitOnSuccess - Event to emit on success
+     * @param options.headers - Additional headers to send
+     * @param options.controller - Abort controller for the request.
+     * @returns The response data.
+     */
+    execute(method: string, resource: string, data?: unknown, options?: Partial<{
+        responseType: ResponseType;
+        withNext: boolean;
+        progressCallback?: ProgressCallback;
+        emitOnSuccess: string;
+        headers: {
+            [key: string]: string;
+        };
+        controller: AbortController;
+        opName: string;
+    }>): Promise<any>;
+    /**
+     * Create a FormData instance from a buffer or file.
+     * @param {Buffer|Blob} data - The file data
+     * @param {string} filename - The filename.
+     * @returns {FormData} The FormData instance.
+     * @private
+     */
+    _createFormData(data: any, filename?: string): FormData;
+    /**
+     * Get the current user details.
+     * @returns {Promise<Object>} The user details.
+     */
+    me(useFromCache: boolean): Promise<Me>;
+    /**
+     * Get the home folder.
+     * @returns The ID of the home folder.
+     */
+    getHomeFolder(): Promise<string>;
+    /**
+     * Get the list of clients for the current user.
+     * @returns {Promise<Array>} The list of clients.
+     */
+    myClients(): Promise<any>;
+    getCollabToken(): Promise<any>;
+    checkCollabToken(token: string): Promise<any>;
+    /**
+     * Register a new user.
+     * @param data - The registration data.
+     * @param data.account - The email address.
+     * @param data.password - The password.
+     * @param data.name - The unique username.
+     * @param data.country - The country code for the new user.
+     * @param data.clientInvitationToken - Optionally a token to be added to a
+     * client automatically once this account is activated.
+     */
+    register(data: {
+        account: string;
+        password: string;
+        name: string;
+        country: string;
+        clientInvitationToken?: string;
+    }): Promise<void>;
+    /**
+     * Delete the current user account.
+     * @param password - The password for confirmation.
+     */
+    deleteMyAccount(password: string): Promise<void>;
+    /**
+     * Confirm the user's email.
+     * @param token - The email confirmation token.
+     */
+    confirmEmail(token: string): Promise<void>;
+    /**
+     * Confirm the change of email.
+     * @param token - The email change confirmation token.
+     */
+    confirmEmailChange(token: string): Promise<void>;
+    /**
+     * Request a password reset.
+     * @param email - The user's email.
+     * @param [optionalClientId] - Optional client ID.
+     */
+    forgotPassword(email: string, optionalClientId?: string): Promise<void>;
+    /**
+     * Set a new password using a token.
+     * @param token - The password reset token.
+     * @param password - The new password.
+     */
+    setNewPassword(token: string, password: string): Promise<void>;
+    /**
+     * Check if an account exists.
+     * @param data - The account data.
+     * @param data.account - The account to check for.
+     * @returns A boolean indicating if an account exists.
+     */
+    accountExists(data: {
+        account: string;
+    }): Promise<boolean>;
+    /**
+     * Get items in a folder.
+     * @param {string} folderId - The folder ID.
+     * @param {boolean} [forceReload] - Forces the reload of the data, so no cached data is used
+     * @returns {Promise<Array>} The list of items.
+     */
+    getItemsInFolderList(folderId: string, forceReload?: boolean): Promise<any>;
+    /**
+     * Get an item by ID.
+     * @param id - The item ID.
+     * @param options - Can be either an object with options or true to return the clonedFrom field.
+     * @param options.returnClonedFrom - If the clonedFrom field should be returned.
+     * @param options.withThumbnails - Return thumbnails array
+     * @returns The item details.
+     */
+    getItem<O extends ItemOptions>(id: string, options?: O): Promise<ItemWithOptions<O>>;
+    /**
+     * Get aggregated item data, using public or authenticated API based on configuration.
+     * @param {string} id - The item ID.
+     * @param {Object} [options] - Query options.
+     * @returns {Promise<Object>} The aggregated item data.
+     */
+    getItemAggregatedPOP(id: any, options: any): Promise<any>;
+    /**
+     * Get aggregated item data from the public API.
+     * @param {string} id - The item ID.
+     * @param {Object} [options] - Query options.
+     * @returns {Promise<Object>} The aggregated item data.
+     */
+    getItemPublicAggregated(id: any, options: any): Promise<any>;
+    /**
+     * Get aggregated item data from the authenticated API.
+     * @param {string} id - The item ID.
+     * @param {Object} [options] - Query options.
+     * @param {boolean} [options.withFieldInstances] - Return field instances
+     * @param {boolean} [options.withAttachmentInfo] - Return attachment information
+     * @param {boolean} [options.noAttributes] - Return no attributes
+     * @param {boolean} [options.noUserAttributes] - Return no user attributes
+     * @param {boolean} [options.noFields] - Return no field data
+     * @param {boolean} [options.noThumbnails] - Return no thumbnail data
+     * @param {boolean} [options.noLinks] - Return no link data
+     * @returns {Promise<Object>} The aggregated item data.
+     */
+    getItemAggregated(id: any, options: any): Promise<any>;
+    /**
+     * Get recursively aggregated item data.
+     * @param {string} id - The item ID.
+     * @param {Object} [options] - Query options.
+     * @param {boolean} [options.withFieldInstances] - Return field instances
+     * @param {boolean} [options.withAttachmentInfo] - Return attachment information
+     * @param {boolean} [options.noAttributes] - Return no attributes
+     * @param {boolean} [options.noUserAttributes] - Return no user attributes
+     * @param {boolean} [options.noFields] - Return no field data
+     * @param {boolean} [options.noThumbnails] - Return no thumbnail data
+     * @returns {Promise<Object>} The recursively aggregated item data.
+     */
+    getItemAggregatedRecursive(id: any, options: any): Promise<any>;
+    /**
+     * Get recursively aggregated public item data.
+     * @param {string} id - The item ID.
+     * @param {boolean} [withFeatures] - Include features.
+     * @returns {Promise<Object>} The recursively aggregated public item data.
+     */
+    getItemPublicRecursive(id: any, withFeatures: any): Promise<any>;
+    /**
+     * Get public item data.
+     * @param {string} id - The item ID.
+     * @param {boolean} [returnClonedFrom] - If the clonedFrom field should be returned.
+     * @returns {Promise<Object>} The public item data.
+     */
+    getItemPublic<O extends boolean>(id: string, returnClonedFrom?: O): Promise<{
+        _id: string;
+        links?: {
+            to: string;
+            usage: string;
+        }[];
+        attributes?: Record<string, unknown>;
+        userAttributes?: Record<string, unknown>;
+        name: string;
+        folder: string;
+        filename?: string;
+        createdAt: string;
+        updatedAt: string;
+        version?: {
+            major: number;
+            minor: number;
+            revision: number;
+        };
+        filesize?: number;
+        hash?: string;
+        mimeType?: string;
+        type: string;
+        packageType?: string;
+        properties: Record<string, string>;
+        description?: string;
+        flags?: string[];
+        shortDescription?: string;
+        tags?: string[];
+        contributors?: string[];
+        userAttributeTemplate?: string;
+        attachments?: Attachments;
+        itemSize?: number;
+        totalSize?: number;
+        allowConversation?: boolean;
+        itemFlag?: {
+            isStaffPick: boolean;
+            isGame: boolean;
+            featureWeight: number;
+        };
+        unpackagedSize?: number;
+        conversation?: string;
+        categories?: string[];
+        createdBy?: string;
+        quotaUser?: string;
+        quotaGroup?: string;
+        license?: string;
+    } & (O extends true ? {
+        clonedFrom?: string;
+    } : {})>;
+    /**
+     * Get item history.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The item history.
+     */
+    getItemHistory(id: any): Promise<any>;
+    /**
+     * Create a new item.
+     * @param data - The item data.
+     * @param data.type - The type of the item. For example "Image", "Mesh", "Material", etc.
+     * @param data.name - The name of the item
+     * @param data.folder - The folder ID of the item or null/undefined if it should be in the root folder
+     * @param [data.itemTemplate] - Item template to use, if any
+     * @param [data.version] - Version of the item, has to be an object. Example: { major: 0, minor: 0, revision: 1}
+     * @param [data.visibility] - Visibility of the object. Default is Private
+     * @param [data.allowConversation] - True, if this item should allow conversations
+     * @param [data.fixNameCollisions] - Fix name collisions. If the item name exists already, an index will be appended
+     * @param [data.overwrite] - Overwrite item if it is already existing. Should not be used together with fixNameCollisions
+     * @param [data.client] - Client ID for the item. Default client will be used if omitted
+     * @param [data.userAttributeTemplate] - User attribute templated to be used
+     * @param [data.flags] - Flags for the new item
+     * @returns The created item ID.
+     */
+    createItem(data: {
+        name: string;
+        type: string;
+        itemTemplateId?: string;
+        itemTemplateReplacements?: any;
+        version?: {
+            major: number;
+            minor: number;
+            revision: number;
+        };
+        folder?: string;
+        visibility?: number;
+        allowConversation?: boolean;
+        fixNameCollisions?: boolean;
+        overwrite?: boolean;
+        client?: string;
+        userAttributeTemplate?: string;
+        flags?: string[];
+        acl?: Acl;
+        attributes?: Item["attributes"];
+        userAttributes?: Item["userAttributes"];
+        links?: Item["links"];
+    }): Promise<string>;
+    /**
+     * Update an existing item.
+     * @param data - The item data.
+     * @returns The new version of the item.
+     */
+    updateItem(data: {
+        _id: string;
+        name: string;
+        version?: {
+            major: number;
+            minor: number;
+            revision: number;
+        };
+        description?: string;
+        shortDescription?: string;
+        tags?: string[];
+        contributors?: string[];
+        flags?: string[];
+        visibility?: number;
+        allowConversation?: boolean;
+        userAttributeTemplateId?: string;
+        categories?: string[];
+        license?: string;
+        acl?: Acl;
+        links?: {
+            to: string;
+            usage: string;
+        }[];
+        attributes?: Record<string, unknown>;
+        userAttributes?: Record<string, unknown>;
+        properties?: Record<string, string>;
+    }): Promise<{
+        version: {
+            major: number;
+            minor: number;
+            revision: number;
+        };
+    }>;
+    /**
+     * Delete an item by ID.
+     * @param id - The item ID or an array of item IDs.
+     * @returns The deletion response.
+     */
+    deleteItem(id: string | string[]): Promise<void>;
+    /**
+     * Rename item
+     * @param id - The item ID.
+     * @param name - The new item name.
+     * @returns The new version of the item.
+     */
+    renameItem(id: string, name: string): Promise<{
+        version: {
+            major: number;
+            minor: number;
+            revision: number;
+        };
+    }>;
+    /**
+     * Query public items list.
+     * @param query - The query parameters.
+     * @returns The list of items.
+     */
+    queryPublicItemsList<O extends ItemQueryOptions>(query: O): Promise<ItemQueryWithOptions<O>>;
+    /**
+     * Query items list, using public or authenticated API based on configuration.
+     * @param query - The query parameters.
+     * @returns The list of items.
+     */
+    queryItemsListPOP<O extends ItemQueryOptions>(query: O): Promise<ItemQueryWithOptions<O>>;
+    /**
+     * Query items list.
+     * @param query - The query parameters.
+     * @returns The list of items.
+     */
+    queryItemsList<O extends ItemQueryOptions>(query: O): Promise<ItemQueryWithOptions<O>>;
+    /**
+     * Query items list and export as Excel.
+     * @param {Object} query - The query parameters.
+     */
+    queryItemsListAsExcel(query: any): Promise<void>;
+    /**
+     * Move items to a different folder.
+     * @param {Object} data - The move data.
+     * @param {Array<string>} data.items - An array of item IDs
+     * @param {string} [data.dest] - The destination folder. If omitted, the destination folder is the root folder
+     * @returns {Promise<number>} The amount of moved items
+     */
+    moveItems(data: any): Promise<any>;
+    /**
+     * Download an item by ID.
+     * @param {string} id - The item ID.
+     * @param {Function} [progressCallback] - Download progress callback.
+     * @returns {Promise<Blob>} The downloaded item.
+     */
+    downloadItem(id: string, progressCallback?: ProgressCallback): Promise<any>;
+    /**
+     * Download a public item by ID.
+     * @param {string} id - The item ID.
+     * @param {Function} [loadingProgressFunc] - Download progress callback.
+     * @returns {Promise<Blob>} The downloaded item.
+     */
+    publicDownloadItem(id: any, loadingProgressFunc?: ProgressCallback): Promise<any>;
+    /**
+     * Get the hash of an item by ID.
+     * @param {string} id - The item ID.
+     * @returns {Promise<string>} The item hash.
+     */
+    getItemHash(id: any): Promise<any>;
+    /**
+     * Request a secure download for an item.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The request response.
+     */
+    requestSecureDownload(id: any): Promise<any>;
+    /**
+     * Get a thumbnail for an item.
+     * @param {string} size - The thumbnail size.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Blob>} The thumbnail.
+     */
+    getThumbnail(size: any, id: any): Promise<any>;
+    /**
+     * Upload a single thumbnail for an item
+     * @param {string} id - The item ID.
+     * @param {number} size - The thumbnail size.
+     * @param {Buffer|File} bufferOrFile - The file buffer or file.
+     * @param {string} filename - The filename.
+     * @param {Function} [progressCallback] - Upload progress callback.
+     * @param {AbortController} [controller] - Abort controller for the request.
+     * @returns {Promise<Object>} The response.
+     */
+    uploadThumbnail(id: string, size: number, bufferOrFile: any, filename?: string, progressCallback?: ProgressCallback, controller?: AbortController): Promise<any>;
+    /**
+     * Get a public thumbnail for an item.
+     * @param {string} size - The thumbnail size.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Blob>} The thumbnail.
+     */
+    getPublicThumbnail(size: any, id: any): Promise<any>;
+    /**
+     * Make an item public.
+     * @param id - single ID or list of IDs
+     * @param recursive - Apply to sub-items.
+     * @param inSubfolders - Apply to items in subfolders.
+     */
+    makeItemPublic(id: string, recursive: boolean, inSubfolders: boolean): Promise<void>;
+    /**
+     * Change item visibility
+     * @param id single ID or list of IDs
+     * @param visibility visibility. 0 = Draft, 1 = Private, 2 = Not listed, 3 = Public
+     * @param recursive
+     * @param inSubfolders
+     * @return {Promise<Object>}
+     */
+    setVisibility(id: any, visibility: any, recursive: any, inSubfolders: any): Promise<any>;
+    /**
+     * Make an item private.
+     * @param {string} id - single ID or list of IDs
+     * @param {boolean} recursive - Apply to sub-items.
+     * @param {boolean} inSubfolders - Apply to items in subfolders.
+     * @returns {Promise<Object>} The response.
+     */
+    makeItemPrivate(id: any, recursive: any, inSubfolders: any): Promise<any>;
+    /**
+     * Set omit LOD generation for an item, so the renderjobagentt wont process it again.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The response.
+     */
+    setOmitLodGeneration(id: any, value: any): Promise<any>;
+    /**
+     * Set omit thumbnail generation for an item, so the renderjobagentt wont process it again.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The response.
+     */
+    setOmitThumbnailGeneration(id: any, value: any): Promise<any>;
+    /**
+     * Set omit preview generation for an item, so the renderjobagentt wont process it again.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The response.
+     */
+    setOmitPreviewGeneration(id: any, value: any): Promise<any>;
+    /**
+     * Upload a file and create a new item.
+     * @param {string} folderId - The folder ID.
+     * @param {Buffer|Blob} data - The file data
+     * @param {string} filename - The filename.
+     * @param {Object} [options] - Options for the item
+     * @param {number} [options.autoDestructIn] - Auto-destruct time in minutes.
+     * @param {ItemVisibility} [options.visibility] - Visibility of the object. Default is Private
+     * @param {string} [options.nameOverride] - Override the name of the created item. Default is filename without extension
+     * @param {string} [options.flags] - Item flags to use
+     * @param {boolean} [options.overwrite] - Overwrite item if already existing.
+     * @param {Function} [progressCallback] - Upload progress callback.
+     * @param {AbortController} [controller] - Abort controller for the request.
+     * @returns {Promise<Object>} The created item.
+     */
+    uploadAndCreate(folderId: string, data: any, filename: string, options: any, progressCallback?: ProgressCallback, controller?: AbortController): Promise<any>;
+    /**
+     * Upload a file to an existing item.
+     * @param itemId - The item ID.
+     * @param bufferOrFile - The file buffer or file.
+     * @param filename - The filename.
+     * @param [progressCallback] - Upload progress callback.
+     * @param [controller] - Abort controller for the request.
+     * @param [options.omitHandleDependencyChange] - If true, will not cause previews and thumbnails to rerender
+     * @param [options.keepThumbnails] - If true, will not remove thumbnails to be rerendered
+     */
+    upload(itemId: string, bufferOrFile: Buffer | File | Blob | string, filename: string, progressCallback?: ProgressCallback, controller?: AbortController, options?: {
+        omitHandleDependencyChange?: boolean;
+        keepThumbnails?: boolean;
+    }): Promise<void>;
+    /**
+     * Clear the preview for an item and mark it for preview regeneration.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Array<Object>>} The responses.
+     */
+    resetPreview(id: any): Promise<[any, any]>;
+    /**
+     * Clear the preview for an item and omit preview generation.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Array<Object>>} The responses.
+     */
+    clearPreview(id: any): Promise<[any, any]>;
+    /**
+     * Clear the thumbnail for an item.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The response.
+     */
+    clearThumbnail(id: any): Promise<any>;
+    /**
+     * Clear the thumbnail for an item and mark it for thumbnail regeneration.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The response.
+     */
+    resetThumbnail(id: any): Promise<any>;
+    /**
+     * Download an attachment of an item.
+     * @param {string} id - The item ID.
+     * @param {string} name - The attachment name.
+     * @param {number} queryParam - The attachment query parameter. Might be a dimension or index, based on the attachment type.
+     * @param {number} index - The attachment index.
+     * @param {Function} [progressCallback] - Download progress callback.
+     * @returns {Promise<Blob>} The downloaded attachment.
+     */
+    downloadAttachmentPOP(id: string, name: string, queryParam?: number, index?: number, progressCallback?: ProgressCallback): Promise<any>;
+    _getAttachmentUrlPath(id: string, name: string, queryParam?: number, index?: number, isPublic?: boolean): string;
+    /**
+     * Download attachment
+     * @param id - The item ID.
+     * @param name - The attachment name.
+     * @param queryParam - The attachment query parameter. Might be a dimension or index, based on the attachment type.
+     * @param index - The (optional) index of the attachment of that type/name. If not provided, defaults to 0.
+     * @param [progressCallback] - Download progress callback.
+     * @returns The attachment data.
+     */
+    downloadAttachment(id: string, name: string, queryParam?: number, index?: number, progressCallback?: ProgressCallback): Promise<{
+        blob: Blob;
+    }>;
+    /**
+     * Download public attachment
+     * @param {string} id - The item ID.
+     * @param {string} name - The attachment name.
+     * @param {number} queryParam - The attachment query parameter. Might be a dimension or index, based on the attachment type.
+     * @param {number} index - The (optional) index of the attachment of that type/name. If not provided, defaults to 0.
+     * @param {Function} [progressCallback] - Download progress callback.
+     * @returns {Promise<Blob>} The downloaded attachment.
+     */
+    downloadPublicAttachment(id: string, name: string, queryParam?: number, index?: number, progressCallback?: ProgressCallback): Promise<any>;
+    /**
+     * Upload an attachment to an item. This endpoint needs admin permissions.
+     * @param {string} id - Id of the item to attach the file to
+     * @param {string} name - Name of the attachment
+     * @param {string} queryParam - Query param of the attachment
+     * @param {number} index - Index of the attachment
+     * @param {Buffer|File} bufferOrFile - The file buffer or file.
+     * @param {string} filename - The filename.
+     * @param {Function} [progressCallback] - Upload progress callback.
+     * @param {AbortController} [controller] - Abort controller for the request.
+     * @return {Promise<Object>}
+     */
+    uploadAttachment(id: string, name: string, queryParam?: number, index?: number, bufferOrFile?: any, filename?: string, progressCallback?: ProgressCallback, controller?: AbortController): Promise<any>;
+    /**
+     * Invalidates attachment in attachmentCache and then deletes attachment
+     * @param {string} id - The item ID.
+     * @param {string} name - The attachment name.
+     * @param {number} queryParam - The (optional) query parameter. Might be a dimension or index, based on the attachment type.
+     *                              If not provided, delete all attachments of name.
+     * @param {number} index - The (optional) index of the attachment of that type/name.
+     * @param {Function} [progressCallback] - Download progress callback.
+     * @returns {Promise<undefined>}
+     */
+    deleteAttachment(id: string, name: string, queryParam?: number, index?: number): Promise<any>;
+    /**
+     * Sets perceptive hash on attachment
+     * @param {string} itemId - The item ID.
+     * @param {string} attachmentId - The attachment ID.
+     * @param {string} perceptiveHash - The perceptive hash.
+     * @returns {Promise<undefined>}
+     */
+    setPerceptiveHashOnAttachment(itemId: any, attachmentId: any, perceptiveHash: any): Promise<any>;
+    /**
+     * Sets perceptive hash on item
+     * @param {string} id - The item ID.
+     * @param {string} perceptiveHash - The perceptive hash.
+     * @returns {Promise<undefined>}
+     */
+    setPerceptiveHash(id: any, perceptiveHash: any): Promise<any>;
+    /**
+     * Get client information for an item.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The client information.
+     */
+    getItemClient(id: any): Promise<any>;
+    /**
+     * Get ACL (Access Control List) for an item.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The item ACL.
+     */
+    getItemAcl(id: any): Promise<any>;
+    /**
+     * Get items linking to a specified item.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Array>} The list of linking items.
+     */
+    getItemsLinking(id: any): Promise<any>;
+    /**
+     * Set attributes for a list of items.
+     * @param {Array<string>} idList - The list of item IDs.
+     * @param {Object} attributes - The attributes to set.
+     * @returns {Promise<Object>} The response.
+     */
+    setAttributes(idList: any, attributes: any): Promise<any>;
+    /**
+     * Get the item sync list since a specified date.
+     * @param {Date} date - The sync date.
+     * @returns {Promise<Array>} The sync list.
+     */
+    getItemSyncList(date: any): Promise<any>;
+    /**
+     * Increase views count for an item.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The response.
+     */
+    increaseViews(id: any): Promise<any>;
+    /**
+     * Get the views count for an item.
+     * @param id - The item ID.
+     * @returns The views count.
+     */
+    getViews(id: string): Promise<number>;
+    /**
+     * Get public item counts.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The public item counts.
+     */
+    getPublicItemCounts(id: any): Promise<any>;
+    /**
+     * Get item counts.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The item counts.
+     */
+    getItemCounts(id: any): Promise<any>;
+    /**
+     * Like an item.
+     * @param id - The item ID.
+     */
+    likeItem(id: string): Promise<void>;
+    /**
+     * Unlike an item.
+     * @param id - The item ID.
+     */
+    unlikeItem(id: string): Promise<void>;
+    /**
+     * Check if the current user likes an item.
+     * @param id - The item ID.
+     * @returns Whether the user likes the item.
+     */
+    doILike(id: string): Promise<boolean>;
+    /**
+     * Set auto-destruct date for an item.
+     * @param {string} id - The item ID.
+     * @param {Date} date - The auto-destruct date.
+     * @returns {Promise<Object>} The response.
+     */
+    setItemAutoDestruct(id: any, date: any): Promise<any>;
+    /**
+     * Clear auto-destruct date for an item.
+     * @param {string} id - The item ID.
+     * @returns {Promise<Object>} The response.
+     */
+    clearItemAutoDestruct(id: any): Promise<any>;
+    /**
+     * Resolve relative item path.
+     * @param {string} id - The item ID.
+     * @param {string} path - The relative path.
+     * @returns {Promise<string>} The resolved item ID.
+     */
+    resolveRelativeItem(id: any, path: any): Promise<any>;
+    /**
+     * Resolve public relative item path.
+     * @param {string} id - The item ID.
+     * @param {string} path - The relative path.
+     * @returns {Promise<string>} The resolved item ID.
+     */
+    publicResolveRelativeItem(id: any, path: any): Promise<any>;
+    /**
+     * Rewire one or more items, also setting attributes
+     * @param {Array<Object>} items - Array of objects, containing { _id: "itemId", links: [ { to: "itemId", usage: "<usage>"} ], attributes: { ... }}
+     * @return {Promise<void>}
+     */
+    rewireItems(items: any): Promise<any>;
+    /**
+     * Get a folder by ID.
+     * @param id - The folder ID.
+     * @returns The folder details.
+     */
+    getFolder(id: string): Promise<{
+        _id: string;
+        name: string;
+        parent?: string;
+        createdAt: string;
+        createdBy?: string;
+        updatedAt: string;
+        updatedBy?: string;
+        location?: string;
+        contentSize?: number;
+        acl?: Acl;
+        resultingAcl?: Acl;
+    }>;
+    /**
+     * Get the full folder tree up to depth MAX_FULLTREE_DEPTH_SUBLEVELS as defined in service limits.js.
+     * @param {string} folderId - The folder ID ("0" for root).
+     * @returns {Promise<Object>} The folder tree structure.
+     */
+    getFullFolderTree(folderId: any): Promise<any>;
+    /**
+     * Get folders in a folder.
+     * @param parentId - The parent folder ID.
+     * @param options - Options object
+     * @param options.resolveNames - Resolve names of folders.
+     * @param options.folderAsItemType - Fetch folders as items of a specific type.
+     * @param options.folderAsItemName - Fetch folders as items of a specific name.
+     * @param options.folderAsItemFlag - Fetch folders as items with a specific flag.
+     * @param options.withStats - If the counts for every item should be returned.
+     * @param options.returnLatestPackage - If the latest package should be returned.
+     * @returns The list of folders.
+     */
+    getFoldersInFolderList<O extends FolderListingOptions>(parentId: string | undefined | null, options?: O): Promise<FolderListingWithOptions<O>>;
+    /**
+     * Update the folder cache for a list of folders.
+     * @param {Array<string>} IDs - The list of folder IDs.
+     */
+    updateFolderCache(IDs: any): Promise<void>;
+    /**
+     * Create a new folder.
+     * @param {Object} data - The folder data.
+     * @param {string} data.name - The name of the folder
+     * @param {string} [data.parent] - The ID of the parent folder or omit to create in root folder
+     * @param {boolean} [data.returnIfExists] - true, if the folder should be returned in case it already exists.
+     * @param {boolean} [data.hidden] - true, if the folder should be marked as hidden
+     * @param {boolean} [data.fixNameCollisions] - Fix name collisions. If the folder name exists already, an index will be appended
+     * @returns {Promise<string>} The folder's ID
+     */
+    createFolder(data: {
+        name: string;
+        parent?: string;
+        hidden?: boolean;
+        returnIfExists?: boolean;
+        fixNameCollisions?: boolean;
+        acl?: {
+            user: string;
+            group: string;
+            can: string[];
+        }[];
+    }): Promise<string>;
+    /**
+     * Update an existing folder.
+     * @param data - The folder data.
+     * @param data._id - The id of the folder
+     * @param data.name - The name of the folder
+     * @param [data.acl] - Optional acl array in case it should be updated
+     */
+    updateFolder(data: {
+        _id: string;
+        name: string;
+        acl?: Acl;
+    }): Promise<void>;
+    /**
+     * Delete a folder by ID.
+     * @param id - The folder ID.
+     */
+    deleteFolder(id: string): Promise<void>;
+    /**
+     * Rename folder
+     * @param {string} id - The folder ID.
+     * @param {string} name - The new folder name.
+     * @returns {Promise<Object>} The updated folder details.
+     */
+    renameFolder(id: any, name: any): Promise<void>;
+    /**
+     * Move folders to a different location.
+     * @param data - The move data.
+     * @param data.folders - List of folder IDs that should be moved
+     * @param data.dest - Destination folder where the listed folders should be moved to. Either the ID or null for the root folder.
+     * @returns The amount of modified folders.
+     */
+    moveFolders(data: {
+        folders: string[];
+        dest?: string;
+    }): Promise<number>;
+    /**
+     * Get the path of a folder by ID.
+     * @param id - The folder ID or a folder object with _id field
+     * @returns The folder path and all elements of it.
+     */
+    getFolderPath(id?: string | {
+        _id: string;
+    }): Promise<{
+        path: string;
+        elements: {
+            id: string;
+            name: string;
+            originalName: string;
+        }[];
+    }>;
+    /**
+     * Resolve a folder path. Returns the folder ID if it exists. returns null for the root folder
+     * @param path path to the folder
+     * @return {Promise<Object>}
+     */
+    resolveFolderPath(path: any): Promise<any>;
+    /**
+     * Get client information for a folder.
+     * @param {string} id - The folder ID.
+     * @returns {Promise<Object>} The client information.
+     */
+    getFolderClient(id: any): Promise<any>;
+    /**
+     * Get the Access Control List (ACL) for a folder.
+     * @param {string} id - The folder ID.
+     * @returns {Promise<Object>} The folder ACL.
+     */
+    getFolderAcl(id: any): Promise<any>;
+    /**
+     * Get the ACL list for multiple folders.
+     * @param {Array<string>} ids - The list of folder IDs.
+     * @returns {Promise<Array>} The list of ACLs.
+     */
+    getFolderAclList(ids: any): Promise<any>;
+    /**
+     * Get a user by ID.
+     * @param {string} id - The user ID.
+     * @returns {Promise<Object>} The user details.
+     */
+    getUser(id: any): Promise<any>;
+    /**
+     * Get the list of users.
+     * @returns {Promise<Array>} The list of users.
+     */
+    getUsersList(): Promise<any>;
+    /**
+     * Create a new user.
+     * @param {Object} data - The user data.
+     * @returns {Promise<Object>} The created user details.
+     */
+    createUser(data: any): Promise<any>;
+    /**
+     * Query users with a search query.
+     * @param [searchQuery] - The search query.
+     * @param [groupID] - The group ID.
+     * @param [cursor] - Pagination cursor.
+     * @returns The query response.
+     */
+    queryUser(searchQuery?: string, groupID?: string, cursor?: string): Promise<{
+        data: {
+            _id: string;
+            name: string;
+            displayName?: string;
+        }[];
+        withNext?: string;
+    }>;
+    /**
+     * Update an existing user.
+     * @param {Object} data - The user data.
+     * @returns {Promise<Object>} The updated user details.
+     */
+    updateUser(data: any): Promise<any>;
+    /**
+     * Delete a user by ID.
+     * @param {string} id - The user ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteUser(id: any): Promise<any>;
+    /**
+     * Update the profile of the current user.
+     * @param data - The profile data.
+     */
+    updateMyProfile(data: {
+        name: string;
+        account: string;
+        displayName?: string;
+        currentPassword?: string;
+        newPassword?: string;
+        location?: string;
+        properties?: Record<string, any>;
+        paymentSetup?: {
+            address: {
+                email: string;
+                name: string;
+                street: string;
+                zipcode: string;
+                city: string;
+                country: string;
+            };
+        };
+    }): Promise<void>;
+    /**
+     * Switch to a different client.
+     * @param {string} id - The client ID.
+     * @returns {Promise<Object>} The switch response.
+     */
+    switchClient(id: any): Promise<any>;
+    /**
+     * Activate a user account with a token.
+     * @param {string} password - The user password.
+     * @param {string} token - The activation token.
+     * @returns {Promise<Object>} The activation response.
+     */
+    activateUser(password: any, token: any): Promise<any>;
+    /**
+     * Get the list of users pending approval.
+     * @returns {Promise<Array>} The list of users.
+     */
+    getUsersToApprove(): Promise<any>;
+    /**
+     * Approve a user's registration.
+     * @param {string} userId - The user ID.
+     * @returns {Promise<Object>} The approval response.
+     */
+    approveUserRegistration(userId: any): Promise<any>;
+    /**
+     * Reject a user's registration.
+     * @param {string} userId - The user ID.
+     * @returns {Promise<Object>} The rejection response.
+     */
+    rejectUserRegistration(userId: any): Promise<any>;
+    /**
+     * Upload an avatar for the current user.
+     * @param data - The avatar data
+     */
+    uploadAvatar(data: Buffer | Blob): Promise<void>;
+    /**
+     * Clear the avatar of the current user.
+     * @returns {Promise<Object>} The response.
+     */
+    clearAvatar(): Promise<any>;
+    /**
+     * Get the avatar of a user.
+     * @param userId - The user ID.
+     * @param size - The avatar size.
+     * @returns The user information.
+     */
+    getAvatar(userId: string, size: number): Promise<UserInfo>;
+    /**
+     * Get the public information of a user.
+     * @param userId - The user ID.
+     * @param clientId - The client ID.
+     * @param avatarSize - The avatar size.
+     * @returns The user public information.
+     */
+    getUserPublicInfo(userId: string, clientId: string, avatarSize: number): Promise<UserInfo>;
+    /**
+     * Get a user attribute by key.
+     * @param {string} key - The attribute key.
+     * @returns {Promise<Object>} The attribute value.
+     */
+    getUserAttribute(key: any): Promise<any>;
+    /**
+     * Clear a user attribute by key.
+     * @param {string} key - The attribute key.
+     * @returns {Promise<Object>} The response.
+     */
+    clearUserAttribute(key: any): Promise<any>;
+    /**
+     * Set a user attribute.
+     * @param {string} key - The attribute key.
+     * @param {string} value - The attribute value.
+     * @returns {Promise<Object>} The response.
+     */
+    setUserAttribute(key: any, value: any): Promise<any>;
+    /**
+     * Get a group by ID.
+     * @param id - The group ID.
+     * @returns The group details.
+     */
+    getGroup(id: string): Promise<{
+        _id: string;
+        name: string;
+        description: string;
+        hasFolder?: boolean;
+        storageQuotaGb: number;
+        trafficQuotaGb: number;
+        allowedDatatypes?: string[];
+        allowedJobtypes?: string[];
+        allowedFeatures?: string[];
+        createdAt: string;
+        updatedAt: string;
+        users: {
+            _id: string;
+            name: string;
+        }[];
+        location?: string;
+    }>;
+    /**
+     * Get the folder of a group.
+     * @param id - The group ID.
+     * @returns The ID of the group folder.
+     */
+    getGroupFolder(id: string): Promise<string | null>;
+    /**
+     * Get the list of groups.
+     * @returns {Promise<Array>} The list of groups.
+     */
+    getGroupsList(): Promise<any>;
+    /**
+     * Create a new group.
+     * @param {Object} data - The group data.
+     * @returns {Promise<Object>} The created group details.
+     */
+    createGroup(data: any): Promise<any>;
+    /**
+     * Query groups with a search query.
+     * @param {string} searchQuery - The search query.
+     * @param {string} [cursor] - Pagination cursor.
+     * @returns {Promise<Object>} The query response.
+     */
+    queryGroup(searchQuery: any, cursor: any): Promise<any>;
+    /**
+     * Update an existing group.
+     * @param data - The group data.
+     * @param [data.headerImageMobile] - ID of an item to be used as the header image on mobile devices.
+     * @param [data.headerImageDesktop] - ID of an item to be used as the header image on desktop devices.
+     * @param [data.publicMembers] - Array of user IDs that should be shown as members to the public.
+     * @param [data.users] - Array of user IDs that should be in this group.
+     */
+    updateGroup(data: {
+        _id: string;
+        name: string;
+        description?: string;
+        storageQuotaGb?: number;
+        trafficQuotaGb?: number;
+        allowedDatatypes?: string[];
+        allowedJobtypes?: string[];
+        allowedFeatures?: string[];
+        hasFolder?: boolean;
+        headerImageDesktop?: string;
+        headerImageMobile?: string;
+        publicMembers?: string[];
+        users?: string[];
+    }): Promise<void>;
+    /**
+     * Delete a group by ID.
+     * @param {string} id - The group ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteGroup(id: any): Promise<any>;
+    /**
+     * Get quota information for a group.
+     * @param {string} id - The group ID.
+     * @returns {Promise<Object>} The quota information.
+     */
+    getGroupQuotaInfo(id: any): Promise<any>;
+    /**
+     * Get public information for a group.
+     * @param groupId - The group ID.
+     * @param clientId - The client ID.
+     * @param avatarSize - The avatar size.
+     * @returns The public group information.
+     */
+    getGroupPublicInfo(groupId: string, clientId: string, avatarSize: number): Promise<{
+        avatar?: string;
+        initials: string;
+        name?: string;
+        description?: string;
+        headerImageDesktop?: string;
+        headerImageMobile?: string;
+        members: {
+            _id: string;
+            name: string;
+        }[];
+    }>;
+    /**
+     * Get list of users in a group. Only accessible for members of the group.
+     * @param {string} groupId - The group ID.
+     * @returns {Promise<{_id: string, name: string}[]>} The list of users.
+     */
+    getGroupUsers(groupId: any): Promise<any>;
+    /**
+     * Upload an avatar for a specific group.
+     * @param groupId - The ID of the group
+     * @param data - The avatar data. Can be passed as a buffer or a blob
+     */
+    uploadGroupAvatar(groupId: string, data: Buffer | Blob): Promise<void>;
+    /**
+     * Get the list of clients.
+     * @returns {Promise<Array>} The list of clients.
+     */
+    getClientsList(): Promise<any>;
+    /**
+     * Get a client by ID.
+     * @param {string} id - The client ID.
+     * @returns {Promise<Object>} The client details.
+     */
+    getClient(id: any): Promise<any>;
+    /**
+     * Create a new client.
+     * @param {Object} data - The client data.
+     * @returns {Promise<Object>} The created client details.
+     */
+    createClient(data: any): Promise<any>;
+    /**
+     * Query clients with a search query.
+     * @param {string} searchQuery - The search query.
+     * @param {string} [cursor] - Pagination cursor.
+     * @returns {Promise<Object>} The query response.
+     */
+    queryClient(searchQuery: any, cursor: any): Promise<any>;
+    /**
+     * Update an existing client.
+     * @param {Object} data - The client data.
+     * @returns {Promise<Object>} The updated client details.
+     */
+    updateClient(data: any): Promise<any>;
+    /**
+     * Delete a client by ID.
+     * @param {string} id - The client ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteClient(id: any): Promise<any>;
+    /**
+     * Get client metrics for a specific month and year.
+     * @param {string} id - The client ID.
+     * @param {number} year - The year.
+     * @param {number} month - The month.
+     * @returns {Promise<Object>} The client metrics.
+     */
+    getClientMetrics(id: any, year: any, month: any): Promise<any>;
+    /**
+     * Join a client.
+     * @param {string} id - The client ID.
+     * @returns {Promise<Object>} The join response.
+     */
+    joinClient(id: any): Promise<any>;
+    /**
+     * Leave a client.
+     * @param {string} id - The client ID.
+     * @returns {Promise<Object>} The leave response.
+     */
+    leaveClient(id: any): Promise<any>;
+    /**
+     * Get the current user's client.
+     * @returns {Promise<Object>} The current user's client.
+     */
+    myClient(): Promise<any>;
+    /**
+     * Save the current user's client.
+     * @param {Object} data - The client data.
+     * @returns {Promise<Object>} The saved client details.
+     */
+    saveMyClient(data: any): Promise<any>;
+    /**
+     * Get public categories for a client.
+     * @param clientId - The client ID.
+     * @returns The list of public categories.
+     */
+    getPublicCategories(clientId: string): Promise<{
+        _id: string;
+        name: string;
+    }[]>;
+    /**
+     * Get the list of categories.
+     * @returns {Promise<Array>} The list of categories.
+     */
+    getCategories(): Promise<any>;
+    /**
+     * Get the categories in a client.
+     * @param {string} clientId - The client ID.
+     * @returns {Promise<Array>} The list of categories.
+     */
+    getCategoriesInClient(clientId: any): Promise<any>;
+    /**
+     * Update the categories in a client.
+     * @param {string} clientId - The client ID.
+     * @param {Array} categories - The categories to update.
+     * @returns {Promise<Object>} The update response.
+     */
+    updateCategoriesInClient(clientId: any, categories: any): Promise<any>;
+    /**
+     * Get the list of licenses.
+     * @returns The list of licenses.
+     */
+    getLicenses(): Promise<{
+        _id: string;
+        name?: string;
+        link?: string;
+        text?: string;
+        shorttext?: string;
+    }[]>;
+    /**
+     * Get licenses in a client.
+     * @param {string} clientId - The client ID.
+     * @returns {Promise<Array>} The list of licenses.
+     */
+    getLicensesInClient(clientId: any): Promise<any>;
+    /**
+     * Get a license by ID.
+     * @param {string} id - The license ID.
+     * @returns {Promise<Object>} The license details.
+     */
+    getLicense(id: any): Promise<any>;
+    /**
+     * Create a new license.
+     * @param {Object} data - The license data.
+     * @returns {Promise<Object>} The created license details.
+     */
+    createLicense(data: any): Promise<any>;
+    /**
+     * Update an existing license.
+     * @param {Object} data - The license data.
+     * @returns {Promise<Object>} The updated license details.
+     */
+    updateLicense(data: any): Promise<any>;
+    /**
+     * Delete a license by ID.
+     * @param {string} id - The license ID.
+     * @param {string} clientId - The client ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteLicense(id: any, clientId: any): Promise<any>;
+    /**
+     * Get the list of public licenses for a client.
+     * @param {string} clientId - The client ID.
+     * @returns {Promise<Array>} The list of public licenses.
+     */
+    getPublicLicenses(clientId: any): Promise<any>;
+    /**
+     * Get a public license by ID.
+     * @param {string} id - The license ID.
+     * @returns {Promise<Object>} The license details.
+     */
+    getPublicLicense(id: any): Promise<any>;
+    /**
+     * Get the list of data types.
+     * @returns {Promise<Array>} The list of data types.
+     */
+    getDatatypesList(): Promise<any>;
+    /**
+     * Get the list of data types.
+     * @returns {Promise<Array>} The list of data types.
+     */
+    getPublicDatatypesList(clientId: any): Promise<any>;
+    /**
+     * Get the list of data types on the client.
+     * @returns {Promise<Array>} The list of data types.
+     */
+    getDatatypesListOnClient(): Promise<any>;
+    /**
+     * Get the list of data types on the client for all users.
+     * @returns {Promise<Array>} The list of data types.
+     */
+    getDatatypesListOnClientForAll(): Promise<any>;
+    /**
+     * Get the list of all data types.
+     * @returns {Promise<Array>} The list of all data types.
+     */
+    getAllDatatypesList(): Promise<any>;
+    /**
+     * Get a data type by ID.
+     * @param {string} id - The data type ID.
+     * @returns {Promise<Object>} The data type details.
+     */
+    getDatatype(id: any): Promise<any>;
+    /**
+     * Create a new data type.
+     * @param {Object} data - The data type data.
+     * @returns {Promise<Object>} The created data type details.
+     */
+    createDatatype(data: any): Promise<any>;
+    /**
+     * Update an existing data type.
+     * @param {Object} data - The data type data.
+     * @returns {Promise<Object>} The updated data type details.
+     */
+    updateDatatype(data: any): Promise<any>;
+    /**
+     * Delete a data type by ID.
+     * @param {string} id - The data type ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteDatatype(id: any): Promise<any>;
+    /**
+     * Get the list of notifications for the current user.
+     * @param {number} [maxCount] - Maximum number of notifications.
+     * @returns {Promise<Array>} The list of notifications.
+     */
+    getMyNotifications(maxCount: any): Promise<any>;
+    /**
+     * Mark a notification as read.
+     * @param {string} id - The notification ID.
+     * @returns {Promise<Object>} The response.
+     */
+    markNotificationAsRead(id: any): Promise<any>;
+    /**
+     * Mark all notifications as read.
+     * @returns {Promise<Object>} The response.
+     */
+    markAllNotificationsAsRead(): Promise<any>;
+    /**
+     * Create a new job.
+     * @param data - The job data.
+     * @returns The ID of the created job.
+     */
+    createJob(data: {
+        type: string;
+        elements: any[];
+        parameters: any[];
+    }): Promise<string>;
+    /**
+     * Get the list of manual job types.
+     * @returns {Promise<Array>} The list of manual job types.
+     */
+    getManualJobTypes(): Promise<any>;
+    /**
+     * Get the list of manual job types on the client.
+     * @returns {Promise<Array>} The list of manual job types.
+     */
+    getManualJobTypesOnClient(): Promise<any>;
+    /**
+     * Get the list of manual job types on the client for all users.
+     * @returns {Promise<Array>} The list of manual job types.
+     */
+    getManualJobTypesOnClientForAll(): Promise<any>;
+    /**
+     * Get the list of all manual job types.
+     * @returns {Promise<Array>} The list of manual job types.
+     */
+    getAllManualJobTypes(): Promise<any>;
+    /**
+     * Get the list of all manual job types for a client.
+     * @param {string} id - The client ID.
+     * @returns {Promise<Array>} The list of manual job types.
+     */
+    getAllManualJobTypesForClient(id: any): Promise<any>;
+    /**
+     * Get the list of client job types.
+     * @returns {Promise<Array>} The list of client job types.
+     */
+    getClientJobTypes(): Promise<any>;
+    /**
+     * Get the list of jobs for the current user.
+     * @returns The list of jobs.
+     */
+    getMyJobs(): Promise<{
+        _id: string;
+        type?: string;
+        message?: string;
+        state?: number;
+        createdAt: string;
+        elementCount: number;
+        startedAt?: string;
+        stoppedAt?: string;
+    }[]>;
+    /**
+     * Get the list of all jobs.
+     * @returns {Promise<Array>} The list of jobs.
+     */
+    getJobs(): Promise<any>;
+    /**
+     * Get the aggregated list of jobs.
+     * @returns {Promise<Array>} The aggregated list of jobs.
+     */
+    getJobsAggregated(): Promise<any>;
+    /**
+     * Get the list of jobs within a specific timeframe.
+     * @param {string} from - The start date.
+     * @param {string} till - The end date.
+     * @returns {Promise<Array>} The list of jobs.
+     */
+    getJobsTimeframe(from: any, till: any): Promise<any>;
+    /**
+     * Get a job by ID.
+     * @param {string} id - The job ID.
+     * @returns {Promise<Object>} The job details.
+     */
+    getJob(id: any): Promise<any>;
+    /**
+     * Get the state of a job.
+     * @param id - The job ID.
+     * @returns The job state.
+     */
+    getJobState(id: string): Promise<JobState>;
+    /**
+     * Get the list of job agents.
+     * @returns {Promise<Array>} The list of job agents.
+     */
+    getAgents(): Promise<any>;
+    /**
+     * Get the aggregated list of job agents.
+     * @returns {Promise<Array>} The aggregated list of job agents.
+     */
+    getAgentsAggregated(): Promise<any>;
+    /**
+     * Enable a job agent.
+     * @param {string} id - The job agent ID.
+     * @returns {Promise<Object>} The enable response.
+     */
+    enableJobAgent(id: any): Promise<any>;
+    /**
+     * Disable a job agent.
+     * @param {string} id - The job agent ID.
+     * @returns {Promise<Object>} The disable response.
+     */
+    disableJobAgent(id: any): Promise<any>;
+    /**
+     * Restart a job agent.
+     * @param {string} id - The job agent ID.
+     * @returns {Promise<Object>} The restart response.
+     */
+    restartJobAgent(id: any): Promise<any>;
+    /**
+     * Get the list of permissions.
+     * @returns {Promise<Array>} The list of permissions.
+     */
+    getPermissionsList(): Promise<any>;
+    /**
+     * Get the list of plugins.
+     * @returns {Promise<Array>} The list of plugins.
+     */
+    getPlugins(): Promise<any>;
+    /**
+     * Get the list of plans.
+     * @returns {Promise<Array>} The list of plans.
+     */
+    getPlans(): Promise<any>;
+    /**
+     * Get a plan by ID.
+     * @param {string} id - The plan ID.
+     * @returns {Promise<Object>} The plan details.
+     */
+    getPlan(id: any): Promise<any>;
+    /**
+     * Create a new plan.
+     * @param {Object} data - The plan data.
+     * @returns {Promise<Object>} The created plan details.
+     */
+    createPlan(data: any): Promise<any>;
+    /**
+     * Update an existing plan.
+     * @param {Object} data - The plan data.
+     * @returns {Promise<Object>} The updated plan details.
+     */
+    updatePlan(data: any): Promise<any>;
+    /**
+     * Delete a plan by ID.
+     * @param {string} id - The plan ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deletePlan(id: any): Promise<any>;
+    /**
+     * Get the list of workflows.
+     * @returns {Promise<Array>} The list of workflows.
+     */
+    getWorkflows(): Promise<any>;
+    /**
+     * Get a workflow by ID.
+     * @param {string} id - The workflow ID.
+     * @returns {Promise<Object>} The workflow details.
+     */
+    getWorkflow(id: any): Promise<any>;
+    /**
+     * Create a new workflow.
+     * @param {Object} data - The workflow data.
+     * @returns {Promise<Object>} The created workflow details.
+     */
+    createWorkflow(data: any): Promise<any>;
+    /**
+     * Update an existing workflow.
+     * @param {Object} data - The workflow data.
+     * @returns {Promise<Object>} The updated workflow details.
+     */
+    updateWorkflow(data: any): Promise<any>;
+    /**
+     * Delete a workflow by ID.
+     * @param {string} id - The workflow ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteWorkflow(id: any): Promise<any>;
+    /**
+     * Start a workflow.
+     * @param {Object} data - The workflow data.
+     * @returns {Promise<Object>} The start response.
+     */
+    startWorkflow(data: any): Promise<any>;
+    /**
+     * Get the list of access tokens.
+     * @returns {Promise<Array>} The list of access tokens.
+     */
+    getAccessTokens(): Promise<any>;
+    /**
+     * Get the list of client access tokens.
+     * @returns {Promise<Array>} The list of client access tokens.
+     */
+    getClientAccessTokens(): Promise<any>;
+    /**
+     * Create a new access token.
+     * @param {Object} data - The access token data.
+     * @returns {Promise<Object>} The created access token details.
+     */
+    createAccessToken(data: any): Promise<any>;
+    /**
+     * Create a new client access token.
+     * @param {Object} data - The access token data.
+     * @returns {Promise<Object>} The created client access token details.
+     */
+    createClientAccessToken(data: any): Promise<any>;
+    /**
+     * Delete an access token by ID.
+     * @param {string} id - The access token ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteAccessToken(id: any): Promise<any>;
+    /**
+     * Delete a client access token by ID.
+     * @param {string} id - The access token ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteClientAccessToken(id: any): Promise<any>;
+    /**
+     * Enable an access token.
+     * @param {string} id - The access token ID.
+     * @returns {Promise<Object>} The enable response.
+     */
+    enableAccessToken(id: any): Promise<any>;
+    /**
+     * Disable an access token.
+     * @param {string} id - The access token ID.
+     * @returns {Promise<Object>} The disable response.
+     */
+    disableAccessToken(id: any): Promise<any>;
+    /**
+     * Get the list of API tokens.
+     * @returns {Promise<Array>} The list of API tokens.
+     */
+    getApiTokens(): Promise<any>;
+    /**
+     * Create a new API token.
+     * @param {Object} data - The API token data.
+     * @returns {Promise<Object>} The created API token details.
+     */
+    createApiToken(data: any): Promise<any>;
+    /**
+     * Delete an API token by ID.
+     * @param {string} id - The API token ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteApiToken(id: any): Promise<any>;
+    /**
+     * Get the list of invoices for the current user's client.
+     * @returns {Promise<Array>} The list of invoices.
+     */
+    getMyClientInvoices(): Promise<any>;
+    /**
+     * Get the list of invoices for the current user.
+     * @returns {Promise<Array>} The list of invoices.
+     */
+    getMyUserInvoices(): Promise<any>;
+    /**
+     * Get the list of invoices for a client.
+     * @param {string} clientId - The client ID.
+     * @returns {Promise<Array>} The list of invoices.
+     */
+    getClientInvoices(clientId: any): Promise<any>;
+    /**
+     * Download an invoice by ID.
+     * @param {string} invoiceId - The invoice ID.
+     * @param {string} [filename] - The filename for the download.
+     * @returns {Promise<void>} The download action.
+     */
+    downloadInvoice(invoiceId: any, filename: any): Promise<void>;
+    /**
+     * Regenerate an invoice by ID.
+     * @param {string} invoiceId - The invoice ID.
+     * @returns {Promise<Object>} The regeneration response.
+     */
+    regenerateInvoice(invoiceId: any): Promise<any>;
+    /**
+     * Get the list of invoices for a specific month and year.
+     * @param {number} year - The year.
+     * @param {number} month - The month.
+     * @returns {Promise<Array>} The list of invoices.
+     */
+    getInvoicesForMonth(year: any, month: any): Promise<any>;
+    /**
+     * Refund an invoice.
+     * @param {string} invoice - The invoice ID.
+     * @param {number} amount - The refund amount.
+     * @param {string} reason - The reason for the refund.
+     * @returns {Promise<Object>} The refund response.
+     */
+    refundInvoice(invoice: any, amount: any, reason: any): Promise<any>;
+    /**
+     * Start a checkout process for payment.
+     * @param {string} successUrl - The success URL.
+     * @param {string} cancelUrl - The cancel URL.
+     * @returns {Promise<Object>} The checkout response.
+     */
+    paymentStartCheckout(successUrl: any, cancelUrl: any): Promise<any>;
+    /**
+     * Start a checkout process for user payment.
+     * @param {string} successUrl - The success URL.
+     * @param {string} cancelUrl - The cancel URL.
+     * @returns {Promise<Object>} The checkout response.
+     */
+    paymentStartUserCheckout(successUrl: any, cancelUrl: any): Promise<any>;
+    /**
+     * Get the list of supported currencies.
+     * @returns {Promise<Array>} The list of currencies.
+     */
+    getSupportedCurrencies(): Promise<any>;
+    /**
+     * Get the list of purchasable items.
+     * @returns {Promise<Array>} The list of purchasables.
+     */
+    getPurchasables(): Promise<any>;
+    /**
+     * Get a purchasable item by ID.
+     * @param {string} id - The purchasable ID.
+     * @returns {Promise<Object>} The purchasable details.
+     */
+    getPurchasable(id: any): Promise<any>;
+    /**
+     * Create a new purchasable item.
+     * @param {Object} data - The purchasable data.
+     * @returns {Promise<Object>} The created purchasable details.
+     */
+    createPurchasable(data: any): Promise<any>;
+    /**
+     * Update an existing purchasable item.
+     * @param {Object} data - The purchasable data.
+     * @returns {Promise<Object>} The updated purchasable details.
+     */
+    updatePurchasable(data: any): Promise<any>;
+    /**
+     * Delete a purchasable item by ID.
+     * @param {string} id - The purchasable ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deletePurchasable(id: any): Promise<any>;
+    /**
+     * Get the list of public purchasables for a client.
+     * @param clientId - The client ID.
+     * @returns The list of public purchasables.
+     */
+    getPublicPurchasables(clientId: string): Promise<{
+        _id: string;
+        name?: string;
+        description?: string;
+        options?: {
+            _id: string;
+            name?: string;
+            prices?: Record<string, number>;
+            interval?: string;
+            fastSpringProductPath?: string;
+        }[];
+        groupId?: string;
+        pricesContainVat?: boolean;
+    }[]>;
+    /**
+     * Get the list of purchases.
+     * @returns {Promise<Array>} The list of purchases.
+     */
+    getPurchases(): Promise<any>;
+    /**
+     * Get the list of active purchases for the current user.
+     * @returns {Promise<Array>} The list of purchases.
+     */
+    getMyActivePurchases(): Promise<{
+        _id: string;
+        purchasableName?: string;
+        purchasableId?: string;
+        active?: boolean;
+        createdAt: string;
+        canceledAt?: string;
+        paidUntil?: string;
+        priceDisplay?: string;
+        intervalUnit?: string;
+        intervalLength?: number;
+    }[]>;
+    /**
+     * Make a purchase.
+     * @param {Object} data - The purchase data.
+     * @returns {Promise<Object>} The purchase details.
+     */
+    purchase(data: any): Promise<any>;
+    /**
+     * Change the purchasable of an existing subscription.
+     * Only supported for purchases made through FastSpring.
+     * @param purchaseID - The ID of the purchase / subscription to modify.
+     * @param purchasableID - The ID of the new purchasable that should be used for this subscription.
+     * @param optionID - The ID of the purchasables option.
+     */
+    changePurchaseProduct(purchaseID: any, purchasableID: string, optionID: string): Promise<void>;
+    /**
+     * Cancel a purchase by ID.
+     * @param id - The purchase ID.
+     */
+    cancelPurchase(id: string): Promise<void>;
+    /**
+     * Uncancel an already cancelled purchase.
+     * @param id - The purchase ID.
+     */
+    uncancelPurchase(id: string): Promise<void>;
+    /**
+     * Get an encrypted session payload for a FastSpring checkout.
+     * @param purchasableID - The ID of the purchasable.
+     * @param optionID - The ID of the option.
+     * @returns The encrypted session payload and key.
+     */
+    getSecureSessionPayload(purchasableID: string, optionID: string): Promise<{
+        payload: string;
+        key: string;
+    }>;
+    /**
+     * Query purchases with various parameters.
+     * @param {string} startDate - The start date.
+     * @param {string} endDate - The end date.
+     * @param {string} email - The email associated with the purchase.
+     * @param {string} invoice - The invoice number.
+     * @param {string} [cursor] - Pagination cursor.
+     * @param {number} [limit] - Result limit.
+     * @returns {Promise<Array>} The list of purchases.
+     */
+    queryPurchases(startDate: any, endDate: any, email: any, invoice: any, cursor: any, limit: any): Promise<any>;
+    /**
+     * Get the list of attribute templates.
+     * @returns {Promise<Array>} The list of attribute templates.
+     */
+    getAttributeTemplates(): Promise<any>;
+    /**
+     * Get an attribute template by ID.
+     * @param {string} id - The attribute template ID.
+     * @returns {Promise<Object>} The attribute template details.
+     */
+    getAttributeTemplate(id: any): Promise<any>;
+    /**
+     * Create a new attribute template.
+     * @param {Object} data - The attribute template data.
+     * @returns {Promise<Object>} The created attribute template details.
+     */
+    createAttributeTemplate(data: any): Promise<any>;
+    /**
+     * Update an existing attribute template.
+     * @param {Object} data - The attribute template data.
+     * @returns {Promise<Object>} The updated attribute template details.
+     */
+    updateAttributeTemplate(data: any): Promise<any>;
+    /**
+     * Delete an attribute template by ID.
+     * @param {string} id - The attribute template ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteAttributeTemplate(id: any): Promise<any>;
+    /**
+     * Get the list of storages.
+     * @returns {Promise<Array>} The list of storages.
+     */
+    getStorages(): Promise<any>;
+    /**
+     * Get a conversation by ID.
+     * @param id - The conversation ID.
+     * @returns The conversation details.
+     */
+    getConversation(id: string): Promise<{
+        conversation: {
+            parent: string;
+            parentType: string;
+            subscribed: boolean;
+            location?: string;
+        };
+        entries: ConversationEntry[];
+    }>;
+    /**
+     * Get a public conversation by ID.
+     * @param id - The conversation ID.
+     * @returns The conversation details.
+     */
+    getPublicConversation(id: string): Promise<{
+        conversation: {
+            parent: string;
+            parentType: string;
+        };
+        entries: ConversationEntry[];
+    }>;
+    /**
+     * Create a new conversation.
+     * @param {string} parentId - The parent ID.
+     * @param {string} parentType - The parent type.
+     * @returns {Promise<Object>} The created conversation details.
+     */
+    createConversation(parentId: any, parentType: any): Promise<any>;
+    /**
+     * Post a message in a conversation.
+     * @param id - The conversation ID.
+     * @param text - The message text.
+     * @param [replyTo] - The ID of the message to reply to.
+     * @returns The ID of the posted message.
+     */
+    postConversationMessage(id: string, text: string, replyTo?: string): Promise<string>;
+    /**
+     * Edit a message in a conversation.
+     * @param id - The message ID.
+     * @param text - The new message text.
+     */
+    editConversationMessage(id: string, text: string): Promise<void>;
+    /**
+     * Delete a message from a conversation.
+     * @param id - The message ID.
+     * @returns The deletion response.
+     */
+    deleteConversationMessage(id: string): Promise<void>;
+    /**
+     * Subscribe to a conversation.
+     * @param {string} id - The conversation ID.
+     * @returns {Promise<Object>} The subscription response.
+     */
+    subscribeToConversation(id: any): Promise<any>;
+    /**
+     * Unsubscribe from a conversation.
+     * @param {string} id - The conversation ID.
+     * @returns {Promise<Object>} The unsubscription response.
+     */
+    unsubscribeFromConversation(id: any): Promise<any>;
+    /**
+     * Like a conversation entry by ID.
+     * @param id - The conversation entry ID.
+     */
+    likeConversationEntry(id: string): Promise<void>;
+    /**
+     * Unlike a conversation entry by ID.
+     * @param id - The conversation entry ID.
+     */
+    unlikeConversationEntry(id: string): Promise<void>;
+    /**
+     * Execute a command.
+     * @param {Object} data - The command data.
+     * @returns {Promise<Object>} The command response.
+     */
+    command(data: any): Promise<any>;
+    /**
+     * Get the list of mail templates.
+     * @returns {Promise<Array>} The list of mail templates.
+     */
+    getMailTemplates(): Promise<any>;
+    /**
+     * Get a mail template by ID.
+     * @param {string} id - The mail template ID.
+     * @returns {Promise<Object>} The mail template details.
+     */
+    getMailTemplate(id: any): Promise<any>;
+    /**
+     * Create a new mail template.
+     * @param {Object} data - The mail template data.
+     * @returns {Promise<Object>} The created mail template details.
+     */
+    createMailTemplate(data: any): Promise<any>;
+    /**
+     * Update an existing mail template.
+     * @param {Object} data - The mail template data.
+     * @returns {Promise<Object>} The updated mail template details.
+     */
+    updateMailTemplate(data: any): Promise<any>;
+    /**
+     * Delete a mail template by ID.
+     * @param {string} id - The mail template ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteMailTemplate(id: any): Promise<any>;
+    /**
+     * Add an image to a mail template.
+     * @param {string} id - The mail template ID.
+     * @param {string} name - The image name.
+     * @param {Buffer|File} buffer - The image buffer or file.
+     * @returns {Promise<Object>} The response.
+     */
+    addMailTemplateImage(id: any, name: any, buffer: any): Promise<any>;
+    /**
+     * Delete an image from a mail template.
+     * @param {string} id - The mail template ID.
+     * @param {string} name - The image name.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteMailTemplateImage(id: any, name: any): Promise<any>;
+    /**
+     * Get the list of mail template names.
+     * @returns {Promise<Array>} The list of mail template names.
+     */
+    getMailTemplateNames(): Promise<any>;
+    /**
+     * Get mail query results.
+     * @param {string} templateName - The template name.
+     * @param {string} dateStart - The start date.
+     * @param {string} dateEnd - The end date.
+     * @param {boolean} success - Filter by success status.
+     * @returns {Promise<Array>} The query results.
+     */
+    getMailQuery(templateName: any, dateStart: any, dateEnd: any, success: any): Promise<any>;
+    /**
+     * Get mail subject and html from "viewOnline" token.
+     * @param {string} token - The token from the mail.
+     * @returns {Promise<{subject: string; html: string}>} The mail data.
+     */
+    getMail(token: any): Promise<any>;
+    /**
+     * Get the list of invoice templates.
+     * @returns {Promise<Array>} The list of invoice templates.
+     */
+    getInvoiceTemplates(): Promise<any>;
+    /**
+     * Get an invoice template by ID.
+     * @param {string} id - The invoice template ID.
+     * @returns {Promise<Object>} The invoice template details.
+     */
+    getInvoiceTemplate(id: any): Promise<any>;
+    /**
+     * Create a new invoice template.
+     * @param {Object} data - The invoice template data.
+     * @returns {Promise<Object>} The created invoice template details.
+     */
+    createInvoiceTemplate(data: any): Promise<any>;
+    /**
+     * Update an existing invoice template.
+     * @param {Object} data - The invoice template data.
+     * @returns {Promise<Object>} The updated invoice template details.
+     */
+    updateInvoiceTemplate(data: any): Promise<any>;
+    /**
+     * Delete an invoice template by ID.
+     * @param {string} id - The invoice template ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteInvoiceTemplate(id: any): Promise<any>;
+    /**
+     * Add an image to an invoice template.
+     * @param {string} id - The invoice template ID.
+     * @param {string} name - The image name.
+     * @param {Buffer|File} buffer - The image buffer or file.
+     * @returns {Promise<Object>} The response.
+     */
+    addInvoiceTemplateImage(id: any, name: any, buffer: any): Promise<any>;
+    /**
+     * Delete an image from an invoice template.
+     * @param {string} id - The invoice template ID.
+     * @param {string} name - The image name.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteInvoiceTemplateImage(id: any, name: any): Promise<any>;
+    /**
+     * Get the list of item templates.
+     * @returns {Promise<Array>} The list of item templates.
+     */
+    getItemTemplatesList(): Promise<any>;
+    /**
+     * Get the list of item templates.
+     * @returns {Promise<Array>} The list of item templates.
+     */
+    getItemTemplates(): Promise<any>;
+    /**
+     * Create a new item template.
+     * @param {Object} data - The item template data.
+     * @returns {Promise<Object>} The created item template details.
+     */
+    createItemTemplate(data: any): Promise<any>;
+    /**
+     * Update an existing item template.
+     * @param {Object} data - The item template data.
+     * @returns {Promise<Object>} The updated item template details.
+     */
+    updateItemTemplate(data: any): Promise<any>;
+    /**
+     * Delete an item template by ID.
+     * @param {string} id - The item template ID.
+     * @returns {Promise<Object>} The deletion response.
+     */
+    deleteItemTemplate(id: any): Promise<any>;
+    /**
+     * Get the list of features.
+     * @returns {Promise<Array>} The list of features.
+     */
+    getFeatures(): Promise<any>;
+    /**
+     * Get the list of features on the client.
+     * @returns {Promise<Array>} The list of features.
+     */
+    getFeaturesOnClient(): Promise<any>;
+    /**
+     * Get the list of features on the client for all users.
+     * @returns {Promise<Array>} The list of features.
+     */
+    getFeaturesOnClientForAll(): Promise<any>;
+    /**
+     * Get the list of all features.
+     * @returns {Promise<Array>} The list of features.
+     */
+    getAllFeatures(): Promise<any>;
+    /**
+     * List all blogs from the current client that the requesting user has access
+     * to (i.e. blogs the user is an owner or editor of).
+     * @returns {Promise<Array>} The list of accessible blogs.
+     */
+    getBlogs(): Promise<any>;
+    /**
+     * Get a specific blog from the current client that the requesting user has
+     * access to (i.e. a blog the user is an owner or editor of).
+     * @param {string} id - The blog ID.
+     * @returns {Promise<Object>} The requested blog.
+     */
+    getBlog(id: any): Promise<any>;
+    /**
+     * Get the public information about a public blog.
+     * @param {string} id - The blog ID.
+     * @returns {Promise<Object>} The requested blog.
+     */
+    getPublicBlog(id: any): Promise<any>;
+    /**
+     * Create a new blog.
+     * @param {string} name - The blog name.
+     * @param {boolean} isPublic - Whether the blog is public.
+     * @param {boolean} commentsEnabled - Whether comments are enabled.
+     * @param {Array<string>} editors - The list of editor user IDs.
+     * @returns {Promise<void>}
+     */
+    createBlog(name: any, isPublic: any, commentsEnabled: any, editors: any): Promise<any>;
+    /**
+     * Save an update to a blog.
+     * @param {string} id - The blog ID.
+     * @param {string} name - The blog name.
+     * @param {boolean} isPublic - Whether the blog is public.
+     * @param {boolean} commentsEnabled - Whether comments are enabled.
+     * @param {Array<string>} editors - The list of editor user IDs.
+     * @returns {Promise<void>}
+     */
+    saveBlog(id: any, name: any, isPublic: any, commentsEnabled: any, editors: any): Promise<any>;
+    /**
+     * Delete a blog.
+     * @param {string} id - The blog ID.
+     * @returns {Promise<void>}
+     */
+    deleteBlog(id: any): Promise<any>;
+    /**
+     * Get articles for an overview of a blog.
+     * @param id - The blog ID.
+     * @returns An overview of the featured article and the most recent amd most popular articles.
+     */
+    getBlogOverview(id: string): Promise<{
+        featured: BaseBlogArticle & {
+            imageID?: string;
+            text: string;
+            publishedAt?: string;
+        };
+        mostRecent: (BaseBlogArticle & {
+            imageID?: string;
+            publishedAt?: string;
+        })[];
+        mostPopular: (BaseBlogArticle & {
+            imageID?: string;
+            publishedAt?: string;
+        })[];
+    }>;
+    /**
+     * Query a blog for articles.
+     * @param id - The blog ID.
+     * @param tag - Require the articles to include this exact.
+     * @param text - Require the articles to contain this text in their content or title.
+     * @param limit - Limit the amount of returned articles, min = 2, max = 24, default = 24.
+     * @param previousArticle - publishedAt date of the previous article to get the next page of articles.
+     * @param searchTag - Find all tags that include this substring.
+     * @param sortBy - By default the list is sorted by publishing date, if this field is 'views', they will be sorted by amount of views instead.
+     * @returns An object with two arrays: "articles" (which includes the articles that match the query) and "tags" (which contains the tags that match the searchTag string, only exists if searchTag was specified)
+     */
+    queryBlog(id: string, tag?: string, text?: string, limit?: number, previousArticle?: string, searchTag?: string, sortBy?: string): Promise<{
+        articles: BaseBlogArticle & {
+            text: string;
+            publishedAt: string;
+            imageID?: string;
+        }[];
+        tags: string[];
+    }>;
+    /**
+     * List all accessible articles from a blog (i.e. articles from blogs that the
+     * user is an owner or editor of).
+     * @param {string} blogID - The blog ID.
+     * @returns {Promise<Array>} The list of articles.
+     */
+    getArticles(blogID: any): Promise<any>;
+    /**
+     * Get a specific accessible article from a blog (i.e. articles from blogs that the
+     * user is an owner or editor of).
+     * @param {string} blogID - The blog ID.
+     * @param {string} id - The article ID.
+     * @returns {Promise<Object>} The requested article.
+     */
+    getArticle(blogID: any, id: any): Promise<any>;
+    /**
+     * Get a specific public article from a blog by specifying the unique slug.
+     * @param blogID - The blog ID.
+     * @param slug - The slug of the article.
+     * @returns The requested article.
+     */
+    getArticleBySlug(clientID: string, slug: string): Promise<BaseBlogArticle & {
+        author: string;
+        content: string;
+        publishedAt?: string;
+    }>;
+    /**
+     * Create a new article in an accesible blog.
+     * @param {string} blogID - The blog ID.
+     * @param {string} title - The article title.
+     * @param {string} slug - The article slug.
+     * @returns {Promise<void>}
+     */
+    createArticle(blogID: any, title: any, slug: any): Promise<any>;
+    /**
+     * Save an update to an article.
+     * @param {string} blogID - The blog ID.
+     * @param {string} id - The article ID.
+     * @param {string} title - The article title.
+     * @param {string} slug - The article slug.
+     * @param {boolean} isPublic - Whether the article is public.
+     * @param {Array<string>} tags - The list of tags.
+     * @param {string} author - The author user ID.
+     * @param {string} content - The article content.
+     * @returns {Promise<void>}
+     */
+    saveArticle(blogID: any, id: any, title: any, slug: any, isPublic: any, tags: any, author: any, content: any): Promise<any>;
+    /**
+     * Delete an article.
+     * @param {string} blogID - The blog ID.
+     * @param {string} id - The article ID.
+     * @returns {Promise<void>}
+     */
+    deleteArticle(blogID: any, id: any): Promise<any>;
+    /**
+     * List all accessible newsletters of the current client. Users without the
+     * newsletter_admin permission will only receive the newsletters they are an
+     * editor of.
+     * @returns {Promise<Array>} The list of newsletters.
+     */
+    getNewsletters(): Promise<any>;
+    /**
+     * Create a new newsletter, only available for client admins.
+     * @param {string} name - The name of the newsletter.
+     * @param {Array<string>} editors - The list of editor user IDs.
+     * @returns {Promise<Object>} Object with the id of the created newsletter.
+     */
+    createNewsletter(name: any, editors: any): Promise<any>;
+    /**
+     * Get a specific newsletter
+     * @param {string} id  - The newsletter ID.
+     * @returns {Promise<Object>} The requested newsletter.
+     */
+    getNewsletter(id: any): Promise<any>;
+    /**
+     * Edit a newsletter, only available for client admins.
+     * @param {string} id  - The newsletter ID.
+     * @param {string} name - The name of the newsletter.
+     * @param {string} sender - The sender name of the newsletter.
+     * @param {Array<string>} editors - The list of editor user IDs.
+     * @returns {Promise<Object>} The new state of the newsletter.
+     */
+    updateNewsletter(id: any, name: any, sender: any, editors: any): Promise<any>;
+    /**
+     * Delete a newsletter, only available for client admins.
+     * @param {string} id  - The newsletter ID.
+     * @returns {Promise<void>}
+     */
+    deleteNewsletter(id: any): Promise<any>;
+    /**
+     * Join a newsletter.
+     * @param id  - The newsletter ID.
+     * @param email  - The email of the user that wants to join the newsletter.
+     */
+    joinNewsletter(id: string, email: string): Promise<void>;
+    /**
+     * Confirm the email address that wants to receive a newsletter.
+     * @param {string} token  - The token from the email.
+     * @returns {Promise<void>}
+     */
+    confirmNewsletter(token: any): Promise<any>;
+    /**
+     * Unsubscribe an email address from a newsletter.
+     * @param token  - The token from the email.
+     */
+    unsubscribeFromNewsletter(token: string): Promise<void>;
+    /**
+     * List all newsletter blocks of the current client. Requires the newsletter_admin permission.
+     * @returns {Promise<Array>} The list of newsletter blocks.
+     */
+    getNewsletterBlocks(): Promise<any>;
+    /**
+     * Returns one specific newsletter block from the current client. Requires the newsletter_admin permission.
+     * @param {string} id  - The block ID.
+     * @returns {Promise<Object>} The requested newsletter blocks.
+     */
+    getNewsletterBlock(id: any): Promise<any>;
+    /**
+     * Create a new newsletter block in the current client.
+     * @param {string} name - The name of the new block.
+     * @returns {Promise<void>}
+     */
+    createNewsletterBlock(name: any): Promise<any>;
+    /**
+     * Update a newsletter block in the current client.
+     * @param {string} id - The ID of the block
+     * @param {string} name - The new name name.
+     * @param {object} inputs - The new inputs data, see API documentation.
+     * @param {string} html - The new HTML content.
+     * @param {string} css - The new CSS content.
+     * @param {boolean} acceptsChildren - Whether the block accepts children.
+     * @returns {Promise<void>}
+     */
+    updateNewsletterBlock(id: any, name: any, inputs: any, html: any, css: any, acceptsChildren: any): Promise<any>;
+    /**
+     * Delete a newsletter block.
+     * @param {string} id - The newsletter block ID.
+     * @returns {Promise<void>}
+     */
+    deleteNewsletterBlock(id: any): Promise<any>;
+    /**
+     * List all newsletter mails of the from a specific newsletter. The user needs to be an editor of the newsletter or have the newsletter_admin permission.
+     * @param {string} newsletterID  - The newsletter ID.
+     * @returns {Promise<Array>} The list of newsletter mails.
+     */
+    getNewsletterMails(newsletterID: any): Promise<any>;
+    /**
+     * Returns one specific newsletter mail. The user needs to be an editor of the newsletter or have the newsletter_admin permission.
+     * @param {string} newsletterID  - The newsletter ID.
+     * @param {string} mailID  - The newsletter mail ID.
+     * @returns {Promise<Object>} The requested newsletter mail.
+     */
+    getNewsletterMail(newsletterID: any, mailID: any): Promise<any>;
+    /**
+     * Create a new newsletter mail in the current client. The user needs to be an editor of the newsletter or have the newsletter_admin permission.
+     * @param {string} newsletterID  - The newsletter ID.
+     * @param {string} title - The title of the new mail.
+     * @returns {Promise<void>}
+     */
+    createNewsletterMail(newsletterID: any, title: any): Promise<any>;
+    /**
+     * Update a newsletter mail in the current client. The user needs to be an editor of the newsletter or have the newsletter_admin permission.
+     * @param {string} newsletterID  - The newsletter ID.
+     * @param {string} mailID  - The newsletter mail ID.
+     * @param {string} title - The title of the mail.
+     * @param {Array} blocks - The blocks that make up the mail.
+     * @param {string} parentBlock - The parent block of the mail.
+     * @returns {Promise<void>}
+     */
+    updateNewsletterMail(newsletterID: any, mailID: any, title: any, blocks: any, parentBlock: any): Promise<any>;
+    /**
+     * Render a newsletter mail from the specified blocks. Requires the newsletter_admin permission.
+     * @param {Array} blocks - The blocks that make up the mail.
+     * @param {string} parentBlock - The parent block of the mail.
+     * @returns {Promise<void>}
+     */
+    generatePreviewNewsletterMail(blocks: any, parentBlock: any): Promise<any>;
+    /**
+     * Send out a test of this newsletter mail to a specified recipient. The user needs to be an editor of the newsletter or have the newsletter_admin permission.
+     * @param {string} newsletterID  - The newsletter ID.
+     * @param {string} mailID  - The newsletter mail ID.
+     * @param {string} recipientEmail - The recipient of this test mail.
+     * @returns {Promise<void>}
+     */
+    sendTestNewsletter(newsletterID: any, mailID: any, recipientEmail: any): Promise<any>;
+    /**
+     * Send out this newsletter mail to all subscribers. Requires the newsletter_admin permission.
+     * @param {string} newsletterID  - The newsletter ID.
+     * @param {string} mailID  - The newsletter mail ID.
+     * @returns {Promise<void>}
+     */
+    sendOutNewsletter(newsletterID: any, mailID: any): Promise<any>;
+    /**
+     * List all pages of the current client. Only available for page admins.
+     * @returns {Promise<Array>} The list of pages.
+     */
+    getPages(): Promise<any>;
+    /**
+     * Create a new page. only available for page admins.
+     * @param {string} title - The title of the page.
+     * @param {string} slug - The slug of the page.
+     * @returns {Promise<void>}
+     */
+    createPage(title: any, slug: any): Promise<any>;
+    /**
+     * Get a specific page. Only available for page admins.
+     * @param {string} id  - The page ID.
+     * @returns {Promise<Object>} The requested page.
+     */
+    getPage(id: any): Promise<any>;
+    /**
+     * Edit a page. Only available for page admins.
+     * @param {string} id  - The page ID.
+     * @param {string} title - The title of the page.
+     * @param {string} slug - The slug of the page.
+     * @param {boolean} isPublic - Whether or not the page is public.
+     * @param {string} content - The slug of the page.
+     * @returns {Promise<void>}
+     */
+    updatePage(id: any, title: any, slug: any, isPublic: any, content: any): Promise<any>;
+    /**
+     * Delete a page. Only available for page admins.
+     * @param {string} id  - The page ID.
+     * @returns {Promise<void>}
+     */
+    deletePage(id: any): Promise<any>;
+    /**
+     * Get a public page by slug from a client.
+     * @param {string} clientID  - The ID of the client.
+     * @param {string} slug  - The slug of the page.
+     * @returns {Promise<Object>} The requested page.
+     */
+    getPublicPage(clientID: any, slug: any): Promise<any>;
+    /**
+     * Set the item flags for an item
+     * @param {string} itemID - The ID of the item.
+     * @param {boolean} isStaffPick - Whether the item is a staff pick.
+     * @param {number} featureWeight - The feature weight of the item, lower values are shown higher in Lemonate.
+     * @param {boolean} isGame - Whether the item is a game.
+     * @param {boolean} replaceIndex - If the current item at this index should be replaced.
+     * @param {number} internalRating - The internal rating of this item.
+     * @returns {Promise<void>}
+     */
+    setItemFlag(itemID: any, isStaffPick: any, featureWeight: any, isGame: any, replaceIndex: any, internalRating: any): Promise<any>;
+    /**
+     * Get the download URL for an item.
+     * @param {string} id - The item ID.
+     * @returns {string} The download URL.
+     */
+    getDownloadUrl(id: any): string;
+    /**
+     * Get the download URL for an item attachment.
+     * @param id - The item ID.
+     * @param name - The attachment name.
+     * @param queryParam - The attachment query parameter. Can be the dimension of the image, index of that type etc.
+     * @param index - The attachment index. Optional, defaults to 0.
+     * @returns The attachment download URL.
+     */
+    getAttachmentDownloadUrl(id: string, name: string, queryParam: number, index?: number): string;
+    /**
+     * Get the public download URL for an item attachment.
+     * @param id - The item ID.
+     * @param name - The attachment name.
+     * @param queryParam - The attachment query parameter. Can be the dimension of the image, index of that type etc.
+     * @param index - The attachment index. Optional, defaults to 0.
+     * @returns The attachment download URL.
+     */
+    getPublicAttachmentDownloadUrl(id: string, name: string, queryParam: number, index?: number): string;
+    /**
+     * Get the public download URL for an item.
+     * @param id - The item ID.
+     * @returns The public download URL.
+     */
+    getPublicDownloadUrl(id: string): string;
+    /**
+     * Post new feedback.
+     * @param text - The text of the feedback
+     */
+    postFeedback(text: string): Promise<void>;
+}
+
+declare class ApiGateway {
+    apiClient: ApiClient;
+    debug: boolean;
+    apiCalls: any[];
+    apiCallsStartTime: moment.Moment | null;
+    constructor(apiClient: ApiClient);
+    start(): void;
+    end(): void;
+    call(caller: string, method: string, ...params: any[]): Promise<any>;
+}
+
+declare class ItemChangeProcessor {
+    updateItemLinksAndAttributes(item: PreparedItem, includeLinkItems: boolean, clearUnusedLinks: boolean): void;
+    getLinksAndAttributes(item: PreparedItem, links: Array<any>, attributes: object, userAttributes: object, includeItems: boolean, clearUnusedLinks: boolean): void;
+    retrieveLinksAndAttributesFromFieldInstances(fieldInstances: Array<any>, links: Array<any>, attributes: object, includeLinkItems: boolean, clearUnusedLinks: boolean): void;
+    traverseTreeFieldInstance(blocks: Array<any>, links: Array<any>, attributes: object, path: string, includeLinkItems: boolean): void;
+    traverseListFieldInstances(blocks: Array<any>, links: Array<any>, attributes: object, path: string, includeLinkItems: boolean): void;
+    processScripts(scripts: Array<any>, links: Array<any>, attributes: object, path: string, includeLinkItems: boolean): void;
+}
+
+declare class ItemPreparator {
+    itemRepo: ItemRepo;
+    itemFetcher: Function;
+    constructor(itemRepo: ItemRepo);
+    setItemFetcher(itemFetcher: Function): void;
+    setFieldsFromDatatypes(item: PreparedItem): void;
+    prepare(item: any): Promise<PreparedItem>;
+    createFieldInstances(item: PreparedItem, fields: any[], attributes: Record<string, unknown>, path: string, attributeSrc: string, doNotFillValues?: boolean): Promise<Field[]>;
+    getFieldSet(item: PreparedItem, name: string): {
+        name: string;
+        fields: any[];
+    } | null;
+    fetchLinkValue(item: PreparedItem, linkUsage: string): Promise<{
+        id: string;
+        linkItem: any;
+        stopRecursion: boolean | undefined;
+    } | {
+        id: null;
+        linkItem: null;
+        stopRecursion?: undefined;
+    }>;
+    readBlocks(item: PreparedItem, parentBlock: Block | undefined, templates: Array<any>, treeNamespace: string, attributes: Record<string, unknown>, readChildren: boolean, readScripts: boolean, parentType: string): Promise<Array<any>>;
+    readScripts(item: PreparedItem, parentBlock: Block, treeNamespace: string, attributes: Record<string, unknown>): Promise<Array<any>>;
+    existsScriptNamespace(item: PreparedItem, attributes: Record<string, unknown>, namespace: string): boolean;
+    readConnections(item: PreparedItem, graphNamespace: string, attributes: Record<string, unknown>): Array<Connection>;
+    existsBlockNamespace(item: PreparedItem, attributes: Record<string, unknown>, namespace: string): boolean;
+    createFields(block: Block, item: PreparedItem, template: Template, blockPath: string, isGraphBlockField: boolean, attributes: Record<string, unknown>): Promise<Field[]>;
+    static refreshFieldDependencies(fields: Field[]): void;
+}
+
+type MetadataItem = {
+    _id: string;
+    name: string;
+    hash: string;
+    type: string;
+    mimeType: string;
+    folder: {
+        _id: string;
+    };
+    links: {
+        to: string;
+        item?: MetadataItem;
+    }[];
+    filesize: number;
+    packageFileOffset?: number;
+    attachments: {
+        name: string;
+        queryParam: number;
+        index: number;
+        filesize: number;
+        packageFileOffset?: number;
+        mimeType: string;
+        hash: string;
+        type: string;
+    }[];
+};
+type MetadataItemMap = {
+    [id: string]: MetadataItem;
+};
+type PackageCache = {
+    files: {
+        [id: string]: {
+            blob: Blob;
+            hash: string;
+            itemName: string;
+            itemType: string;
+            mimeType: string;
+        };
+    };
+    folders: {
+        [id: string]: {
+            _id: string;
+            name: string;
+            parent: string;
+        };
+    };
+    items: MetadataItemMap;
+};
+type ParsedPackage = {
+    metadata: MetadataItemMap;
+    rootItem: MetadataItem;
+    folders: typeof packageCache["folders"];
+    files: {
+        [key: string]: Buffer<any>;
+    };
+};
+declare const packageCache: PackageCache;
+declare function getFileFromCache(itemID: string): {
+    blob: Blob;
+    hash: string;
+    itemName: string;
+    itemType: string;
+    mimeType: string;
+};
+declare function getFolders(): {
+    [id: string]: {
+        _id: string;
+        name: string;
+        parent: string;
+    };
+};
+declare function getFolder(id: string): {
+    _id: string;
+    name: string;
+    parent: string;
+};
+declare function findFolder(name: string, parentID: string): {
+    _id: string;
+    name: string;
+    parent: string;
+} | undefined;
+declare function findItem(name: string, parentID: string): MetadataItem | undefined;
+declare function getItems(): MetadataItemMap;
+declare function getItemFromCache(itemID: string): MetadataItem;
+declare function addPackageToCache(packageID: string, packageContent: ParsedPackage): void;
+declare function parsePackage(binaryBlob: Blob, pkgID: string): Promise<ParsedPackage>;
+declare function createAttachmentID(id: string, name: string, queryParam: number, index: number): string;
+declare function queryAttachments(item: MetadataItem, name: string, queryParam?: number, index?: number): {
+    name: string;
+    queryParam: number;
+    index: number;
+    filesize: number;
+    packageFileOffset?: number;
+    mimeType: string;
+    hash: string;
+    type: string;
+} | null;
+declare function getAttachmentFromPackageCache(id: string, name: string, queryParam?: number, index?: number): {
+    blob: Blob;
+    hash: string;
+    itemName: string;
+    itemType: string;
+    mimeType: string;
+} | null | undefined;
+
+type Package_MetadataItem = MetadataItem;
+declare const Package_addPackageToCache: typeof addPackageToCache;
+declare const Package_createAttachmentID: typeof createAttachmentID;
+declare const Package_findFolder: typeof findFolder;
+declare const Package_findItem: typeof findItem;
+declare const Package_getAttachmentFromPackageCache: typeof getAttachmentFromPackageCache;
+declare const Package_getFileFromCache: typeof getFileFromCache;
+declare const Package_getFolder: typeof getFolder;
+declare const Package_getFolders: typeof getFolders;
+declare const Package_getItemFromCache: typeof getItemFromCache;
+declare const Package_getItems: typeof getItems;
+declare const Package_parsePackage: typeof parsePackage;
+declare const Package_queryAttachments: typeof queryAttachments;
+declare namespace Package {
+  export { Package_addPackageToCache as addPackageToCache, Package_createAttachmentID as createAttachmentID, Package_findFolder as findFolder, Package_findItem as findItem, Package_getAttachmentFromPackageCache as getAttachmentFromPackageCache, Package_getFileFromCache as getFileFromCache, Package_getFolder as getFolder, Package_getFolders as getFolders, Package_getItemFromCache as getItemFromCache, Package_getItems as getItems, Package_parsePackage as parsePackage, Package_queryAttachments as queryAttachments };
+  export type { Package_MetadataItem as MetadataItem };
+}
+
+declare class ItemRepo {
+    apiClient: ApiClient;
+    activeItem: PreparedItem | undefined;
+    rootItemId: string | undefined;
+    loadingItems: Map<string, Promise<PreparedItem | undefined>>;
+    loadedItems: Map<string, PreparedItem>;
+    itemInstances: Map<string, Map<string, PreparedItem>>;
+    resolvedPaths: Map<string, string>;
+    jail: any;
+    apiGateway: ApiGateway;
+    itemCache: ItemCache;
+    linkableItemsCache: LinkableItemsCache;
+    undoManager: UndoManager;
+    itemPreparator: ItemPreparator;
+    itemChangeProcessor: ItemChangeProcessor;
+    usePublicApi: boolean;
+    constructor(usePublicApi: boolean, apiClient: ApiClient);
+    _logGroup(msg: string): void;
+    _logGroupEnd(): void;
+    _log(msg: string): void;
+    getLoadedItems(): PreparedItem[];
+    getItemInstances(): Map<string, Map<string, PreparedItem>>;
+    findLoadedItem(id: string): PreparedItem | undefined;
+    _handleError(err: any, message: string): void;
+    getUndoManager(): UndoManager;
+    createFieldsForItem(block: Block, template: Template, ownerItem: PreparedItem): Promise<Field[]>;
+    createScriptsForItem(block: Block, scriptData: any[] | undefined, ownerItem: PreparedItem, proxify?: boolean): Promise<void>;
+    clear(): void;
+    removeBlock(block: Block, parent: any): void;
+    traverseBlockPairs(b1: Block, b2: Block, func: Function): void;
+    copyScripts(oldBlock: Block, newBlock: Block, deferInitCall?: boolean): Script[];
+    updateScriptFieldReferences(oldBlock: Block, newBlock: Block): void;
+    updateScriptFieldReferencesFromMap(nodeFieldMap: Map<string, string>, block: Block): void;
+    createNewBlock(templateEntry: TemplateEntry, parent: Block, ownerItem: PreparedItem): Promise<Block>;
+    addBlockToParent(block: Block, parent: Block, item: PreparedItem): Block;
+    createNewListEntry(templateEntry: TemplateEntry, field: Field, ownerItem: PreparedItem): Promise<any>;
+    createNewGraphNode(templateEntry: TemplateEntry, graph: Field, x: number, y: number, ownerItem: PreparedItem): Promise<Block>;
+    addNodeToGraph(block: Block, graph: Field, item: PreparedItem): void;
+    removeGraphNode(graph: Field, node: Block): void;
+    addGraphLink(graph: Field, srcNode: string, srcSlot: number, destNode: string, destSlot: number, ownerItem: PreparedItem): void;
+    removeGraphLink(graph: Field, srcNode: string, srcSlot: number, destNode: string, destSlot: number): void;
+    createNewScript(parent: Block, index: number | undefined, ownerItem: PreparedItem): Script;
+    removeScript(script: Script, parent: Block): void;
+    findBlock(id: string): Block | null;
+    loadPackage(url: string): Promise<PreparedItem>;
+    createPackageItemUrl(itemId: string): string | null;
+    revokePackageItemUrl(url: string): void;
+    _loadPackageContentRecursively(item: any, reportProgressFunc: Function): Promise<PreparedItem[]>;
+    createNewItemInstance(itemId: string): PreparedItem | null;
+    _addLoadedItem(item: any): void;
+    _addItemInstance(item: any): void;
+    loadItemByRelativePath(itemId: string, path: string, options?: any): Promise<PreparedItem | undefined>;
+    _loadItemFromApi(id: string, options?: any): Promise<any[]>;
+    _relinkItems(items: PreparedItem[], referenceMap: Map<string, PreparedItem>): void;
+    /**
+     *
+     * @param id
+     * @param options object
+     * @param options.parentId
+     * @param options.recursive boolean
+     * @param options.withCollaboration boolean
+     * @param options.progressCallback function
+     * @returns {Promise<PreparedItem | null>}
+     */
+    loadItem(id: string, options?: any): Promise<PreparedItem | undefined>;
+    _loadItemInternal(id: string, options?: any): Promise<PreparedItem | undefined>;
+    _linkAndPrepareItems(items: PreparedItem[]): Promise<PreparedItem[]>;
+    resolveRelativePath(path: string, itemId?: string | null): Promise<any>;
+    traverseItems(func: Function, rootItem?: PreparedItem | MetadataItem | undefined): Promise<void>;
+    traverseBlocks(func: Function, blocks: Block[]): Promise<void>;
+    traverseFieldInstances(func: Function, fieldInstances: Field[]): Promise<void>;
+    replaceLink(oldId: string, newId: string): Promise<void>;
+    saveItem(item: PreparedItem): Promise<PreparedItem> | null;
+    save(): Promise<void>;
+    existsUnsavedChanges(): Promise<boolean>;
+    handleRename({ id, newName }: {
+        id: any;
+        newName: any;
+    }): void;
+}
+
+declare class ProxyEvent {
+    type?: string;
+    itemId?: string;
+    elementId?: string;
+    target?: string;
+    prop?: string;
+    value?: any;
+    oldValue?: any;
+    createdAt: number;
+    moveTargetArray?: any[];
+    moveTargetArrayIndex?: number;
+    moveTargetElementId?: string;
+    start?: number;
+    length?: number;
+    position?: number;
+    elementsToDelete?: any[];
+    field?: Field;
+    fieldId?: string;
+    isLink?: boolean;
+    bundleIndex: number;
+    private _undoFunction?;
+    private _redoFunction?;
+    constructor(type?: string, itemId?: string, elementId?: string, target?: any, prop?: any, value?: any, oldValue?: any);
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    setUndoFunction(fn: Function): void;
+    setRedoFunction(fn: Function): void;
+    setMoveTarget(array: any[], index: number, elementId: string): void;
+    setRange(start: number, length: number): void;
+    setPosition(position: number): void;
+    setElementsToDelete(elements: any[]): void;
+    setField(field: Field): void;
+    setFieldId(id: string): void;
+    setIsLink(isLink: boolean): void;
+    clone(): ProxyEvent & this;
+    isWithinMergeDeltaOf(other: ProxyEvent): boolean;
+    isMergeableWith(other: ProxyEvent): any;
+    merge(other: ProxyEvent): (ProxyEvent & this) | null;
+}
+
+declare class SnapshotEntry {
+    id: string;
+    items: {
+        _id: string;
+        instanceId: string;
+        data: Snapshot;
+    }[];
+}
+declare class UndoManager {
+    itemRepo: ItemRepo;
+    undoEvents: ProxyEvent[];
+    redoEvents: ProxyEvent[];
+    maxUndoCount: number;
+    enabled: boolean;
+    snapshots: Map<string, SnapshotEntry>;
+    private _undoRedoPromise;
+    constructor(itemRepo: ItemRepo, maxUndoCount?: number);
+    clear(): void;
+    createSnapshot(): string;
+    rollbackFromSnapshot(id: string): void;
+    _grabSnapshot(item: PreparedItem): Snapshot;
+    _getFieldInstance(item: PreparedItem, id: string): Field | null;
+    _rollbackFromSnapshot(item: PreparedItem, snapshot: Snapshot): void;
+    getEnabled(): boolean;
+    setEnabled(value: boolean): void;
+    ignore(func: Function): any;
+    undo(count: number): Promise<void>;
+    redo(count: number): Promise<void>;
+    private _performUndo;
+    private _performRedo;
+    getUndoSteps(): {
+        type: string | undefined;
+        itemId: string | undefined;
+        prop: string | undefined;
+    }[];
+    getRedoSteps(): {
+        type: string | undefined;
+        itemId: string | undefined;
+        prop: string | undefined;
+    }[];
+    event(event: ProxyEvent): void;
+    getNumberOfUndoBundles(): number;
+    getNumberOfRedoBundles(): number;
+    spliceLastEventBundle(events: ProxyEvent[]): ProxyEvent[];
+    spliceFirstEventBundle(events: any): any;
+    assignBundleIndexToEvent(event: ProxyEvent): void;
+}
+
+declare class Proxifier {
+    suppressDirty: boolean;
+    undoManager?: UndoManager;
+    private _promises;
+    private _capturePromises;
+    private _profiledEvents;
+    private _profiling;
+    private _profilerStartTime;
+    private _profiledCount;
+    private static _instance;
+    static get instance(): Proxifier;
+    private constructor();
+    suppressDirtyFlag(value: boolean): void;
+    setUndoManager(manager: UndoManager): void;
+    isUndoManagerActive(): boolean | undefined;
+    private _postUndoManagerEvent;
+    setItemDirty(item: PreparedItem, prop: any, origValue: any, value: any): void;
+    capturePromise(func: Function): Promise<any[]>;
+    startProfiling(): void;
+    endProfiling(): void;
+    private _addPromise;
+    private _proxyObject;
+    private _proxyArray;
+    proxyBlockArray(arr: any[], block: Block, item: PreparedItem): any[];
+    proxyListArray(arr: any[], field: Field, item: PreparedItem): any[];
+    proxyScriptArray(arr: any[], block: Block, item: PreparedItem): any[];
+    proxyBlock(block: Block, item: PreparedItem): any;
+    proxyGraphBlock(block: Block, item: PreparedItem): any;
+    proxyGraphBlockArray(arr: Block[], graphItem: any): any[];
+    proxyConnection(connection: Connection, graphItem: any): any;
+    proxyConnectionArray(arr: Connection[], graphItem: any): any[];
+    proxyItemField(field: Field, item: any): any;
+    proxyGraphBlockField(field: Field, block: Block, item: PreparedItem): any;
+    proxyBlockField(field: Field, block: Block, item: PreparedItem): any;
+    proxyScriptItem(scriptItem: any, script: any, item: any): any;
+    proxyScriptFieldsArray(fields: any, script: any, item: any): any[];
+    proxyScriptField(field: any, script: any, item: any): any;
+}
+
+declare const _default: {
+    createGUID: () => string;
+    toUserFriendlyName: (variableName: string) => string;
+    assert: (value: any, msg: string) => void;
+    matchItemIdAndObject(value1: any, value2: any): boolean;
+    areValuesEqual(a: any, b: any, maxLevels?: number): boolean;
+    startTimer(msg: string): (msg: string) => void;
+    dataURItoBlob(dataURI: string): Blob;
+    xmur3(str: any): () => number;
+    mulberry32(seed: number): () => number;
+    hslToRgb(h: number, s: number, l: number): number[];
+    rgbToHex(r: number, g: number, b: number): string;
+    /**
+     * Create a bright, saturated color from a string (deterministic).
+     * @param {string} str
+     * @param {{minS?:number, maxS?:number, minL?:number, maxL?:number, return?:'hex'|'hsl'|'rgb'}} [opts]
+     */
+    colorFromString(str: string, opts?: any): string;
+};
+
+declare class ProfilerEntry {
+    level: number;
+    name: string;
+    times: number[];
+    durations: number[];
+    childrenMap: Map<string, ProfilerEntry>;
+    children: ProfilerEntry[];
+    parent?: ProfilerEntry;
+    constructor(name: string, level: number, time: number, parent?: ProfilerEntry);
+}
+declare class Profiler {
+    startTime: number;
+    endTime: number;
+    startIteration: number;
+    currentLevel: number;
+    root: ProfilerEntry;
+    currentEntry: ProfilerEntry;
+    active: boolean;
+    private static _instance;
+    static get instance(): Profiler;
+    private constructor();
+    start(): void;
+    end(printResults?: boolean): void;
+    private _iterate;
+    getResults(): any[];
+    printResults(): void;
+    newIteration(): void;
+    asyncBlock(key: string, func: Function): Promise<any>;
+    block(key: string, func: Function): any;
+    beginBlock(name: string): ProfilerEntry | undefined;
+    endBlock(entry?: ProfilerEntry): void;
+}
+
+declare class Exception extends Error {
+    constructor(msg?: any, name?: string);
+    toString(): string;
+}
+declare class InvalidArgumentException extends Exception {
+    constructor(msg?: any);
+}
+declare class InvalidStateException extends Exception {
+    constructor(msg?: any);
+}
+declare class LoaderException extends Exception {
+    constructor(msg?: any);
+}
+declare class QuotaExceededException extends Exception {
+    constructor(msg?: any);
+}
+declare class AccessDeniedException extends Exception {
+    constructor(msg?: any);
+}
+
+declare function getDatatypeByName(name: string, solveInheritance?: boolean): any;
+
+declare function verifyAcl(userInfo: any, acls: any, action: string): true | undefined;
+declare function hasPermission(userInfo: any, perm: any, needsSuperadmin: boolean): boolean;
+
+export { AccessDeniedException, AggregatedItem, ApiClient, ApiGateway, Block, EventEmitter, Field, InvalidArgumentException, InvalidStateException, Item, ItemCache$1 as ItemCache, ItemRepo, ItemVisibility, LinkableItemsCache, LoaderException, Package as PackageTools, PreparedItem, Profiler, Proxifier, ProxyEvent, QuotaExceededException, Script, ScriptField, Snapshot, Storage, Template, ThumbCache, UndoManager, eventBus, getDatatypeByName, hasPermission, _default as tools, verifyAcl };
+export type { Acl, Attachments, BaseBlogArticle, ConversationEntry, FolderListingOptions, FolderListingWithOptions, ItemOptions, ItemQueryOptions, ItemQueryWithOptions, ItemWithOptions, JobState, Me, ProgressCallback, UserInfo };