I added more type definitions. All the events and their callbacks

[RobinRadic]

All the events.

Placed it into a .ts in my project and it works perfectly. Could you add this to the inspire-tree.d.ts? I could do a pull request if you want. Otherwise, some people might have use of this just by copy/pasting it into their project.

export interface TreeEvents<TREE extends InspireTree= InspireTree, TREE_NODE extends TreeNode = TreeNode> {

    /** @event changes.applied (InspireTree | TreeNode context) - Indicates batched changes are complete for the context. */
    'changes.applied'?: (context: TREE | TREE_NODE) => void;

    /** @event children.loaded (TreeNode node) - Children were dynamically loaded for a node. */
    'children.loaded'?: (node: TREE_NODE) => void;

    /** @event data.loaded (Array nodes) - Data has been loaded successfully (only for data loaded via xhr/callbacks). */
    'data.loaded'?: (nodes: any[]) => void;

    /** @event data.loaderror (Error err) - Loading failed. */
    'data.loaderror'?: (err: Error) => void;

    /** @event model.loaded (Array nodes) - Data has been parsed into an internal model. */
    'model.loaded'?: (node: TREE_NODE) => void;

    /** @event node.added (TreeNode node) - Node added. */
    'node.added'?: (node: TREE_NODE) => void;

    /** @event node.click (TreeNode node) - Node os clicked. */
    'node.click'?: (node: TREE_NODE) => void;

    /** @event node.blurred (TreeNode node, bool isLoadEvent) - Node lost focus. */
    'node.blurred'?: (node: TREE_NODE, isLoadEvent: boolean) => void;

    /** @event node.checked (TreeNode node, bool isLoadEvent) - Node checked. */
    'node.checked'?: (node: TREE_NODE, isLoadEvent: boolean) => void;

    /** @event node.collapsed (TreeNode node) - Node collapsed. */
    'node.collapsed'?: (node: TREE_NODE) => void;

    /** @event node.deselected (TreeNode node) - Node deselected. */
    'node.deselected'?: (node: TREE_NODE) => void;

    /** @event node.edited (TreeNode node), (string oldValue), (string newValue) - Node text was altered via inline editing. */
    'node.edited'?: (node: TREE_NODE) => void;

    /** @event node.expanded (TreeNode node, bool isLoadEvent) - Node expanded. */
    'node.expanded'?: (node: TREE_NODE, isLoadEvent: boolean) => void;

    /** @event node.focused (TreeNode node, bool isLoadEvent) - Node focused. */
    'node.focused'?: (node: TREE_NODE, isLoadEvent: boolean) => void;

    /** @event node.hidden (TreeNode node, bool isLoadEvent) - Node hidden. */
    'node.hidden'?: (node: TREE_NODE, isLoadEvent: boolean) => void;

    /** @event node.moved (TreeNode node, TreeNodes source, int oldIndex, TreeNodes target, int newIndex) - Node moved. */
    'node.moved'?: (node: TREE_NODE) => void;

    /** @event node.paginated (TreeNode context), (Object pagination) (Event event) - Nodes were paginated. Context is undefined when for the root level. */
    'node.paginated'?: (node: TREE_NODE) => void;

    /** @event node.propertchanged - (TreeNode node), (String property), (Mixed oldValue), (Mixed) newValue) - A node's root property has changed. */
    'node.property.changed'?: (node: TREE_NODE) => void;

    /** @event node.removed (object node) - Node removed. */
    'node.removed'?: (node: TREE_NODE) => void;

    /** @event node.restored (TreeNode node) - Node restored. */
    'node.restored'?: (node: TREE_NODE) => void;

    /** @event node.selected (TreeNode node, bool isLoadEvent) - Node selected. */
    'node.selected'?: (node: TREE_NODE, isLoadEvent: boolean) => void;

    /** @event node.statchanged - (TreeNode node), (String property), (Mixed oldValue), (Mixed) newValue) - A node state boolean has changed. */
    'node.state.changed'?: (node: TREE_NODE) => void;

    /** @event node.shown (TreeNode node) - Node shown. */
    'node.shown'?: (node: TREE_NODE) => void;

    /** @event node.softremoved (TreeNode node, bool isLoadEvent) - Node soft removed. */
    'node.softremoved'?: (node: TREE_NODE, isLoadEvent: boolean) => void;

    /** @event node.unchecked (TreeNode node) - Node unchecked. */
    'node.unchecked'?: (node: TREE_NODE) => void;
}

export type TreeEvent = keyof TreeEvents


declare module 'inspire-tree' {
    export interface InspireTree {
        emit<E extends keyof TreeEvents>(event: E | E[], ...values: any[]): boolean;

        emitAsync<E extends keyof TreeEvents>(event: E | E[], ...values: any[]): Promise<any[]>;

        addListener<E extends keyof TreeEvents>(event: E, listener: TreeEvents[E]): this;

        on<E extends keyof TreeEvents>(event: E, listener: TreeEvents[E]): this;

        prependListener<E extends keyof TreeEvents>(event: E | E[], listener: TreeEvents[E]): this;

        once<E extends keyof TreeEvents>(event: E, listener: TreeEvents[E]): this;

        prependOnceListener<E extends keyof TreeEvents>(event: E | E[], listener: TreeEvents[E]): this;

        many<E extends keyof TreeEvents>(event: E | E[], timesToListen: number, listener: TreeEvents[E]): this;

        prependMany<E extends keyof TreeEvents>(event: E | E[], timesToListen: number, listener: TreeEvents[E]): this;

        onAny(listener: EventAndListener): this;

        prependAny(listener: EventAndListener): this;

        offAny(listener: Listener): this;

        removeListener<E extends keyof TreeEvents>(event: E | E[], listener: TreeEvents[E]): this;

        off<E extends keyof TreeEvents>(event: E, listener: TreeEvents[E]): this;
    }
}

[viveleroi]

Looks okay enough for a PR, go ahead and open one. Thanks!