alfresco-js-api/index.d.ts

JavaScript client library for the Alfresco REST API

declare class AlfrescoApi {

    constructor(config: AlfrescoApi.AlfrescoApiConfig);

    configureJsApi(config: AlfrescoApi.AlfrescoApiConfig): void;

    changeEcmHost(ecmHost: string): void;

    changeBpmHost(bpmHost: string): void;

    changeCsrfConfig(disableCsrf: boolean): void;

    isLoggedIn(): boolean;

    login(username: string, password: string): Promise<string>;

    logout(): Promise<any>;

    loginTicket(ticket: string): any;

    refreshToken(): Promise<string>;

    implicitLogin(): Promise<any>;

    getTicket(): Array<string>;

    getTicketBpm(): string;

    getTicketEcm(): string;

    setTicket(ticketEcm: any, ticketBpm: any): void;

    config: AlfrescoApi.AlfrescoApiConfig;

    isBpmLoggedIn(): boolean;

    isEcmLoggedIn(): boolean;

    getBpmUsername(): string;

    getEcmUsername(): string;

    isBpmConfiguration(): boolean;

    isEcmConfiguration(): boolean;

    isOauthConfiguration(): boolean;

    isEcmBpmConfiguration(): boolean;

    Activiti: AlfrescoApi.Activiti;
    Auth: AlfrescoApi.Auth;
    Core: AlfrescoApi.Core;
    Discovery: AlfrescoApi.Discovery;
    Search: AlfrescoApi.Search;
    GsCore: AlfrescoApi.GsCore;
    GsClassification: AlfrescoApi.GsClassification;


    bpmAuth: AlfrescoApi.BpmAuthApi;
    ecmAuth: AlfrescoApi.EcmAuthApi;
    oauth2Auth: AlfrescoApi.OauthApi;

    activiti: AlfrescoApi.Activiti;
    core: AlfrescoApi.Core;
    discovery: AlfrescoApi.Discovery;
    search: AlfrescoApi.Search;
    gsCore: AlfrescoApi.GsCore;
    gsClassification: AlfrescoApi.GsClassification;
    nodes: AlfrescoApi.NodesApi;
    content: AlfrescoApi.ContentApi;
    upload: AlfrescoApi.UploadApi;
    webScript: AlfrescoApi.WebscriptApi;

    ecmClient: AlfrescoApi.EcmClient;
    bpmClient: AlfrescoApi.BpmClient;
}

declare namespace AlfrescoApi {

    export interface AlfrescoApi {

        new(config: AlfrescoApiConfig): AlfrescoApi;

        configureJsApi(config: AlfrescoApi.AlfrescoApiConfig): void;

        changeEcmHost(ecmHost: string): void;

        changeBpmHost(bpmHost: string): void;

        changeCsrfConfig(disableCsrf: boolean): void;

        isLoggedIn(): boolean;

        login(username: string, password: string): Promise<string>;

        logout(): Promise<any>;

        loginTicket(ticket: string): any;

        refreshToken(): Promise<string>;

        implicitLogin(): Promise<any>;

        getTicket(): Array<string>;

        getTicketBpm(): string;

        getTicketEcm(): string;

        setTicket(ticketEcm: any, ticketBpm: any): void;

        config: AlfrescoApiConfig;

        isBpmLoggedIn(): boolean;

        isEcmLoggedIn(): boolean;

        getBpmUsername(): string;

        getEcmUsername(): string;

        on(nameEvent: string, callBack: any);

        isBpmConfiguration(): boolean;

        isEcmConfiguration(): boolean;

        isOauthConfiguration(): boolean;

        isEcmBpmConfiguration(): boolean;

        Activiti: Activiti;
        Auth: Auth;
        Core: Core;
        Discovery: Discovery;
        Search: Search;
        GsCore: GsCore;
        GsClassification: GsClassification;

        bpmAuth: BpmAuthApi;
        ecmAuth: EcmAuthApi;
        oauth2Auth: OauthApi;

        activiti: Activiti;
        core: Core;
        discovery: Discovery;
        search: Search;
        gsCore: GsCore;
        gsClassification: GsClassification;

        nodes: NodesApi;
        content: ContentApi;
        upload: UploadApi;
        webScript: WebscriptApi;

        ecmClient: EcmClient;
        bpmClient: BpmClient;
    }

    export class FolderEntity {
        constructor(obj?: any);

        items: DocumentEntity[];
    }

    export class DocumentEntity {
        constructor(obj?: any);

        nodeRef: string;
        nodeType: string;
        type: string;
        mimetype: string;
        isFolder: boolean;
        isLink: boolean;
        fileName: string;
        displayName: string;
        status: string;
        title: string;
        description: string;
        author: string;
        createdOn: string;
        createdBy: string;
        createdByUser: string;
        modifiedOn: string;
        modifiedBy: string;
        modifiedByUser: string;
        lockedBy: string;
        lockedByUser: string;
        size: number;
        version: string;
        contentUrl: string;
        webdavUrl: string;
        actionSet: string;
        tags: string[];
        activeWorkflows: string;
        location: LocationEntity;
    }

    export class LocationEntity {
        constructor(obj?: any);

        repositoryId: string;
        site: string;
        siteTitle: string;
        container: string;
        path: string;
        file: string;
        parent: LocationParentEntity;
    }

    export class LocationParentEntity {
        constructor(obj?: any);

        nodeRef: string;
    }

    export class DeletedNodesPaging {
        constructor(obj?: any);

        list: DeletedNodesPagingList;
    }

    export class DeletedNodesPagingList {
        constructor(obj?: any);

        pagination: Pagination;
        entries: DeletedNodeEntity[];
    }

    export class Source {
        constructor(obj?: any);

        id: string;
        name?: string;
        createdAt?: Date;
        modifiedAt?: Date;
        createdByUser?: UserInfo;
        modifiedByUser?: UserInfo;
        isFolder?: boolean;
        isFile?: boolean;
        aspectNames?: Array<string>;
        properties?: any;
        nodeType?: string;
    }

    export class MinimalNodeEntity {
        constructor(obj?: any);

        entry?: MinimalNodeEntryEntity;
    }

    export class DeletedNodeEntity {
        constructor(obj?: any);

        entry?: DeletedNodeMinimalEntry;
    }

    export class Node {
        constructor(obj?: any);

        id?: string;
        nodeId?: string;
        name?: string;
        nodeType?: string;
        isFolder?: boolean;
        isFile?: boolean;
        isFavorite?: boolean;
        isLocked?: boolean;
        modifiedAt?: Date;
        modifiedByUser?: UserInfo;
        adddAt?: Date;
        adddByUser?: UserInfo;
        parentId?: string;
        isLink?: boolean;
        content?: ContentInfo;
        aspectNames?: Array<string>;
        properties?: any;
        allowableOperations?: Array<string>;
        path?: PathInfo;
        permissions?: PermissionsInfo;
        createdAt?: Date;
        createdByUser?: UserInfo;
    }

    export class MinimalNode extends Node {
        constructor(obj?: any);

    }

    export interface EcmClient {
        new(config: AlfrescoApiConfig): EcmClient;

        changeHost(host: string): void;

        setAuthentications(authentications: any): void;

        callApi(path: string, httpMethod: string, pathParams?: any, queryParams?: any, headerParams?: any, formParams?: any, bodyParam?: any, authNames?: string[], contentTypes?: string[], accepts?: string[], returnType?: any, contextRoot?: string, responseType?: string): Promise<any>;
    }

    export interface BpmClient {
        new(config: AlfrescoApiConfig): BpmClient;

        changeHost(host: string): void;

        setAuthentications(authentications: any): void;

        callApi(path: string, httpMethod: string, pathParams?: any, queryParams?: any, headerParams?: any, formParams?: any, bodyParam?: any, authNames?: string[], contentTypes?: string[], accepts?: string[], returnType?: any, contextRoot?: string, responseType?: string): Promise<any>;

    }

    export interface SearchClient {
        new(config: AlfrescoApiConfig): SearchClient;

        changeHost(): void;

        setAuthentications(authentications: any): void;
    }

    export interface EcmPrivateClient {
        new(config: AlfrescoApiConfig): EcmPrivateClient;

        changeHost(host: string): void;

        setAuthentications(authentications: any): void;
    }

    export class MinimalNodeEntryEntity extends MinimalNode {
        constructor(obj?: any);

    }

    export class NodeProperties {
        constructor(obj?: any);

        [key: string]: any;
    }

    export class DeletedNodeMinimalEntry extends MinimalNode {
        constructor(obj?: any);

        archivedAt: Date;
        archivedByUser: UserInfo;
    }

    export class PathInfoEntity {
        constructor(obj?: any);

        elements: PathElementEntity[];
        isComplete: boolean;
        name: string;
    }

    export class PathElementEntity {
        constructor(obj?: any);

        id: string;
        name: string;
    }

    export interface Auth {
    }

    export interface ApiClient {
        new(client: any): ApiClient;
    }

    export interface BpmAuth {
        new(config: any): BpmAuth;
    }

    //  ======= Discovery start ======

    export interface Discovery {
        new(config: any): Discovery;

        discoveryApi: DiscoveryApi;
    }

    export interface DiscoveryApi {
        getRepositoryInformation(): Promise<DiscoveryEntry>;
    }

    export interface DiscoveryEntry {
        entry: RepositoryEntry;
    }

    export class EntitlementsInfo {
        constructor(obj?: any);

        maxUsers?: number;
        maxDocs?: number;
        isClusterEnabled?: boolean;
        isCryptodocEnabled?: boolean;
    }


    export interface Error {
        error?: ErrorError;
    }

    export class LicenseInfo {
        constructor(obj?: any);

        issuedAt: Date;
        expiresAt: Date;
        remainingDays: number;
        holder: string;
        mode: string;
        entitlements?: EntitlementsInfo;
    }

    export class ModuleInfo {
        constructor(obj?: any);

        id?: string;
        title?: string;
        description?: string;
        version?: string;
        installDate?: Date;
        installState?: string;
        versionMin?: string;
        versionMax?: string;
    }

    export class RepositoryInfo {
        constructor(obj?: any);

        edition: string;
        version: VersionInfo;
        status: StatusInfo;
        license?: LicenseInfo;
        modules?: Array<ModuleInfo>;
    }

    export class RepositoryEntry {
        constructor(obj?: any);

        repository: RepositoryInfo;
    }

    export class StatusInfo {
        constructor(obj?: any);

        isReadOnly: boolean;
        isAuditEnabled: boolean;
        isQuickShareEnabled: boolean;
        isThumbnailGenerationEnabled: boolean;
    }

    export class VersionInfo {
        constructor(obj?: any);

        major: string;
        minor: string;
        patch: string;
        hotfix: string;
        schema: number;
        label: string;
        display: string;
    }

    export class PersonBodyCreate {
        constructor(obj?: any);

        id: string;
        firstName: string;
        lastName: string;
        email: string;
        password: number;
        properties: any;
    }

    //  ======= Discovery end ======


    //  ======= Core Start ======

    export interface FavoritesApi {
        new(client: ApiClient): FavoritesApi;

        addFavorite(personId?: string, favoriteBody?: FavoriteBody): Promise<FavoriteEntry>;

        // addSiteFavorite(personId?: string, favoriteSiteBody?: FavoriteSiteBody, fields?: Array<string>, opts?: any): Promise<FavoriteSiteEntry>;
        // removeFavorite(personId?: string, favoriteId?: string, opts?: any): Promise<any>;
        removeFavoriteSite(personId?: string, favoriteId?: string): Promise<any>;

        getFavorite(personId?: string, favoriteId?: string, opts?: any): Promise<FavoriteEntry>;

        getFavorites(personId?: string, opts?: { skipCount?: number, maxItems?: number, where?: string, fields?: Array<string> }): Promise<FavoritePaging>;

        getFavoriteSite(personId?: string, siteId?: string, opts?: any): Promise<SiteEntry>;

        // listFavoriteSitesForPerson(personId?: string, skipCount?: number, maxItems?: number, fields?: Array<string>, opts?: any): Promise<SitePaging>;
        // listFavorites(personId?: string, skipCount?: number, maxItems?: number, where?: string, fields?: Array<string>, opts?: any): Promise<FavoritePaging>;
    }

    export interface ChildAssociationsApi {
        new(client: ApiClient): ChildAssociationsApi;

        addNode(nodeId?: string, nodeBody?: NodeBody, opts?: { autoRename?: boolean, include?: Array<string>, fields?: Array<string> }): Promise<NodeEntry>;

        addSecondaryChildAssoc(parentId?: string, assocChildBody?: AssocChildBody): Promise<any>;

        deleteNode(nodeId?: string, opts?: { permanent?: boolean }): Promise<any>;

        getNodeChildren(nodeId?: string, opts?: { skipCount?: number, maxItems?: number, orderBy?: string, where?: string, include?: Array<string>, relativePath?: string, includeSource?: boolean, fields?: Array<string> }): Promise<NodePaging>;

        listParents(childId?: string, opts?: { where?: string, include?: string, fields?: Array<string> }): Promise<NodeAssocPaging>;

        listSecondaryChildAssociations(parentId?: string, opts?: { assocType?: string, where?: string, include?: string, fields?: Array<string> }): Promise<NodeAssocPaging>;

        moveNode(nodeId?: string, moveBody?: MoveBody, opts?: { include?: Array<string>, fields?: Array<string> }): Promise<NodeEntry>;
    }

    export interface AssociationsApi {
        new(client: ApiClient): AssociationsApi;

        addAssoc(sourceId?: string, assocTargetBody?: AssocTargetBody): Promise<any>;

        listSourceNodeAssociations(targetId?: string, opts?: { where?: string, include?: string, fields?: Array<string> }): Promise<NodeAssocPaging>;

        listTargetAssociations(sourceId?: string, opts?: { where?: string, include?: string, fields?: Array<string> }): Promise<NodeAssocPaging>;

        removeAssoc(sourceId?: string, targetId?: string, opts?: { assocType?: string }): Promise<any>;

    }

    export interface CommentsApi {
        new(client: ApiClient): CommentsApi;

        addComment(nodeId?: string, commentBody?: CommentBody, opts?: any): Promise<CommentEntry>;

        getComments(nodeId?: string, opts?: any): Promise<CommentPaging>;

        removeComment(nodeId?: string, commentId?: string): Promise<any>;

        updateComment(nodeId?: string, commentId?: string, commentBody?: CommentBody, opts?: any): Promise<CommentEntry>;
    }

    export interface NetworksApi {
        new(client: ApiClient): NetworksApi;

        getNetwork(networkId?: string, opts?: any): Promise<PersonNetworkEntry>;

        getNetworkForPerson(personId?: string, networkId?: string, opts?: any): Promise<PersonNetworkEntry>;

        listNetworksForPerson(personId?: string, opts?: any): Promise<PersonNetworkPaging>;
    }

    export interface NodesApi {
        new(client: ApiClient): NodesApi;

        addNode(nodeId: string, nodeBody: any, opts?: { autoRename?: boolean, include?: Array<string>, fields?: Array<string> }, formParams?: any): Promise<NodeEntry>;

        copyNode(nodeId: string, copyBody: any, opts?: { include?: Array<string>, fields?: Array<string> }): Promise<NodeEntry>;

        deleteNode(nodeId?: string, opts?: { permanent?: boolean }): Promise<any>;

        purgeDeletedNode(nodeId: string): Promise<any>;

        // custom API not exposed by the platform
        getNodeInfo(nodeId: string, opts?: any): Promise<Node>;

        // custom API not exposed by the platform
        deleteNodePermanent(nodeId: string): Promise<any>;

        // custom API not exposed by the platform
        createFolder(name: string, relativePath: string, nodeId?: string, opts?: any): Promise<NodeEntry>;

        // custom API not exposed by the platform
        createFolderAutoRename(name: string, relativePath: string, nodeId: string, opts): Promise<NodeEntry>;

        getDeletedNode(nodeId?: string, opts?: { include?: Array<string> }): Promise<DeletedNodeEntry>;

        getDeletedNodes(opts?: { skipCount?: number, maxItems?: number, include?: Array<string> }): Promise<DeletedNodesPaging>;

        getFileContent(nodeId?: string, opts?: { attachment?: boolean, ifModifiedSince?: Date }): Promise<any>;

        getNode(nodeId?: string, opts?: { include?: Array<string>, relativePath?: string, fields?: Array<string> }): Promise<NodeEntry>;

        getNodeContent(nodeId?: string, opts?: any): Promise<any>;

        getNodeChildren(nodeId?: string, opts?: { skipCount?: number, maxItems?: number, orderBy?: string, where?: string, include?: Array<string>, relativePath?: string, includeSource?: boolean, fields?: Array<string> }): Promise<NodePaging>;

        getParents(nodeId?: string, opts?: { where?: string, include?: Array<string>, skipCount?: number, maxItems?: number, includeSource?: boolean, fields?: Array<string> }): Promise<NodeAssociationPaging>;

        getSecondaryChildren(nodeId?: string, opts?: { where?: string, include?: Array<string>, skipCount?: number, maxItems?: number, includeSource?: boolean, fields?: Array<string> }): Promise<NodeChildAssociationPaging>;

        getSourceAssociations(nodeId?: string, opts?: { where?: string, include?: Array<string>, fields?: Array<string> }): Promise<NodeAssociationPaging>;

        getTargetAssociations(nodeId?: string, opts?: { where?: string, include?: Array<string>, fields?: Array<string> }): Promise<NodeAssociationPaging>;

        lockNode(nodeId?: string, nodeBodyLock?: NodeBodyLock, opts?: { include?: Array<string>, fields?: Array<string> }): Promise<NodeEntry>;

        unlockNode(nodeId?: string, opts?: { include?: Array<string>, fields?: Array<string> }): Promise<NodeEntry>;

        moveNode(nodeId?: string, moveBody?: MoveBody, opts?: { include?: Array<string>, fields?: Array<string> }): Promise<NodeEntry>;

        restoreNode(nodeId?: string): Promise<any>;

        updateFileContent(nodeId?: string, contentBody?: string, opts?: { majorVersion?: boolean, comment?: string, include?: Array<string>, fields?: Array<string> }): Promise<NodeEntry>;

        updateNodeContent(nodeId?: string, contentBody?: string, opts?: any): Promise<NodeEntry>;

        updateNode(nodeId?: string, nodeBody?: NodeBody, opts?: { include?: Array<string>, fields?: Array<string> }): Promise<NodeEntry>;
    }

    export interface SitesApi {
        new(client?: ApiClient): SitesApi;

        addSiteMember(siteId?: string, siteMemberBody?: SiteMemberBody): Promise<SiteMemberEntry>;

        createSite(siteBody?: SiteBody, opts?: { skipConfiguration?: Boolean, skipAddToFavorites?: Boolean }): Promise<SiteEntry>;

        deleteSite(siteId?: string, opts?: { permanent?: Boolean }): Promise<any>;

        getSite(siteId?: string, opts?: { relations?: Array<string>, fields?: Array<string> }): Promise<SiteEntry>;

        getSiteContainer(siteId?: string, containerId?: string, opts?: Array<string>): Promise<SiteContainerEntry>;

        getSiteContainers(siteId?: string, opts?: { skipCount?: number, maxItems?: number, fields?: Array<string> }): Promise<SiteContainerPaging>;

        getSiteMember(siteId?: string, personId?: string, opts?: { fields?: Array<string> }): Promise<SiteMemberEntry>;

        getSiteMembers(siteId?: string, opts?: { skipCount?: number, maxItems?: number, fields?: Array<string> }): Promise<SiteMemberPaging>;

        getSites(opts?: { skipCount?: number, maxItems?: number, orderBy?: string, relations?: Array<string>, fields?: Array<string> }): Promise<SitePaging>;

        removeSiteMember(siteId?: string, personId?: string): Promise<any>;

        updateSiteMember(siteId?: string, personId?: string, siteMemberRoleBody?: SiteMemberRoleBody): Promise<SiteMemberEntry>;
    }

    export interface GroupsApi {
        new(client?: ApiClient): GroupsApi;

        createGroup(groupBody?: GroupBody, opts?: { include?: Array<string>, fields?: Array<string> }): Promise<GroupsEntry>;

        getGroups(opts?: { skipCount?: number, maxItems?: number, orderBy?: string, where?: string, include?: Array<string>, fields?: Array<string> }): Promise<GroupsPaging>;

        deleteGroup(groupId?: string, opts?: { cascade?: boolean }): Promise<any>;

        getGroup(groupId?: string, opts?: { include?: Array<string>, fields?: Array<string> }): Promise<GroupsEntry>;

        updateGroup(groupId?: string, groupBody?: GroupBody, opts?: { include?: Array<string>, fields?: Array<string> }): Promise<GroupsEntry>;

        getGroupMembers(groupId?: string, opts?: { skipCount?: number, maxItems?: number, orderBy?: string, where?: string, include?: Array<string>, fields?: Array<string> }): Promise<GroupMemberPaging>;

        addGroupMember(groupId?: string, groupBody?: GroupBody, opts?: { fields?: Array<string> }): Promise<GroupMemberEntry>;

        deleteGroupMember(groupId?: string, groupMemberId?: string): Promise<any>;
    }

    export interface PeopleApi {
        new(client: ApiClient): PeopleApi;

        addPerson(person: PersonBodyCreate): Promise<PersonEntry>;

        addFavorite(personId?: string, favoriteBody?: FavoriteBody): Promise<FavoriteEntry>;

        addSiteMembershipRequest(personId?: string, siteMembershipBody?: SiteMembershipRequestBody): Promise<SiteMembershipRequestEntry>;

        deleteFavoriteSite(personId?: string, siteId?: string): Promise<any>;

        favoriteSite(personId?: string, favoriteSiteBody?: FavoriteSiteBody): Promise<FavoriteEntry>;

        getActivities(personId?: string, opts?: { skipCount?: number, maxItems?: number, who?: string, siteId?: string, fields?: Array<string> }): Promise<ActivityPaging>;

        getFavorite(personId?: string, favoriteId?: string, opts?: { fields?: Array<string> }): Promise<FavoriteEntry>;

        getFavoriteSite(personId?: string, siteId?: string, opts?: { fields?: Array<string> }): Promise<SiteEntry>;

        getFavoriteSites(personId?: string, opts?: { skipCount?: number, maxItems?: number, fields?: Array<string> }): Promise<SitePaging>;

        getFavorites(personId?: string, opts?: { skipCount?: number, maxItems?: number, where?: string, fields?: Array<string> }): Promise<FavoritePaging>;

        getPerson(personId?: string, opts?: { fields?: Array<string> }): Promise<PersonEntry>;

        getPersons(opts?: { skipCount?: number, maxItems?: number, fields?: Array<string> }): Promise<PersonPaging>;

        getPersonNetwork(personId?: string, networkId?: string, opts?: { fields?: Array<string> }): Promise<PersonNetworkEntry>;

        getPersonNetworks(personId?: string, opts?: { skipCount?: number, maxItems?: number, fields?: Array<string> }): Promise<PersonNetworkPaging>;

        getPreference(personId?: string, preferenceName?: string, opts?: { fields?: Array<string> }): Promise<PreferenceEntry>;

        getPreferences(personId?: string, opts?: { skipCount?: number, maxItems?: number, fields?: Array<string> }): Promise<PreferencePaging>;

        getSiteMembership(personId?: string, opts?: { skipCount?: number, maxItems?: number, orderBy?: string, relations?: Array<string>, fields?: Array<string> }): Promise<SitePaging>;

        getSiteMembershipRequest(personId?: string, siteId?: string, opts?: { fields?: Array<string> }): Promise<SiteMembershipRequestEntry>;

        getSiteMembershipRequests(personId?: string, opts?: { skipCount?: number, maxItems?: number, fields?: Array<string> }): Promise<SiteMembershipRequestPaging>;

        removeFavoriteSite(personId?: string, favoriteId?: string): Promise<any>;

        removeSiteMembershipRequest(personId?: string, siteId?: string): Promise<any>;

        updateSiteMembershipRequest(personId?: string, siteId?: string, siteMembershipBody?: SiteMembershipRequestBody): Promise<any>;

        getGroupsMembership(personId?: string, opts?: { skipCount?: number, maxItems?: number, orderBy?: string, where?: string, include?: Array<string>, fields?: Array<string> }): Promise<GroupsPaging>;
    }

    // export interface PreferencesApi {
    //     getPreference(personId?: string, opts?: any): Promise<PreferenceEntry>;
    //     getPreferences(personId?: string, opts?: any): Promise<PreferencePaging>;
    // }

    export interface QueriesApi {
        new(client: ApiClient): QueriesApi;

        findNodes(term?: string, opts?: any): Promise<NodePaging>;

        findPeople(term?: string, opts?: any): Promise<PersonPaging>;

        findSites(term?: string, opts?: any): Promise<SitePaging>;
    }

    export interface RenditionsApi {
        new(client: ApiClient): RenditionsApi;

        createRendition(nodeId?: string, renditionBody?: RenditionBody): Promise<any>;

        getRendition(nodeId: string, renditionId: string): Promise<RenditionEntry>;

        getRenditionContent(nodeId: string, renditionId: string, opts?: { attachment?: boolean, ifModifiedSince?: Date }): Promise<any>;

        getRenditions(nodeId: string): Promise<RenditionPaging>;

        getSharedLinkRenditions(sharedId: string): Promise<RenditionPaging>;

        getSharedLinkRendition(sharedId: string, renditionId: string): Promise<RenditionEntry>;

        getSharedLinkRenditionContent(sharedId: string, renditionId: string, opts?: { attachment?: boolean, ifModifiedSince?: Date }): Promise<any>;
    }

    export interface RatingsApi {
        new(client: ApiClient): RatingsApi;

        rate(nodeId?: string, ratingBody?: RatingBody, opts?: any): Promise<RatingEntry>;

        removeRating(nodeId?: string, ratingId?: string): Promise<any>;

        getRating(nodeId?: string, ratingId?: string, opts?: any): Promise<RatingEntry>;

        getRatings(nodeId?: string, opts?: any): Promise<RatingPaging>;
    }

    export interface SharedlinksApi {
        new(client: ApiClient): SharedlinksApi;

        addSharedLink(sharedLinkBody?: SharedLinkBody, opts?: any): Promise<SharedLinkEntry>;

        deleteSharedLink(sharedId?: string): Promise<any>;

        emailSharedLink(sharedId?: string, emailSharedLinkBody?: EmailSharedLinkBody, opts?: any): Promise<any>;

        findSharedLinks(opts?: any): Promise<SharedLinkPaging>;

        getSharedLink(sharedId?: string, opts?: any): Promise<SharedLinkEntry>;

        getSharedLinkContent(sharedId?: string, opts?: any): Promise<any>;
    }

    export interface DownloadsApi {
        new(client: ApiClient): DownloadsApi;

        createDownload(payload: DownloadBodyCreate, opts?: any): Promise<DownloadEntry>;

        getDownload(downloadId: string, opts?: any): Promise<DownloadEntry>;

        cancelDownload(downloadId: string): Promise<any>;
    }

    export interface DownloadBodyCreate {
        nodeIds?: string[];
    }

    export interface DownloadEntry {
        entry?: Download;
    }

    export interface Download {
        filesAdded?: number;
        bytesAdded?: number;
        id: string;
        totalFiles: number;
        totalBytes: number;
        status: string;
    }

    export interface NodeAssocPaging {
        list?: NodeAssocPagingList;
    }

    export interface NodeAssocPagingList {
        entries?: NodeAssocMinimalEntry;
        pagination?: Pagination;
    }

    export interface NodeAssocMinimalEntry {
        entry?: NodeAssocMinimal;
    }

    export interface NodeAssocMinimal {
        id?: string;
        parentId?: String;
        name?: String;
        nodeType?: String;
        isFolder?: Boolean;
        isFile?: Boolean;
        modifiedAt?: Date;
        modifiedByUser?: UserInfo;
        createdAt?: Date;
        createdByUser?: UserInfo;
        content?: ContentInfo;
        association?: AssocInfo;
    }

    export interface AssocInfo {
        assocType?: String;
    }

    export interface TagsApi {
        new(client: ApiClient): TagsApi;

        addTag(nodeId?: string, tagBody?: TagBody): Promise<TagEntry>;

        removeTag(nodeId?: string, tagId?: string): Promise<any>;

        getTag(tagId?: string, fields?: Array<string>, opts?: any): Promise<TagEntry>;

        getNodeTags(nodeId?: string, opts?: any): Promise<TagPaging>;

        getTags(opts?: any): Promise<TagPaging>;

        updateTag(tagId?: string, tagBody?: TagBody): Promise<TagEntry>;
    }

    export interface WebscriptApi {
        new(client: ApiClient): WebscriptApi;

        executeWebScript(httpMethod?: string, scriptPath?: string, scriptArgs?: any, contextRoot?: string, servicePat?: string, postBody?: string): Promise<{}>;
    }

    // export interface TrashcanApi {
    //     deleteremovedNode(nodeId?: string, opts?: any): Promise<any>;
    //     getremovedNode(nodeId?: string, include?: Array<string>, opts?: any): Promise<removedNodeEntry>;
    //     listremovedNodes(skipCount?: number, maxItems?: number, include?: Array<string>, opts?: any): Promise<removedNodesPaging>;
    //     restoreremovedNode(nodeId?: string, fields?: Array<string>, opts?: any): Promise<NodeEntry>;
    // }

    export interface VersionsApi {
        deleteVersion(nodeId: string, versionId: string): Promise<any>;

        getVersion(nodeId: string, versionId: string): Promise<VersionEntry>;

        getVersionContent(nodeId: string, versionId: string, opts?: { attachment?: boolean, ifModifiedSince?: Date, range?: string }): Promise<any>;

        listVersionHistory(nodeId: string, opts?: { include?: Array<string>, fields?: Array<string>, skipCount?: number, maxItems?: number }): Promise<VersionPaging>;

        revertVersion(nodeId: string, versionId: string, revertBody: RevertBody, opts?: { fields?: Array<string> }): Promise<VersionEntry>;
    }

    export interface ClassesApi {
        getClass(className: string, opts?: {}): Promise<ClassDescription>;
    }

    export class Activity {
        constructor(obj?: any);

        postPersonId?: string;
        id?: number;
        siteId?: string;
        postedAt?: Date;
        feedPersonId?: string;
        activitySummary?: {
            [key: string]: string;
        };
        activityType?: string;
    }

    export class ActivityEntry {
        constructor(obj?: any);

        entry?: Activity;
    }

    export class AssocChildBody {
        constructor(obj?: any);

        childId: string;
        assocType: string;
    }

    export class DeletedNodeEntry {
        constructor(obj?: any);

        entry?: DeletedNode;
    }

    export class DeletedNode {
        constructor(obj?: any);

        archivedByUser?: UserInfo;
        archivedAt?: Date;
    }

    export class ActivityPaging {
        constructor(obj?: any);

        list?: ActivityPagingList;
    }

    export class ActivityPagingList {
        constructor(obj?: any);

        entries?: Array<ActivityEntry>;
        pagination?: Pagination;
    }

    export class Association {
        constructor(obj?: any);

        targetId?: string;
        assocType?: string;
    }

    export class AssociationBody {
        constructor(obj?: any);

        targetId?: string;
        assocType?: string;
    }

    export class AssociationEntry {
        constructor(obj?: any);

        entry?: Association;
    }

    export class AssociationInfo {
        constructor(obj?: any);

        assocType?: string;
    }

    export class ChildAssociation {
        constructor(obj?: any);

        childId?: string;
        assocType?: string;
    }

    export class ChildAssociationBody {
        constructor(obj?: any);

        childId?: string;
        assocType?: string;
    }

    export class ChildAssociationEntry {
        constructor(obj?: any);

        entry?: ChildAssociation;
    }

    export class ChildAssociationInfo {
        constructor(assocType: string, isPrimary: boolean);

        assocType?: string;
        isPrimary?: boolean;
    }

    export class AssocTargetBody {
        constructor(obj?: any);

        targetId?: string;
        assocType?: string;
    }

    export class Comment {
        constructor(obj?: any);

        id?: string;
        content?: string;
        adddBy?: Person;
        adddAt?: Date;
        edited?: boolean;
        modifiedBy?: Person;
        modifiedAt?: Date;
        canEdit?: boolean;
        canremove?: boolean;
    }

    export class CommentBody {
        constructor(obj?: any);

        content?: string;
    }

    export class CommentEntry {
        constructor(obj?: any);

        entry?: Comment;
    }

    export class CommentPaging {
        constructor(obj?: any);

        list?: CommentPagingList;
    }

    export class CommentPagingList {
        constructor(obj?: any);

        entries?: Array<CommentEntry>;
        pagination?: Pagination;
    }

    export class Company {
        constructor(obj?: any);

        organization?: string;
        address1?: string;
        address2?: string;
        address3?: string;
        postcode?: string;
        telephone?: string;
        fax?: string;
        email?: string;
    }

    export class ContentInfo {
        constructor(obj?: any);

        mimeType?: string;
        mimeTypeName?: string;
        sizeInBytes?: number;
        encoding?: string;
    }

    export class RemovedNode extends Node {
        constructor(obj?: any);

        archivedByUser?: UserInfo;
        archivedAt?: Date;
    }

    export class RemovedNodeEntry {
        constructor(obj?: any);

        entry?: RemovedNode;
    }

    export class RemovedNodesPaging {
        constructor(obj?: any);

        list?: RemovedNodesPagingList;
    }

    export class RemovedNodesPagingList {
        constructor(obj?: any);

        entries?: Array<RemovedNodeEntry>;
        pagination?: Pagination;
    }

    export class Error {
        constructor(obj?: any);

        error?: ErrorError;
    }

    export class ErrorError {
        constructor(obj?: any);

        errorKey?: string;
        briefSummary?: string;
        descriptionURL?: string;
        logId?: string;
        stackTrace?: string;
        statusCode?: number;
    }

    export class Favorite {
        constructor(obj?: any);

        targetGuid?: string;
        adddAt?: Date;
        target?: any;
    }

    export class FavoriteBody {
        constructor(obj?: any);

        target?: any;
    }

    export class FavoriteEntry {
        constructor(obj?: any);

        entry?: Favorite;
    }

    export class FavoritePaging {
        constructor(obj?: any);

        list?: FavoritePagingList;
    }

    export class FavoritePagingList {
        constructor(obj?: any);

        entries?: Array<FavoriteEntry>;
        pagination?: Pagination;
    }

    export class FavoriteSite {
        constructor(obj?: any);

        id?: string;
    }

    export class FavoriteSiteBody {
        constructor(obj?: any);

        id?: string;
    }

    export class FavoriteSiteEntry {
        constructor(obj?: any);

        entry?: FavoriteSite;
    }

    export class NetworkQuota {
        constructor(obj?: any);

        id?: string;
        limit?: number;
        usage?: number;
    }


    export class NodeAssociation extends Node {
        constructor(obj?: any);

        association?: AssociationInfo;
    }

    export class NodeAssociationEntry {
        constructor(obj?: any);

        entry?: NodeAssociation;
    }

    export class NodeAssociationPaging {
        constructor(obj?: any);

        list?: NodeAssociationPagingList;
    }

    export class NodeAssociationPagingList {
        constructor(obj?: any);

        entries?: Array<NodeAssociationEntry>;
        pagination?: Pagination;
        source?: Node;
    }

    export class CopyBody {
        constructor(obj?: any);

        targetParentId?: string;
        name?: string;
    }

    export class NodeBody {
        constructor(obj?: any);

        name?: string;
        nodeType?: string;
        aspectNames?: Array<string>;
        properties?: {
            [key: string]: string;
        };
        relativePath?: string;
        association?: NodeBodyAssociation;
        secondaryChildren?: Array<ChildAssociationBody>;
        targets?: Array<AssociationBody>;
        permissions?: PermissionsBodyUpdate;
    }

    export class NodeBodyAssociation {
        constructor(obj?: any);

        assocType?: string;
    }

    export class NodeBodyLock {
        constructor(obj?: any);

        timeToExpire?: number;
        type?: NodeBodyLock.TypeEnum;
        lifetime?: NodeBodyLock.LifetimeEnum;
    }

    namespace NodeBodyLock {
        enum TypeEnum {
            ALLOW_OWNER_CHANGES = 'ALLOW_OWNER_CHANGES',
            FULL = 'FULL'
        }

        enum LifetimeEnum {
            PERSISTENT = 'PERSISTENT',
            EPHEMERAL = 'EPHEMERAL'
        }
    }

    export class MoveBody {
        constructor(obj?: any);

        targetParentId?: string;
        name?: string;
    }

    export class NodeChildAssociation extends Node {
        constructor(obj?: any);

        association?: ChildAssociationInfo;
    }

    export class NodeChildAssociationEntry {
        constructor(obj?: any);

        entry?: NodeChildAssociation;
    }

    export class NodeChildAssociationPaging {
        constructor(obj?: any);

        list?: NodeChildAssociationPagingList;
    }

    export class NodeChildAssociationPagingList {
        constructor(obj?: any);

        entries?: Array<NodeChildAssociationEntry>;
        pagination?: Pagination;
        source?: Node;
    }

    export class NodeEntry {
        constructor(obj?: any);

        entry?: Node;
    }

    export class NodePaging {
        constructor(obj?: any);

        list?: NodePagingList;
    }

    export class NodePagingList {
        constructor(obj?: any);

        entries?: Array<NodeEntry>;
        pagination?: Pagination;
        source?: Node;
    }

    export class Pagination {
        constructor(obj?: any);

        count?: number;
        hasMoreItems?: boolean;
        totalItems?: number;
        skipCount?: number;
        maxItems?: number;
    }

    export class PathElement {
        constructor(obj?: any);

        id?: string;
        name?: string;
    }

    export class PathInfo {
        constructor(obj?: any);

        elements?: Array<PathElement>;
        name?: string;
        isComplete?: boolean;
    }

    export class PermissionElement {
        constructor(obj?: any);

        authorityId?: string;
        name?: string;
        accessStatus?: PermissionElement.AccessStatusEnum;
    }

    namespace PermissionElement {
        enum AccessStatusEnum {
            ALLOWED = 'ALLOWED',
            DENIED = 'DENIED'
        }
    }

    export class PermissionsBodyUpdate {
        constructor(obj?: any);

        isInheritanceEnabled?: boolean;
        locallySet?: Array<PermissionElement>;
    }

    export class PermissionsInfo {
        constructor(obj?: any);

        isInheritanceEnabled?: boolean;
        inherited?: Array<PermissionElement>;
        locallySet?: Array<PermissionElement>;
        settable?: Array<string>;
    }

    export class Person {
        constructor(obj?: any);

        id?: string;
        firstName?: string;
        lastName?: string;
        description?: string;
        avatarId?: string;
        email?: string;
        skypeId?: string;
        googleId?: string;
        instantMessageId?: string;
        jobTitle?: string;
        location?: string;
        company?: Company;
        mobile?: string;
        telephone?: string;
        statusUpdatedAt?: Date;
        userStatus?: string;
        enabled?: boolean;
        emailNotificationsEnabled?: boolean;
        aspectNames?: Array<string>;
        properties?: {
            [key: string]: string;
        };
    }

    export class PersonBodyadd {
        constructor(obj?: any);

        id?: string;
        firstName?: string;
        lastName?: string;
        description?: string;
        email?: string;
        skypeId?: string;
        googleId?: string;
        instantMessageId?: string;
        jobTitle?: string;
        location?: string;
        company?: Company;
        mobile?: string;
        telephone?: string;
        userStatus?: string;
        enabled?: boolean;
        emailNotificationsEnabled?: boolean;
        password?: string;
        aspectNames?: Array<string>;
        properties?: {
            [key: string]: string;
        };
    }

    export class PersonBodyUpdate {
        constructor(obj?: any);

        firstName?: string;
        lastName?: string;
        description?: string;
        email?: string;
        skypeId?: string;
        googleId?: string;
        instantMessageId?: string;
        jobTitle?: string;
        location?: string;
        company?: Company;
        mobile?: string;
        telephone?: string;
        userStatus?: string;
        enabled?: boolean;
        emailNotificationsEnabled?: boolean;
        password?: string;
        oldPassword?: string;
        aspectNames?: Array<string>;
        properties?: {
            [key: string]: string;
        };
    }

    export class PersonEntry {
        constructor(obj?: any);

        entry?: Person;
    }

    export class PersonNetwork {
        constructor(obj?: any);

        id?: string;
        homeNetwork?: boolean;
        isEnabled?: boolean;
        adddAt?: Date;
        paidNetwork?: boolean;
        subscriptionLevel?: PersonNetwork.SubscriptionLevelEnum;
        quotas?: Array<NetworkQuota>;
    }

    namespace PersonNetwork {
        enum SubscriptionLevelEnum {
            Free = 'Free',
            Standard = 'Standard',
            Enterprise = 'Enterprise'
        }
    }

    export class PersonNetworkEntry {
        constructor(obj?: any);

        entry?: PersonNetwork;
    }

    export class PersonNetworkPaging {
        constructor(obj?: any);

        list?: PersonNetworkPagingList;
    }

    export class PersonNetworkPagingList {
        constructor(obj?: any);

        entries?: Array<PersonNetworkEntry>;
        pagination?: Pagination;
    }

    export class PersonPaging {
        constructor(obj?: any);

        list?: PersonPagingList;
    }

    export class PersonPagingList {
        constructor(obj?: any);

        entries?: Array<PersonEntry>;
        pagination?: Pagination;
    }

    export class Preference {
        constructor(obj?: any);

        id?: string;
        value?: string;
    }

    export class PreferenceEntry {
        constructor(obj?: any);

        entry?: Preference;
    }

    export class PreferencePaging {
        constructor(obj?: any);

        list?: PreferencePagingList;
    }

    export class PreferencePagingList {
        constructor(obj?: any);

        entries?: Array<PreferenceEntry>;
        pagination?: Pagination;
    }

    export class SearchRequest {
        constructor(obj ?: any);

        query ?: RequestQuery;
        paging ?: RequestPagination;
        include ?: Array<string>;
        includeRequest?: boolean;
        fields ?: Array<string>;
        sort ?: Array<RequestSortDefinitionInner>;
        templates ?: Array<RequestTemplate>;
        defaults ?: RequestDefaults;
        localization?: RequestLocalization;
        filterQueries ?: Array<RequestFilterQuery>;
        facetQueries ?: Array<RequestFacetQuery>;
        facetFields ?: RequestFacetFields;
        facetIntervals?: RequestFacetIntervals;
        pivots?: Array<RequestPivot>;
        stats?: Array<RequestStats>;
        spellcheck ?: RequestSpellcheck;
        scope ?: RequestScope;
        limits ?: RequestLimits;
        highlight ?: RequestHighlight;
        ranges?: Array<RequestRange>;
    }

    export class QueryBody extends SearchRequest {
        constructor(obj ?: any);
    }

    export class RequestPivot {
        key?: string;
        pivots?: Array<RequestPivot>;
    }

    export class RequestStats {
        field?: string;
        label?: string;
        min?: boolean;
        max?: boolean;
        sum?: boolean;
        countValues?: boolean;
        missing?: boolean;
        mean?: boolean;
        stddev?: boolean;
        sumOfSquares?: boolean;
        distinctValues?: boolean;
        countDistinct?: boolean;
        cardinality?: boolean;
        cardinalityAccuracy?: number;
        excludeFilters?: Array<string>;
        percentiles?: Array<number>;
    }

    export class RequestFacetIntervals {
        sets?: Array<RequestFacetSet>;
        intervals?: Array<RequestFacetInterval>;
    }

    export class RequestFacetSet {
        label?: string;
        start?: string;
        end?: string;
        startInclusive?: boolean;
        endInclusive?: boolean;
    }

    export class RequestFacetInterval {
        field?: string;
        label?: string;
        sets?: Array<RequestFacetSet>;
    }

    export class RequestFilterQuery {
        query?: string;
        tags?: Array<string>;
    }

    export class RequestFacetQuery {
        query?: string;
        label?: string;
    }

    export class RequestLocalization {
        timezone?: string;
        locales?: Array<string>;
    }

    export class RequestSortDefinitionInner {
        // type?: RequestSortDefinitionInner.TypeEnum;
        type?: string;
        field?: string;
        ascending?: boolean;
    }

    namespace RequestSortDefinitionInner {
        enum TypeEnum {
            FIELD = 'FIELD',
            DOCUMENT = 'DOCUMENT',
            SCORE = 'SCORE'
        }
    }

    export class RequestTemplate {
        name?: string;
        template?: string;
    }

    export class RequestRange {
        field?: string;
        start?: string;
        end?: string;
        gap?: string;
        hardend?: boolean;
        other?: Array<string>;
        include?: Array<string>;
        label?: string;
        excludeFilters?: Array<string>;
    }

    export class RequestHighlightFields {
        constructor(obj?: any);

        field?: string;
        snippetCount?: number;
        fragmentSize?: number;
        mergeContiguous?: boolean;
        prefix?: string;
        postfix?: string;
    }

    export class RequestHighlight {
        constructor(obj?: any);

        prefix?: string;
        postfix?: string;
        snippetCount?: number;
        fragmentSize?: number;
        maxAnalyzedChars?: number;
        mergeContiguous?: boolean;
        usePhraseHighlighter?: boolean;
        fields: Array<RequestHighlightFields>;
    }

    export class RequestLimits {
        constructor(obj?: any);

        permissionEvaluationTime?: number;
        permissionEvaluationCount?: number;
    }

    export class RequestScope {
        constructor(obj?: any);

        locations?: string;
    }

    export class RequestSpellcheck {
        constructor(obj?: any);

        query?: string;
    }

    export class RequestFacetFields {
        constructor(obj?: any);

        facets?: RequestFacetField[];
    }

    export class RequestFacetField {
        constructor(obj?: any);

        field?: string;
        label?: string;
        prefix?: string;
        sort?: RequestFacetField.SortEnum;
        method?: RequestFacetField.MethodEnum;
        missing?: boolean;
        limit?: number;
        offset?: number;
        mincount?: number;
        facetEnumCacheMinDf?: number;
        excludeFilters?: string[];
    }

    namespace RequestFacetField {
        enum SortEnum {
            COUNT = 'COUNT',
            INDEX = 'INDEX'
        }

        enum MethodEnum {
            ENUM = 'ENUM',
            FC = 'FC'
        }
    }

    export class RequestQuery {
        constructor(obj?: any);

        language?: string;
        userQuery?: string;
        query?: string;
    }

    export class RequestPagination {
        constructor(obj?: any);

        maxItems?: number;
        skipCount?: number;
    }

    export class RequestDefaults {
        constructor(obj?: any);

        textAttributes?: Array<string>;
        defaultFTSOperator?: RequestDefaults.DefaultFTSOperatorEnum;
        defaultFTSFieldOperator?: RequestDefaults.DefaultFTSFieldOperatorEnum;
        namespace?: string;
        defaultFieldName?: string;
    }

    namespace RequestDefaults {
        enum DefaultFTSOperatorEnum {
            AND = 'AND',
            OR = 'OR'
        }

        enum DefaultFTSFieldOperatorEnum {
            AND = 'AND',
            OR = 'OR'
        }
    }

    export class Rating {
        constructor(obj?: any);

        id?: string;
        aggregate?: RatingAggregate;
        ratedAt?: Date;
        myRating?: string;
    }

    export class RatingAggregate {
        constructor(obj?: any);

        average?: number;
        numberOfRatings?: number;
    }

    export class RatingBody {
        constructor(obj?: any);

        id?: RatingBody.IdEnum;
        myRating?: string;
    }

    namespace RatingBody {

        enum IdEnum {
            likes = 'likes',
            fiveStar = 'fiveStar'
        }
    }

    export class RatingEntry {
        constructor(obj?: any);

        entry?: Rating;
    }

    export class RatingPaging {
        constructor(obj?: any);

        list?: RatingPagingList;
    }

    export class RatingPagingList {
        constructor(obj?: any);

        entries?: Array<RatingEntry>;
        pagination?: Pagination;
    }

    export class Rendition {
        constructor(obj?: any);

        id?: string;
        content?: ContentInfo;
        status?: Rendition.StatusEnum;
    }

    namespace Rendition {

        enum StatusEnum {
            CREATED = 'CREATED',
            NOT_CREATED = 'NOT_CREATED'
        }
    }

    export class RenditionBody {
        constructor(obj?: any);

        id?: string;
    }

    export class RenditionEntry {
        constructor(obj?: any);

        entry?: Rendition;
    }

    export class RenditionPaging {
        constructor(obj?: any);

        list?: RenditionPagingList;
    }

    export class RenditionPagingList {
        constructor(obj?: any);

        entries?: Array<RenditionEntry>;
        pagination?: Pagination;
    }

    export class RevertBody {
        constructor(obj?: any);

        majorVersion?: boolean;
        comment?: string;
    }

    export class SharedLink {
        constructor(obj?: any);

        id?: string;
        expiresAt?: Date;
        nodeId?: string;