How to use the @hpcc-js/api.IInput.prototype function in @hpcc-js/api

type_exists: () => boolean;
    inlineLabel: { (): string; (_: string): InputRange };
    inlineLabel_exists: () => boolean;
    value: { (): any[]; (_: any[]): InputRange };
    value_exists: () => boolean;

    //  IInput  ---
    name: { (): string; (_: string): InputRange };
    name_exists: () => boolean;
    label: { (): string; (_: string): InputRange };
    label_exists: () => boolean;
    validate: { (): string; (_: string): InputRange };
    validate_exists: () => boolean;
}
InputRange.prototype._class += " form_InputRange";
InputRange.prototype.implements(IInput.prototype);

InputRange.prototype.publish("type", "text", "set", "InputRange type", ["number", "date", "text", "time", "datetime", "hidden"]);
InputRange.prototype.publish("inlineLabel", null, "string", "InputRange Label", null, { optional: true });
InputRange.prototype.publish("value", ["", ""], "array", "Input Current Value", null, { override: true });

high_exists: () => boolean;
    step: { (): number; (_: number): Range };
    step_exists: () => boolean;

    //  IInput  ---
    name: { (): string; (_: string): Range };
    name_exists: () => boolean;
    label: { (): string; (_: string): Range };
    label_exists: () => boolean;
    value: { (): any; (_: any): Range };
    value_exists: () => boolean;
    validate: { (): string; (_: string): Range };
    validate_exists: () => boolean;
}
Range.prototype._class += " form_Range";
Range.prototype.implements(IInput.prototype);

Range.prototype.publish("type", "text", "set", "Input type", ["html-color", "number", "checkbox", "button", "select", "textarea", "date", "text", "range", "search", "email", "time", "datetime"]);
Range.prototype.publish("selectOptions", [], "array", "Array of options used to fill a dropdown list");
Range.prototype.publish("low", null, "number", "Minimum value for Range input");
Range.prototype.publish("high", null, "number", "Maximum value for Range input");
Range.prototype.publish("step", null, "number", "Step value for Range input");

name_exists: () => boolean;
    label: { (): string; (_: string): Input };
    label_exists: () => boolean;
    value: { (): any; (_: any): Input };
    value_exists: () => boolean;
    validate: { (): string; (_: string): Input };
    validate_exists: () => boolean;

    //  IInput Events ---
    blur: (w: Input) => void;
    click: (w: Input) => void;
    dblclick: (w: Input) => void;
    change: (w: Input, complete: boolean) => void;
}
Input.prototype._class += " form_Input";
Input.prototype.implements(IInput.prototype);

Input.prototype.publish("type", "text", "set", "Input type", ["number", "button", "checkbox", "date", "text", "textarea", "search", "email", "time", "datetime", "hidden"]);
Input.prototype.publish("inlineLabel", null, "string", "Input Label", null, { optional: true });

selectOptions: { (): any[]; (_: any[]): Radio };
    selectOptions_exists: () => boolean;

    //  IInput  ---
    name: { (): string; (_: string): Radio };
    name_exists: () => boolean;
    label: { (): string; (_: string): Radio };
    label_exists: () => boolean;
    value: { (): any; (_: any): Radio };
    value_exists: () => boolean;
    validate: { (): string; (_: string): Radio };
    validate_exists: () => boolean;
}
Radio.prototype._class += " form_Radio";
Radio.prototype.implements(IInput.prototype);

Radio.prototype.publish("selectOptions", [], "array", "Array of options used to fill a dropdown list");

selectOptions: { (): any[]; (_: any[]): CheckBox };
    selectOptions_exists: () => boolean;

    //  IInput  ---
    name: { (): string; (_: string): CheckBox };
    name_exists: () => boolean;
    label: { (): string; (_: string): CheckBox };
    label_exists: () => boolean;
    value: { (): any; (_: any): CheckBox };
    value_exists: () => boolean;
    validate: { (): string; (_: string): CheckBox };
    validate_exists: () => boolean;
}
CheckBox.prototype._class += " form_CheckBox";
CheckBox.prototype.implements(IInput.prototype);

CheckBox.prototype.publish("selectOptions", [], "array", "Array of options used to fill a dropdown list");

this._inputElement[0].text(this.value());
    }

    //  IInput  ---
    name: { (): string; (_: string): Button };
    name_exists: () => boolean;
    label: { (): string; (_: string): Button };
    label_exists: () => boolean;
    value: { (): any; (_: any): Button };
    value_exists: () => boolean;
    validate: { (): string; (_: string): Button };
    validate_exists: () => boolean;
}
Button.prototype._class += " form_Button";
Button.prototype.implements(IInput.prototype);

this._inputElement[1].style("height", (bbox.height - 2) + "px");

    }

    //  IInput  ---
    name: { (): string; (_: string): ColorInput };
    name_exists: () => boolean;
    label: { (): string; (_: string): ColorInput };
    label_exists: () => boolean;
    value: { (): any; (_: any): ColorInput };
    value_exists: () => boolean;
    validate: { (): string; (_: string): ColorInput };
    validate_exists: () => boolean;
}
ColorInput.prototype._class += " form_ColorInput";
ColorInput.prototype.implements(IInput.prototype);

selectOptions_exists: () => boolean;
    maxWidth: { (): number; (_: number): Select };
    maxWidth_exists: () => boolean;

    //  IInput  ---
    name: { (): string; (_: string): Select };
    name_exists: () => boolean;
    label: { (): string; (_: string): Select };
    label_exists: () => boolean;
    value: { (): any; (_: any): Select };
    value_exists: () => boolean;
    validate: { (): string; (_: string): Select };
    validate_exists: () => boolean;
}
Select.prototype._class += " form_Select";
Select.prototype.implements(IInput.prototype);

Select.prototype.publish("selectOptions", [], "array", "Array of options used to fill a dropdown list");
Select.prototype.publish("maxWidth", 120, "number", "Width", null, { optional: true });

"M" + (4.5 * x) + "," + (y + 8) +
                "V" + (2 * y - 8)
                ;
        } else {
            retVal += "M" + (1 * x) + "," + (y + 8) +
                "V" + (2 * y - 8)
                ;
        }
        return retVal;
    };

    name: (_?: string) => string | this;
    change: (_: Slider) => void;
}
Slider.prototype._class += " form_Slider";
Slider.prototype.implements(IInput.prototype);

export interface Slider {
    padding(): number;
    padding(_: number): this;
    fontSize(): number;
    fontSize(_: number): this;
    fontFamily(): string;
    fontFamily(_: string): this;
    fontColor(): string;
    fontColor(_: string): this;
    allowRange(): boolean;
    allowRange(_: boolean): this;
    low(): number;
    low(_: number): this;
    high(): number;
    high(_: number): this;

onText(_: string): this;
    switchRadius(): number;
    switchRadius(_: number): this;
    containerRadius(): number;
    containerRadius(_: number): this;
    offColor(): string;
    offColor(_: string): this;
    onColor(): string;
    onColor(_: string): this;
    offFontColor(): string;
    offFontColor(_: string): this;
    onFontColor(): string;
    onFontColor(_: string): this;

}
OnOff.prototype.implements(IInput.prototype);

OnOff.prototype.publish("marginLeft", 0, "number", "Margin left of OnOff");
OnOff.prototype.publish("marginBottom", 0, "number", "Margin bottom of OnOff");
OnOff.prototype.publish("minWidth", 100, "number", "Minimum width of OnOff (pixels)");
OnOff.prototype.publish("minHeight", 20, "number", "Minimum height of OnOff (pixels)");
OnOff.prototype.publish("gutter", 1, "number", "Space between switch and border of OnOff (pixels)");
OnOff.prototype.publish("onText", "Save", "string", "Text to display when 'ON'");
OnOff.prototype.publish("offText", "Properties", "string", "Text to display when 'OFF'");
OnOff.prototype.publish("switchRadius", 10, "number", "Border radius of switch (pixels)");
OnOff.prototype.publish("containerRadius", 10, "number", "Border radius of OnOff (pixels)");
OnOff.prototype.publish("onColor", "#2ecc71", "html-color", "Background color when 'ON'");
OnOff.prototype.publish("offColor", "#ecf0f1", "html-color", "Background color when 'OFF'");
OnOff.prototype.publish("onFontColor", "#2c3e50", "html-color", "Font color when 'ON'");
OnOff.prototype.publish("offFontColor", "#7f8c8d", "html-color", "Font color when 'OFF'");