@types/knockout/ts3.9/index.d.ts

interface KnockoutSubscribableFunctions<T> {
    /**
     * Notify subscribers of knockout "change" event. This doesn't actually change the observable value.
     * @param eventValue A value to be sent with the event.
     * @param event The knockout event.
     */
    notifySubscribers(eventValue?: T, event?: "change"): void;
    /**
     * Notify subscribers of a knockout or user defined event.
     * @param eventValue A value to be sent with the event.
     * @param event The knockout or user defined event name.
     */
    notifySubscribers<U>(eventValue: U, event: string): void;
}

interface KnockoutComputedFunctions<T> {
}

interface KnockoutObservableFunctions<T> {
    /**
     * Used by knockout to decide if value of observable has changed and should notify subscribers. Returns true if instances are primitives, and false if are objects.
     * If your observable holds an object, this can be overwritten to return equality based on your needs.
     * @param a previous value.
     * @param b next value.
     */
    equalityComparer(a: T, b: T): boolean;
}

// The functions of observable arrays that don't mutate the array
interface KnockoutReadonlyObservableArrayFunctions<T> {
    /**
      * Returns the index of the first occurrence of a value in an array.
      * @param searchElement The value to locate in the array.
      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
      */
    indexOf(searchElement: T, fromIndex?: number): number;
    /**
      * Returns a section of an array.
      * @param start The beginning of the specified portion of the array.
      * @param end The end of the specified portion of the array.
      */
    slice(start: number, end?: number): T[];
}
// The functions of observable arrays that mutate the array
interface KnockoutObservableArrayFunctions<T> extends KnockoutReadonlyObservableArrayFunctions<T> {
    /**
     * Removes and returns all the remaining elements starting from a given index.
     * @param start The zero-based location in the array from which to start removing elements.
     */
    splice(start: number): T[];
    /**
     * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
     * @param start The zero-based location in the array from which to start removing elements.
     * @param deleteCount The number of elements to remove.
     * @param items Elements to insert into the array in place of the deleted elements.
     */
    splice(start: number, deleteCount: number, ...items: T[]): T[];
    /**
     * Removes the last value from the array and returns it.
     */
    pop(): T;
    /**
     * Adds new item or items to the end of array.
     * @param items Items  to be added.
     */
    push(...items: T[]): void;
    /**
     * Removes the first value from the array and returns it.
     */
    shift(): T;
    /**
     * Inserts new item or items at the beginning of the array.
     * @param items Items to be added.
     */
    unshift(...items: T[]): number;
    /**
     * Reverses the order of the array and returns the observableArray (not the underlying array).
     */
    reverse(): KnockoutObservableArray<T>;
    /**
     * Sorts the array contents and returns the observableArray.
     */
    sort(): KnockoutObservableArray<T>;
    /**
     * Sorts the array contents and returns the observableArray.
     * @param compareFunction A function that returns negative value if first argument is smaller, positive value if second is smaller, or zero to treat them as equal.
     */
    sort(compareFunction: (left: T, right: T) => number): KnockoutObservableArray<T>;

    // Ko specific
    /**
     * Replaces the first value that equals oldItem with newItem.
     * @param oldItem Item to be replaced.
     * @param newItem Replacing item.
     */
    replace(oldItem: T, newItem: T): void;
    /**
     * Removes all values that equal item and returns them as an array.
     * @param item The item to be removed.
     */
    remove(item: T): T[];
    /**
     * Removes all values and returns them as an array.
     * @param removeFunction A function used to determine true if item should be removed and fasle otherwise.
     */
    remove(removeFunction: (item: T) => boolean): T[];
    /**
     * Removes all values that equal any of the supplied items.
     * @param items Items to be removed.
     */
    removeAll(items: T[]): T[];
    /**
     * Removes all values and returns them as an array.
     */
    removeAll(): T[];

    // Ko specific Usually relevant to Ruby on Rails developers only
    /**
     * Finds any objects in the array that equal someItem and gives them a special property called _destroy with value true.
     * @param item Items to be marked with the property.
     */
    destroy(item: T): void;
    /**
     * Finds any objects in the array filtered by a function and gives them a special property called _destroy with value true.
     * @param destroyFunction A function used to determine which items should be marked with the property.
     */
    destroy(destroyFunction: (item: T) => boolean): void;
    /**
     * Finds any objects in the array that equal suplied items and gives them a special property called _destroy with value true.
     * @param items
     */
    destroyAll(items: T[]): void;
    /**
     * Gives a special property called _destroy with value true to all objects in the array.
     */
    destroyAll(): void;
}

interface KnockoutSubscribableStatic {
    fn: KnockoutSubscribableFunctions<any>;

    new <T>(): KnockoutSubscribable<T>;
}

interface KnockoutSubscription {
    /**
     * Terminates a subscription.
     */
    dispose(): void;
}

interface KnockoutSubscribable<T> extends KnockoutSubscribableFunctions<T> {
    /**
     * Registers to be notified after the observable's value changes.
     * @param callback Function that is called whenever the notification happens.
     * @param target Defines the value of 'this' in the callback function.
     * @param event The knockout event name.
     */
    subscribe(callback: (newValue: T) => void, target?: any, event?: "change"): KnockoutSubscription;
    /**
     * Registers to be notified before the observable's value changes.
     * @param callback Function that is called whenever the notification happens.
     * @param target Defines the value of 'this' in the callback function.
     * @param event The knockout event name.
     */
    subscribe(callback: (newValue: T) => void, target: any, event: "beforeChange"): KnockoutSubscription;
    /**
     * Registers to be notified when a knockout or user defined event happens.
     * @param callback Function that is called whenever the notification happens. eventValue can be anything. No relation to underlying observable.
     * @param target Defines the value of 'this' in the callback function.
     * @param event The knockout or user defined event name.
     */
    subscribe<U>(callback: (eventValue: U) => void, target: any, event: string): KnockoutSubscription;
    /**
     * Customizes observables basic functionality.
     * @param requestedExtenders Name of the extender feature and its value, e.g. { notify: 'always' }, { rateLimit: 50 }
     */
    extend(requestedExtenders: { [key: string]: any; }): KnockoutSubscribable<T>;
    /**
    * Gets total number of subscribers.
    */
    getSubscriptionsCount(): number;
    /**
     * Gets number of subscribers of a particular event.
     * @param event Event name.
     */
    getSubscriptionsCount(event: string): number;
}

interface KnockoutComputedStatic {
    fn: KnockoutComputedFunctions<any>;

    /**
     * Creates computed observable.
     */
    <T>(): KnockoutComputed<T>;
    /**
     * Creates computed observable.
     * @param evaluatorFunction Function that computes the observable value.
     * @param context Defines the value of 'this' when evaluating the computed observable.
     * @param options An object with further properties for the computed observable.
     */
    <T>(evaluatorFunction: () => T, context?: any, options?: KnockoutComputedOptions<T>): KnockoutComputed<T>;
    /**
     * Creates computed observable.
     * @param options An object that defines the computed observable options and behavior.
     * @param context Defines the value of 'this' when evaluating the computed observable.
     */
    <T>(options: KnockoutComputedDefine<T>, context?: any): KnockoutComputed<T>;
}

interface KnockoutReadonlyComputed<T> extends KnockoutReadonlyObservable<T> {
    /**
     * Returns whether the computed observable may be updated in the future. A computed observable is inactive if it has no dependencies.
     */
    isActive(): boolean;
    /**
     * Returns the current number of dependencies of the computed observable.
     */
    getDependenciesCount(): number;
}

interface KnockoutComputed<T> extends KnockoutReadonlyComputed<T>, KnockoutObservable<T>, KnockoutComputedFunctions<T> {
    fn: KnockoutComputedFunctions<any>;

    /**
     * Manually disposes the computed observable, clearing all subscriptions to dependencies.
     * This function is useful if you want to stop a computed observable from being updated or want to clean up memory for a
     * computed observable that has dependencies on observables that won’t be cleaned.
     */
    dispose(): void;
    /**
     * Customizes observables basic functionality.
     * @param requestedExtenders Name of the extender feature and it's value, e.g. { notify: 'always' }, { rateLimit: 50 }
     */
    extend(requestedExtenders: { [key: string]: any; }): KnockoutComputed<T>;
}

interface KnockoutObservableArrayStatic {
    fn: KnockoutObservableArrayFunctions<any>;

    <T>(value?: T[] | null): KnockoutObservableArray<T>;
}

/**
 * While all observable arrays are writable at runtime, this type is analogous to the native ReadonlyArray type:
 * casting an observable array to this type expresses the intention that it shouldn't be mutated.
 */
interface KnockoutReadonlyObservableArray<T> extends KnockoutReadonlyObservable<ReadonlyArray<T>>, KnockoutReadonlyObservableArrayFunctions<T> {
    // NOTE: Keep in sync with KnockoutObservableArray<T>, see note on KnockoutObservableArray<T>
    subscribe(callback: (newValue: KnockoutArrayChange<T>[]) => void, target: any, event: "arrayChange"): KnockoutSubscription;
    subscribe(callback: (newValue: T[]) => void, target: any, event: "beforeChange"): KnockoutSubscription;
    subscribe(callback: (newValue: T[]) => void, target?: any, event?: "change"): KnockoutSubscription;
    subscribe<U>(callback: (newValue: U) => void, target: any, event: string): KnockoutSubscription;
}

/*
    NOTE: In theory this should extend both KnockoutObservable<T[]> and KnockoutReadonlyObservableArray<T>,
        but can't since they both provide conflicting typings of .subscribe.
    So it extends KnockoutObservable<T[]> and duplicates the subscribe definitions, which should be kept in sync
*/
interface KnockoutObservableArray<T> extends KnockoutObservable<T[]>, KnockoutObservableArrayFunctions<T> {
    subscribe(callback: (newValue: KnockoutArrayChange<T>[]) => void, target: any, event: "arrayChange"): KnockoutSubscription;
    subscribe(callback: (newValue: T[]) => void, target: any, event: "beforeChange"): KnockoutSubscription;
    subscribe(callback: (newValue: T[]) => void, target?: any, event?: "change"): KnockoutSubscription;
    subscribe<U>(callback: (newValue: U) => void, target: any, event: string): KnockoutSubscription;

    extend(requestedExtenders: { [key: string]: any; }): KnockoutObservableArray<T>;
}

interface KnockoutObservableStatic {
    fn: KnockoutObservableFunctions<any>;

    <T>(value: T): KnockoutObservable<T>;
    <T = any>(value: null): KnockoutObservable<T | null>
    <T = any>(): KnockoutObservable<T | undefined>
}

/**
 * While all observable are writable at runtime, this type is analogous to the native ReadonlyArray type:
 * casting an observable to this type expresses the intention that this observable shouldn't be mutated.
 */
interface KnockoutReadonlyObservable<T> extends KnockoutSubscribable<T>, KnockoutObservableFunctions<T> {
    (): T;

    /**
     * Returns the current value of the computed observable without creating a dependency.
     */
    peek(): T;
    valueHasMutated?: { (): void; };
    valueWillMutate?: { (): void; };
}

interface KnockoutObservable<T> extends KnockoutReadonlyObservable<T> {
    (value: T): void;

    // Since .extend does arbitrary thing to an observable, it's not safe to do on a readonly observable
    /**
     * Customizes observables basic functionality.
     * @param requestedExtenders Name of the extender feature and it's value, e.g. { notify: 'always' }, { rateLimit: 50 }
     */
    extend(requestedExtenders: { [key: string]: any; }): KnockoutObservable<T>;
}

interface KnockoutComputedOptions<T> {
    /**
     * Makes the computed observable writable. This is a function that receives values that other code is trying to write to your computed observable.
     * It’s up to you to supply custom logic to handle the incoming values, typically by writing the values to some underlying observable(s).
     * @param value Value being written to the computer observable.
     */
    write?(value: T): void;
    /**
     * Disposal of the computed observable will be triggered when the specified DOM node is removed by KO.
     * This feature is used to dispose computed observables used in bindings when nodes are removed by the template and control-flow bindings.
     */
    disposeWhenNodeIsRemoved?: Node;
    /**
     * This function is executed before each re-evaluation to determine if the computed observable should be disposed.
     * A true-ish result will trigger disposal of the computed observable.
     */
    disposeWhen?(): boolean;
    /**
     * Defines the value of 'this' whenever KO invokes your 'read' or 'write' callbacks.
     */
    owner?: any;
    /**
     * If true, then the value of the computed observable will not be evaluated until something actually attempts to access its value or manually subscribes to it.
     * By default, a computed observable has its value determined immediately during creation.
     */
    deferEvaluation?: boolean;
    /**
     * If true, the computed observable will be set up as a purecomputed observable. This option is an alternative to the ko.pureComputed constructor.
     */
    pure?: boolean;
}

interface KnockoutComputedDefine<T> extends KnockoutComputedOptions<T> {
    /**
     * A function that is used to evaluate the computed observable’s current value.
     */
    read(): T;
}

interface KnockoutBindingContext {
    $parent: any;
    $parents: any[];
    $root: any;
    $data: any;
    $rawData: any | KnockoutObservable<any>;
    $index?: KnockoutObservable<number>;
    $parentContext?: KnockoutBindingContext;
    $component: any;
    $componentTemplateNodes: Node[];

    /**
     * Clones the current Binding Context, adding extra properties to it.
     * @param properties object with properties to be added in the binding context.
     */
    extend(properties: { [key: string]: any; } | (() => { [key: string]: any; })): KnockoutBindingContext;
    /**
     * This returns a new binding context whose viewmodel is the first parameter and whose $parentContext is the current bindingContext. 
     * @param dataItemOrAccessor The binding context of the children.
     * @param dataItemAlias An alias for the data item in descendant contexts.
     * @param extendCallback Function to be called.
     * @param options Further options.
     */
    createChildContext(dataItemOrAccessor: any, dataItemAlias?: string, extendCallback?: Function, options?: { "exportDependencies": boolean }): any;
}

interface KnockoutAllBindingsAccessor {
    (): any;
    get(name: string): any;
    has(name: string): boolean;
}

interface KnockoutBindingHandler<E extends Node = any, V = any, VM = any> {
    after?: Array<string>;
    init?: (element: E, valueAccessor: () => V, allBindingsAccessor: KnockoutAllBindingsAccessor, viewModel: VM, bindingContext: KnockoutBindingContext) => void | { controlsDescendantBindings: boolean; };
    update?: (element: E, valueAccessor: () => V, allBindingsAccessor: KnockoutAllBindingsAccessor, viewModel: VM, bindingContext: KnockoutBindingContext) => void;
    options?: any;
    preprocess?: (value: string, name: string, addBindingCallback?: (name: string, value: string) => void) => string;
    [s: string]: any;
}

interface KnockoutBindingHandlers {
    [bindingHandler: string]: KnockoutBindingHandler;

    // Controlling text and appearance
    visible: KnockoutBindingHandler;
    text: KnockoutBindingHandler;
    html: KnockoutBindingHandler;
    css: KnockoutBindingHandler;
    style: KnockoutBindingHandler;
    attr: KnockoutBindingHandler;

    // Control Flow
    foreach: KnockoutBindingHandler;
    if: KnockoutBindingHandler;
    ifnot: KnockoutBindingHandler;
    with: KnockoutBindingHandler;

    // Working with form fields
    click: KnockoutBindingHandler;
    event: KnockoutBindingHandler;
    submit: KnockoutBindingHandler;
    enable: KnockoutBindingHandler;
    disable: KnockoutBindingHandler;
    value: KnockoutBindingHandler;
    textInput: KnockoutBindingHandler;
    hasfocus: KnockoutBindingHandler;
    checked: KnockoutBindingHandler;
    options: KnockoutBindingHandler;
    selectedOptions: KnockoutBindingHandler;
    uniqueName: KnockoutBindingHandler;

    // Rendering templates
    template: KnockoutBindingHandler;

    // Components (new for v3.2)
    component: KnockoutBindingHandler;
}

interface KnockoutMemoization {
    memoize(callback: Function): string;
    unmemoize(memoId: string, callbackParams: any[]): boolean;
    unmemoizeDomNodeAndDescendants(domNode: any, extraCallbackParamsArray: any[]): boolean;
    parseMemoText(memoText: string): string;
}

interface KnockoutVirtualElement { }

interface KnockoutVirtualElements {
    allowedBindings: { [bindingName: string]: boolean; };
    emptyNode(node: KnockoutVirtualElement): void;
    firstChild(node: KnockoutVirtualElement): KnockoutVirtualElement;
    insertAfter(container: KnockoutVirtualElement, nodeToInsert: Node, insertAfter: Node): void;
    nextSibling(node: KnockoutVirtualElement): Node;
    prepend(node: KnockoutVirtualElement, toInsert: Node): void;
    setDomNodeChildren(node: KnockoutVirtualElement, newChildren: { length: number;[index: number]: Node; }): void;
    childNodes(node: KnockoutVirtualElement): Node[];
}

interface KnockoutExtenders {
    throttle(target: any, timeout: number): KnockoutComputed<any>;
    notify(target: any, notifyWhen: string): any;

    rateLimit(target: any, timeout: number): any;
    rateLimit(target: any, options: { timeout: number; method?: string; }): any;

    trackArrayChanges(target: any): any;
}

//
// NOTE TO MAINTAINERS AND CONTRIBUTORS : pay attention to only include symbols that are
// publicly exported in the minified version of ko, without that you can give the false
// impression that some functions will be available in production builds.
//
interface KnockoutUtils {
    //////////////////////////////////
    // utils.domData.js
    //////////////////////////////////

    domData: {
        get(node: Node, key: string): any;

        set(node: Node, key: string, value: any): void;

        getAll(node: Node, createIfNotFound: boolean): any;

        clear(node: Node): boolean;
    };

    //////////////////////////////////
    // utils.domNodeDisposal.js
    //////////////////////////////////

    domNodeDisposal: {
        addDisposeCallback(node: Node, callback: Function): void;

        removeDisposeCallback(node: Node, callback: Function): void;

        cleanNode(node: Node): Node;

        removeNode(node: Node): void;
    };

    addOrRemoveItem<T>(array: T[] | KnockoutObservable<T>, value: T, included: T): void;

    arrayFilter<T>(array: T[], predicate: (item: T) => boolean): T[];

    arrayFirst<T>(array: T[], predicate: (item: T) => boolean, predicateOwner?: any): T;

    arrayForEach<T>(array: T[], action: (item: T, index: number) => void): void;

    arrayGetDistinctValues<T>(array: T[]): T[];

    arrayIndexOf<T>(array: T[], item: T): number;

    arrayMap<T, U>(array: T[], mapping: (item: T) => U): U[];

    arrayPushAll<T>(array: T[] | KnockoutObservableArray<T>, valuesToPush: T[]): T[];

    arrayRemoveItem(array: any[], itemToRemove: any): void;

    compareArrays<T>(a: T[], b: T[]): Array<KnockoutArrayChange<T>>;

    extend(target: Object, source: Object): Object;

    fieldsIncludedWithJsonPost: any[];

    getFormFields(form: any, fieldName: string): any[];

    objectForEach(obj: any, action: (key: any, value: any) => void): void;

    parseHtmlFragment(html: string): any[];

    parseJson(jsonString: string): any;

    postJson(urlOrForm: any, data: any, options: any): void;

    peekObservable<T>(value: KnockoutObservable<T> | T): T;

    range(min: any, max: any): any;

    registerEventHandler(element: any, eventType: any, handler: Function): void;

    setHtml(node: Element, html: () => string): void;

    setHtml(node: Element, html: string): void;

    setTextContent(element: any, textContent: string | KnockoutObservable<string>): void;

    stringifyJson(data: any, replacer?: Function, space?: string): string;

    toggleDomNodeCssClass(node: any, className: string, shouldHaveClass: boolean): void;

    triggerEvent(element: any, eventType: any): void;

    unwrapObservable<T>(value: KnockoutObservable<T> | T): T;
    unwrapObservable<T>(value: KnockoutObservableArray<T> | T[]): T[];

    // NOT PART OF THE MINIFIED API SURFACE (ONLY IN knockout-{version}.debug.js) https://github.com/SteveSanderson/knockout/issues/670
    // forceRefresh(node: any): void;
    // ieVersion: number;
    // isIe6: boolean;
    // isIe7: boolean;
    // jQueryHtmlParse(html: string): any[];
    // makeArray(arrayLikeObject: any): any[];
    // moveCleanedNodesToContainerElement(nodes: any[]): HTMLElement;
    // replaceDomNodes(nodeToReplaceOrNodeArray: any, newNodesArray: any[]): void;
    // setDomNodeChildren(domNode: any, childNodes: any[]): void;
    // setElementName(element: any, name: string): void;
    // setOptionNodeSelectionState(optionNode: any, isSelected: boolean): void;
    // simpleHtmlParse(html: string): any[];
    // stringStartsWith(str: string, startsWith: string): boolean;
    // stringTokenize(str: string, delimiter: string): string[];
    // stringTrim(str: string): string;
    // tagNameLower(element: any): string;
}

interface KnockoutArrayChange<T> {
    status: "added" | "deleted" | "retained";
    value: T;
    index: number;
    moved?: number;
}

//////////////////////////////////
// templateSources.js
//////////////////////////////////

interface KnockoutTemplateSourcesDomElement {
    text(): any;
    text(value: any): void;

    data(key: string): any;
    data(key: string, value: any): any;
}

interface KnockoutTemplateAnonymous extends KnockoutTemplateSourcesDomElement {
    nodes(): any;
    nodes(value: any): void;
}

interface KnockoutTemplateSources {

    domElement: {
        prototype: KnockoutTemplateSourcesDomElement
        new(element: Element): KnockoutTemplateSourcesDomElement
    };

    anonymousTemplate: {
        prototype: KnockoutTemplateAnonymous;
        new(element: Element): KnockoutTemplateAnonymous;
    };
}

//////////////////////////////////
// nativeTemplateEngine.js
//////////////////////////////////

interface KnockoutNativeTemplateEngine extends KnockoutTemplateEngine {

    renderTemplateSource(templateSource: Object, bindingContext?: KnockoutBindingContext, options?: Object): any[];
}

//////////////////////////////////
// templateEngine.js
//////////////////////////////////

interface KnockoutTemplateEngine {

    createJavaScriptEvaluatorBlock(script: string): string;

    makeTemplateSource(template: any, templateDocument?: Document): any;

    renderTemplate(template: any, bindingContext: KnockoutBindingContext, options: Object, templateDocument: Document): any;

    isTemplateRewritten(template: any, templateDocument: Document): boolean;

    rewriteTemplate(template: any, rewriterCallback: Function, templateDocument: Document): void;
}

//////////////////////////////////
// tasks.js
//////////////////////////////////

interface KnockoutTasks {
    scheduler: (callback: Function) => any;
    schedule(task: Function): number;
    cancel(handle: number): void;
    runEarly(): void;
}

/////////////////////////////////
interface KnockoutStatic {
    utils: KnockoutUtils;
    memoization: KnockoutMemoization;

    bindingHandlers: KnockoutBindingHandlers;
    getBindingHandler(handler: string): KnockoutBindingHandler;

    virtualElements: KnockoutVirtualElements;
    extenders: KnockoutExtenders;

    applyBindings(viewModelOrBindingContext?: any, rootNode?: any): void;
    applyBindingsToDescendants(viewModelOrBindingContext: any, rootNode: any): void;
    applyBindingAccessorsToNode(node: Node, bindings: (bindingContext: KnockoutBindingContext, node: Node) => {}, bindingContext: KnockoutBindingContext): void;
    applyBindingAccessorsToNode(node: Node, bindings: {}, bindingContext: KnockoutBindingContext): void;
    applyBindingAccessorsToNode(node: Node, bindings: (bindingContext: KnockoutBindingContext, node: Node) => {}, viewModel: any): void;
    applyBindingAccessorsToNode(node: Node, bindings: {}, viewModel: any): void;
    applyBindingsToNode(node: Node, bindings: any, viewModelOrBindingContext?: any): any;

    subscribable: KnockoutSubscribableStatic;
    observable: KnockoutObservableStatic;

    computed: KnockoutComputedStatic;
    /**
     * Creates a pure computed observable.
     * @param evaluatorFunction Function that computes the observable value.
     * @param context Defines the value of 'this' when evaluating the computed observable.
     */
    pureComputed<T>(evaluatorFunction: () => T, context?: any): KnockoutComputed<T>;
    /**
     * Creates a pure computed observable.
     * @param options An object that defines the computed observable options and behavior.
     * @param context Defines the value of 'this' when evaluating the computed observable.
     */
    pureComputed<T>(options: KnockoutComputedDefine<T>, context?: any): KnockoutComputed<T>;

    observableArray: KnockoutObservableArrayStatic;

    /**
     * Evaluates if instance is a KnockoutSubscribable.
     * @param instance Instance to be evaluated.
     */
    isSubscribable(instance: any): instance is KnockoutSubscribable<any>;
    /**
     * Clones object substituting each observable for it's underlying value. Uses browser JSON.stringify internally to stringify the result.
     * @param viewModel Object with observables to be converted.
     * @param replacer A Function or array of names that alters the behavior of the stringification process.
     * @param space Used to insert white space into the output JSON string for readability purposes.
     */
    toJSON(viewModel: any, replacer?: Function | [string | number], space?: string | number): string;
    /**
     * Clones object substituting for each observable the current value of that observable.
     * @param viewModel Object with observables to be converted.
     */
    toJS(viewModel: any): any;
    /**
     * Determine if argument is an observable. Returns true for observables, observable arrays, and all computed observables.
     * @param instance Object to be checked.
     */
    isObservable(instance: any): instance is KnockoutObservable<any>;
    /**
     * Determine if argument is an observable. Returns true for observables, observable arrays, and all computed observables.
     * @param instance Object to be checked.
     */
    isObservable<T>(instance: KnockoutObservable<T> | T): instance is KnockoutObservable<T>;
    /**
     * Determine if argument is a writable observable. Returns true for observables, observable arrays, and writable computed observables.
     * @param instance Object to be checked.
     */
    isWriteableObservable(instance: any): instance is KnockoutObservable<any>;
    /**
     * Determine if argument is a writable observable. Returns true for observables, observable arrays, and writable computed observables.
     * @param instance Object to be checked.
     */
    isWriteableObservable<T>(instance: KnockoutObservable<T> | T): instance is KnockoutObservable<T>;
    /**
     * Determine if argument is a computed observable.
     * @param instance Object to be checked.
     */
    isComputed(instance: any): instance is KnockoutComputed<any>;
    /**
     * Determine if argument is a computed observable.
     * @param instance Object to be checked.
     */
    isComputed<T>(instance: KnockoutObservable<T> | T): instance is KnockoutComputed<T>;

    /**
     * Returns the data that was available for binding against the element.
     * @param node Html node that contains the binding context.
     */
    dataFor(node: Node): any;
    /**
     * Returns the entire binding context that was available to the DOM element.
     * @param node Html node that contains the binding context.
     */
    contextFor(node: Node): any;
    /**
     * Removes a node from the DOM.
     * @param node Node to be removed.
     */
    removeNode(node: Node): void;
    /**
     * Used internally by Knockout to clean up data/computeds that it created related to the element. It does not remove any event handlers added by bindings.
     * @param node Node to be cleaned.
     */
    cleanNode(node: Node): Node;
    renderTemplate(template: Function, viewModel: any, options?: any, target?: any, renderMode?: any): any;
    renderTemplate(template: string, viewModel: any, options?: any, target?: any, renderMode?: any): any;
    /**
     * Returns the underlying value of the Knockout Observable or in case of plain js object, return the object. Use this to easily accept both observable and plain values.
     * @param instance observable to be unwraped if it's an Observable.
     */
    unwrap<T>(instance: KnockoutObservable<T> | T): T;
    /**
     * Gets the array inside the KnockoutObservableArray.
     * @param instance observable to be unwraped.
     */
    unwrap<T>(instance: KnockoutObservableArray<T> | T[]): T[];

    /**
     * Get information about the current computed property during the execution of a computed observable’s evaluator function.
     */
    computedContext: KnockoutComputedContext;

    //////////////////////////////////
    // templateSources.js
    //////////////////////////////////

    templateSources: KnockoutTemplateSources;

    //////////////////////////////////
    // templateEngine.js
    //////////////////////////////////

    templateEngine: {

        prototype: KnockoutTemplateEngine;

        new(): KnockoutTemplateEngine;
    };

    //////////////////////////////////
    // templateRewriting.js
    //////////////////////////////////

    templateRewriting: {

        ensureTemplateIsRewritten(template: Node, templateEngine: KnockoutTemplateEngine, templateDocument: Document): any;
        ensureTemplateIsRewritten(template: string, templateEngine: KnockoutTemplateEngine, templateDocument: Document): any;

        memoizeBindingAttributeSyntax(htmlString: string, templateEngine: KnockoutTemplateEngine): any;

        applyMemoizedBindingsToNextSibling(bindings: any, nodeName: string): string;
    };

    //////////////////////////////////
    // nativeTemplateEngine.js
    //////////////////////////////////

    nativeTemplateEngine: {

        prototype: KnockoutNativeTemplateEngine;

        new(): KnockoutNativeTemplateEngine;

        instance: KnockoutNativeTemplateEngine;
    };

    //////////////////////////////////
    // jqueryTmplTemplateEngine.js
    //////////////////////////////////

    jqueryTmplTemplateEngine: {

        prototype: KnockoutTemplateEngine;

        renderTemplateSource(templateSource: Object, bindingContext: KnockoutBindingContext, options: Object): Node[];

        createJavaScriptEvaluatorBlock(script: string): string;

        addTemplate(templateName: string, templateMarkup: string): void;
    };

    //////////////////////////////////
    // templating.js
    //////////////////////////////////

    setTemplateEngine(templateEngine: KnockoutNativeTemplateEngine | undefined): void;

    renderTemplate(template: Function, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any;
    renderTemplate(template: any, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any;
    renderTemplate(template: Function, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any;
    renderTemplate(template: any, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any;
    renderTemplate(template: Function, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any;
    renderTemplate(template: any, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any;
    renderTemplate(template: Function, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any;
    renderTemplate(template: any, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any;

    renderTemplateForEach(template: Function, arrayOrObservableArray: any[], options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any;
    renderTemplateForEach(template: any, arrayOrObservableArray: any[], options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any;
    renderTemplateForEach(template: Function, arrayOrObservableArray: KnockoutObservable<any>, options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any;
    renderTemplateForEach(template: any, arrayOrObservableArray: KnockoutObservable<any>, options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any;

    /**
     * Executes a callback function inside a computed observable, without creating a dependecy between it and the observables inside the function.
     * @param callback Function to be called.
     * @param callbackTarget Defines the value of 'this' in the callback function.
     * @param callbackArgs Arguments for the callback Function.
     */
    ignoreDependencies<T>(callback: () => T, callbackTarget?: any, callbackArgs?: any): T;

    expressionRewriting: {
        bindingRewriteValidators: any[];
        twoWayBindings: any;
        parseObjectLiteral: (objectLiteralString: string) => any[];

        /**
        Internal, private KO utility for updating model properties from within bindings
        property:            If the property being updated is (or might be) an observable, pass it here
                             If it turns out to be a writable observable, it will be written to directly
        allBindings:         An object with a get method to retrieve bindings in the current execution context.
                             This will be searched for a '_ko_property_writers' property in case you're writing to a non-observable
                             (See note below)
        key:                 The key identifying the property to be written. Example: for { hasFocus: myValue }, write to 'myValue' by specifying the key 'hasFocus'
        value:               The value to be written
        checkIfDifferent:    If true, and if the property being written is a writable observable, the value will only be written if
                             it is !== existing value on that writable observable

        Note that if you need to write to the viewModel without an observable property,
        you need to set ko.expressionRewriting.twoWayBindings[key] = true; *before* the binding evaluation.
        */
        writeValueToProperty: (property: KnockoutObservable<any> | any, allBindings: KnockoutAllBindingsAccessor, key: string, value: any, checkIfDifferent?: boolean) => void;
    };

    /////////////////////////////////

    bindingProvider: {
        instance: KnockoutBindingProvider;
        new(): KnockoutBindingProvider;
    }

    /////////////////////////////////
    // selectExtensions.js
    /////////////////////////////////

    selectExtensions: {

        readValue(element: HTMLElement): any;

        writeValue(element: HTMLElement, value: any, allowUnset?: boolean): void;
    };

    components: KnockoutComponents;

    /////////////////////////////////
    // options.js
    /////////////////////////////////

    options: {
        deferUpdates: boolean,

        useOnlyNativeEvents: boolean
    };

    /////////////////////////////////
    // tasks.js
    /////////////////////////////////

    tasks: KnockoutTasks;

    /////////////////////////////////
    // utils.js
    /////////////////////////////////

    onError?: (error: Error) => void;
}

interface KnockoutBindingProvider {
    nodeHasBindings(node: Node): boolean;
    getBindings(node: Node, bindingContext: KnockoutBindingContext): {};
    getBindingAccessors?(node: Node, bindingContext: KnockoutBindingContext): { [key: string]: string; };
}

interface KnockoutComputedContext {
    /**
     * Returns the number of dependencies of the computed observable detected so far during the current evaluation.
     */
    getDependenciesCount(): number;
    /**
     * A function that returns true if called during the first ever evaluation of the current computed observable, or false otherwise.
     * For pure computed observables, isInitial() is always undefined.
     */
    isInitial: () => boolean;
    isSleeping: boolean;
}

//
// refactored types into a namespace to reduce global pollution
// and used Union Types to simplify overloads (requires TypeScript 1.4)
//
declare namespace KnockoutComponentTypes {
    type ViewModel = ViewModelFunction | ViewModelSharedInstance | ViewModelFactoryFunction | AMDModule;
    
    interface Config<T> {
        viewModel?: T;
        template: string | Node[] | DocumentFragment | TemplateElement | AMDModule;
        synchronous?: boolean;
    }

    interface ComponentConfig<T = ViewModel> {
        viewModel?: T;
        template: any;
        createViewModel?: any;
    }

    interface EmptyConfig {
    }

    // common AMD type
    interface AMDModule {
        require: string;
    }

    // viewmodel types
    interface ViewModelFunction {
        (params?: any): any;
    }

    interface ViewModelSharedInstance {
        instance: any;
    }

    interface ViewModelFactoryFunction {
        createViewModel: (params: any, componentInfo: ComponentInfo) => any;
    }

    interface ComponentInfo {
        element: Node;
        templateNodes: Node[];
    }

    interface TemplateElement {
        element: string | Node;
    }

    interface Loader {
        /**
         * Define this if: you want to supply configurations programmatically based on names, e.g., to implement a naming convention.
         * @see {@link https://knockoutjs.com/documentation/component-loaders.html}
         */
        getConfig?(componentName: string, callback: (result: ComponentConfig | null) => void): void;
        /**
         * Define this if: you want to take control over how component configurations are interpreted, e.g., if you do not want to use the standard 'viewModel/template' pair format.
         * @see {@link https://knockoutjs.com/documentation/component-loaders.html}
         */
        loadComponent?(componentName: string, config: ComponentConfig, callback: (result: Definition | null) => void): void;
        /**
         * Define this if: you want to use custom logic to supply DOM nodes for a given template configuration (e.g., using an ajax request to fetch a template by URL).
         * @see {@link https://knockoutjs.com/documentation/component-loaders.html}
         */
        loadTemplate?(componentName: string, templateConfig: any, callback: (result: Node[] | null) => void): void;
        /**
         * Define this if: you want to use custom logic to supply a viewmodel factory for a given viewmodel configuration (e.g., integrating with a third-party module loader or dependency injection system).
         * @see {@link https://knockoutjs.com/documentation/component-loaders.html}
         */
        loadViewModel?(componentName: string, viewModelConfig: any, callback: (result: any) => void): void;
        suppressLoaderExceptions?: boolean;
    }

    interface Definition {
        template: Node[];
        createViewModel?(params: any, options: { element: Node; }): any;
    }
}

interface KnockoutComponents {

    /**
     * Registers a component, in the default component loader, to be used by name in the component binding.
     * @param componentName Component name. Will be used for your custom HTML tag name.
     * @param config Component configuration.
     */
    register<T = KnockoutComponentTypes.ViewModel>(componentName: string, config: KnockoutComponentTypes.Config<T> | KnockoutComponentTypes.EmptyConfig): void;
    /**
     * Determine if a component with the specified name is already registered in the default component loader.
     * @param componentName Component name.
     */
    isRegistered(componentName: string): boolean;
    /**
     * Removes the named component from the default component loader registry. Or if no such component was registered, does nothing.
     * @param componentName Component name.
     */
    unregister(componentName: string): void;
    /**
     * Searchs each registered component loader by component name, and returns the viewmodel/template declaration via callback parameter.
     * @param componentName Component name.
     * @param callback Function to be called with the viewmodel/template declaration parameter.
     */
    get(componentName: string, callback: (definition: KnockoutComponentTypes.Definition) => void): void;
    /**
     * Clears the cache knockout creates to speed up component loading, for a given component.
     * @param componentName Component name.
     */
    clearCachedDefinition(componentName: string): void
    defaultLoader: KnockoutComponentTypes.Loader;
    loaders: KnockoutComponentTypes.Loader[];
    /**
     * Returns the registered component name for a HTML element. Can be overwriten to to control dynamically which HTML element map to which component name.
     * @param node html element that corresponds to a custom component.
     */
    getComponentNameForNode(node: Node): string;
}

declare var ko: KnockoutStatic;

declare module "knockout" {
    export = ko;
}