/// <reference path="./sigApi.ApiBase.d.ts" />
/// <reference path="./sigApi.Property.d.ts" />
/// <reference path="./sigApi.SchemeBranchData.d.ts" />
/// <reference path="./sigApi.SchemeIdentifier.d.ts" />

declare namespace SigApi {
    interface ApiProperties extends ApiBase {
        /**
         * Gets a property of a control. 
         * 
         * @param {string} instanceId The instanceId of the control from which the property should be taken
         * @param {string} propertyName The name of the property
         * @param {boolean} [keepPropertyStructure = false] If set to `true` {@link PropertyPropertySwitch}|{@link PropertyScheme} branches are not resolved
         *                                                  and the {@link PropertyPropertySwitch}|{@link PropertyScheme} is returned
         * 
         * @returns {Property|null} Returns the property (see description of property class) or null if it was not found
         */
        getProperty(
            instanceId: string,
            propertyName: string,
            keepPropertyStructure?: boolean
        ): Property | null
        /**
         * Gets the Description Object of an property (references).
         * 
         * @param {string} instanceId The instanceId of the control from which the property should be taken
         * @param {string} propertyName The name of the property
         * 
         * @returns {PropertyObject|null} Returns the descriptionObject of an property
         * 
         * object {src: `number`, dest: `number`, value: `number|string`}
         */
        getPropertyReference(
            instanceId: string,
            propertyName: string
        ): PropertyObject | null
        /**
         * Formats (unit conversion and format) the given value like the value of the specified Property
         * 
         * @param {string} instanceId  The instanceId of the control from which the property should be taken
         * @param {string} propertyName The name of the property
         * @param {number} value The value which should be formated
         * 
         * @returns {number|string} The formated value
         */
        formatValueLike(
            instanceId: string,
            propertyName: string,
            value: number
        ): number | string
        /**
         * Converts (unit conversion) the given value like the value of the specified Property
         * 
         * @param {string} instanceId  The instanceId of the control from which the property should be taken
         * @param {string} propertyName The name of the property
         * @param {number} value The value which should be converted
         * 
         * @returns {number|string} The converted value
         */
        convertValueLike(
            instanceId: string,
            propertyName: string,
            value: number | string
        ): number | string
        /**
         * Converts (unit back-conversion) the given value back like the value of the specified Property
         * 
         * @param {string} instanceId  The instanceId of the control from which the property should be taken
         * @param {string} propertyName The name of the property
         * @param {number} value The value which should be converted
         * 
         * @returns {number|string} The converted value
         */
        convertValueBackLike(
            instanceId: string,
            propertyName: string,
            value: number | string
        ): number | string
        /**
         * Unit conversion and formatting of a given value according to a unit. 
         * Use this to convert values from their base unit to a given unit and format them as a string for display.
         * Because formulas could contain datapoints which must be read first, this function returns a Promise
         * 
         * @param {number|string} unitId The id or the name of the unit
         * @param {number|string} value The number or numeric string which should be converted
         * @param {boolean} [isFloatingPoint=true] A flag if the value should be treated as float or as an integer (integer uses the units decimals as divisor if the unit contains no formula)
         * @param {boolean} [indicateOverflow=true] A flag which specifies if values which are greater then the maxDigits should be displayed as <<< (= true) or as the max Number (= false & correct Round Type)
         * @param {number} [roundType=SIG_CONST.ROUND_ROUND] Specifies how values are round (0 = normalRound, 1 = ceil, 2 = floor)
         * 
         * @returns {Promise<string>} Promise -> resolve: (string) => void, reject: ({string}) => void
         * 
         * A Promise which is resolved with the formatted value as parameter
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        formatValueWithUnit(
            unitId: number | string,
            value: number | string,
            isFloatingPoint?: boolean,
            indicateOverflow?: boolean,
            roundType?: number
        ): Promise<string>
        /**
         * Unit conversion of a given value according to a unit. 
         * Use this to convert values from their base unit to a given unit for display or input.
         * Because formulas could contain datapoints which must be read first, this function returns a Promise
         * 
         * @param {number|string} unitId The id or the name of the unit
         * @param {number|string} value The number or numeric string which should be converted
         * @param {boolean} [isFloatingPoint=true] A flag if the value should be treated as float or as an integer (integer uses the units decimals as divisor if the unit contains no formula)
         * 
         * @returns {Promise<number>} Promise -> resolve: (number) => void, reject: () => void
         * 
         * A Promise which is resolved with the converted value as parameter
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        convertValueWithUnit(
            unitId: number | string,
            value: number | string,
            isFloatingPoint?: boolean
        ): Promise<number>
        /**
         * Reverts unit conversion and formatting of a given (display) value according to a unit.
         * Use this to revert conversions done by convertValueWithUnit or formatValueWithUnit to obtain the value in its base unit for serialization or writing to a datapoint.
         * Because formulas could contain datapoints which must be read first, this function returns a Promise
         * 
         * @param {number|string} unitId The id or the name of the unit
         * @param {number|string} value The numeric value or formatted number string which should be converted back according to the unit
         * @param {boolean} [isFloatingPoint=true] A flag if the value should be treated as float or as an integer (integer uses the units decimals as divisor if the unit contains no formula)
         * 
         * @returns {Promise<number>} Promise -> resolve: (number) => void, reject: () => void
         * 
         * A Promise which is resolved with the converted value as parameter
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        convertValueBackWithUnit(
            unitId: number | string,
            value: number | string,
            isFloatingPoint?: boolean
        ): Promise<number>
        /**
         * Formats (unit conversion and format) the given value with a unitscheme. Because Formulas and schemes could have datapoints which must be read first, this function uses a Promise
         * 
         * @param {number|SchemeIdentifier} schemeId The id of the scheme. Important note: using only the name of the scheme is deprecated and should no longer be used! Use numeric Id or Identifier object instead...
         * @param {number|string} schemeInput The id or the name of the scheme-input-datapoint or a constant value depending on useInputAsConstant flag
         * @param {number} value The number which should be converted
         * @param {number|string} [defaultUnit=null] The id or the name of the unit which should be used if no schemebranch is active (if null, the value is returned)
         * @param {boolean} [isFloatingPoint=true] A flag if the value should be treated a float of as an integer (integer uses the decimalDigits as divisor)
         * @param {boolean} [indicateOverflow=true] A flag which specifies if values which are greater then the maxDigits should be displayed as <<< (= true) or as the max Number (= false & correct Round Type)
         * @param {number} [roundType=SIG_CONST.ROUND_ROUND] Specifies how values are round (0 = normalRound, 1 = ceil, 2 = floor)
         * @param {boolean} [useInputAsConstant=false] A flag which describes if the schemeInput is a constant number or a dp id
         * 
         * @returns {Promise<string>} Promise -> resolve: (string) => void, reject: () => void
         * 
         * A Promise which is resolved with the formatted value as parameter
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        formatValueWithUnitscheme(
            schemeId: number | SchemeIdentifier,
            schemeInput: number | string,
            value: number,
            defaultUnit?: number | string,
            isFloatingPoint?: boolean,
            indicateOverflow?: boolean,
            roundType?: number,
            useInputAsConstant?: boolean
        ): Promise<string>
        /**
         * Formats (unit conversion and format) the given value with a unitscheme. Because Formulas and schemes could have datapoints which must be read first, this function uses a Promise
         * 
         * @param {number|SchemeIdentifier} schemeId The id of the scheme. Important note: using only the name of the scheme is deprecated and should no longer be used! Use numeric Id or Identifier object instead...
         * @param {number|string} schemeInput a constant value a input
         * @param {number} value The number which should be converted
         * @param {number|string} [defaultUnit=null] The id or the name of the unit which should be used if no schemebranch is active (if null, the value is returned)
         * @param {boolean} [isFloatingPoint=true] A flag if the value should be treated a float of as an integer (integer uses the decimalDigits as divisor)
         * @param {boolean} [indicateOverflow=true] A flag which specifies if values which are greater then the maxDigits should be displayed as <<< (= true) or as the max Number (= false & correct Round Type)
         * @param {number} [roundType=SIG_CONST.ROUND_ROUND] Specifies how values are round (0 = normalRound, 1 = ceil, 2 = floor)
         * 
         * @returns {Promise<string>} Promise -> resolve: (string) => void, reject: () => void
         * 
         * A Promise which is resolved with the formatted value as parameter
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        formatValueWithUnitschemeC(
            schemeId: number | SchemeIdentifier,
            schemeInput: number | string,
            value: number,
            defaultUnit?: number | string,
            isFloatingPoint?: boolean,
            indicateOverflow?: boolean,
            roundType?: number
        ): Promise<string>
        /**
         * Converts (unit conversion) the given value with a unitscheme. Because Formulas and schemes could have datapoints which must be read first, this function uses a Promise
         * 
         * @param {number|SchemeIdentifier} schemeId The id of the scheme. Important note: using only the name of the scheme is deprecated and should no longer be used! Use numeric Id or Identifier object instead...
         * @param {number|string} schemeInput The id or the name of the scheme-input-datapoint or a constant value depending on useInputAsConstant flag
         * @param {number} value The number which should be converted
         * @param {number|string} [defaultUnit=null] The id or the name of the unit which should be used if no schemebranch is active (if null, the value is returned)
         * @param {boolean} [isFloatingPoint=true] A flag if the value should be treated a float of as an integer (integer uses the decimalDigits as divisor)
         * @param {boolean} [useInputAsConstant=false] A flag which describes if the schemeInput is a constant number or a dp id
         * 
         * @returns {Promise<number>} Promise -> resolve: (number) => void, reject: () => void
         * 
         * A Promise which is resolved with the converted value as parameter
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        convertValueWithUnitscheme(
            schemeId: number | SchemeIdentifier,
            schemeInput: number | string,
            value: number,
            defaultUnit?: number | string,
            isFloatingPoint?: boolean,
            useInputAsConstant?: boolean
        ): Promise<number>
        /**
         * Converts (unit back-conversion) the given value back with a unitscheme. Because Formulas and schemes could have datapoints which must be read first, this function uses a Promise
         * 
         * @param {number|SchemeIdentifier} schemeId The id of the scheme. Important note: using only the name of the scheme is deprecated and should no longer be used! Use numeric Id or Identifier object instead...
         * @param {number|string} schemeInput The id or the name of the scheme-input-datapoint or a constant value depending on useInputAsConstant flag
         * @param {number} value The number which should be converted
         * @param {number|string} [defaultUnit=null] The id or the name of the unit which should be used if no schemebranch is active (if null, the value is returned)
         * @param {boolean} [isFloatingPoint=true] A flag if the value should be treated a float of as an integer (integer uses the decimalDigits as divisor)
         * @param {boolean} [useInputAsConstant=false] A flag which describes if the schemeInput is a constant number or a dp id
         * 
         * @returns {Promise<number>} Promise -> resolve: (number) => void, reject: () => void
         * 
         * A Promise which is resolved with the converted value as parameter
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        convertValueBackWithUnitscheme(
            schemeId: number | SchemeIdentifier,
            schemeInput: number | string,
            value: number | string,
            defaultUnit?: number | string,
            isFloatingPoint?: boolean,
            useInputAsConstant?: boolean
        ): Promise<number>
        /**
         * Evaluates a scheme, and returns the Value. !Important! If a CompositeControl Scheme is evalueated, the vm will always be null,
         * because it could not be rendered without a VM context. 
         * 
         * @param {number|SchemeIdentifier} schemeId The id of the scheme. Important note: using only the name of the scheme is deprecated and should no longer be used! Use numeric Id or Identifier object instead...
         * @param {number|string} schemeInput The id or the name of the scheme-input-datapoint or a constant value depending on useInputAsConstant flag
         * @param {boolean} [useInputAsConstant=false] A flag which describes if the schemeInput is a constant number or a dp id
         * 
         * @returns {Promise<string>} Promise -> resolve: (number|string) => void, reject: (string) => void
         * 
         * A Promise which is resolved with the SchemeValue
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        doScheme(
            schemeId: number | SchemeIdentifier,
            schemeInput: number | string,
            useInputAsConstant?: boolean
        ): Promise<number | string>
        /**
        * Evaluates a scheme, and returns the Value
        * 
        * @param {string} instanceId The instancedId of the VM from where the Property is taken
        * @param {string} propertyName The name of the Property
        * @param {number|string} schemeInput The id or the name of the scheme-input-datapoint or a constant value depending on useInputAsConstant flag
        * @param {boolean} useInputAsConstant A flag which describes if the schemeInput is a constant number or a dp id
        * 
        * @returns {Promise<number|string>} Promise -> resolve: (number|string) => void, reject: (string) => void
        * 
        * A Promise which is resolved with the SchemeValue
        * 
        * The Promise gets rejected with a string describing the reason, if the input was invalid
        */
        doSchemeWithProperty(
            instanceId: string,
            propertyName: string,
            schemeInput: number | string,
            useInputAsConstant: boolean
        ): Promise<number | string>
        /**
         * Evaluates all Branches of a scheme
         * 
         * @param {number|SchemeIdentifier} schemeId The id of the scheme. Important note: using only the name of the scheme is deprecated and should no longer be used! Use numeric Id or Identifier object instead...
         * 
         * @returns {Promise} Promise -> resolve: ([{operator: number, compare: {@link PropertyObject}, value: string|number}]) => void, reject: (string) => void 
         * 
         * A Promise which is resolved with an array of schemeValues, compareOperators and compareValues(as property Object)
         * 
         * The CompareOperator is a number constant (see sigApi.SIG_CONST.SCHEME_OPERATOR_* constants) 
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        getSchemeData(
            schemeId: number | SchemeIdentifier
        ): Promise<{ operator: number, compare: PropertyObject, value: string | number }[]>
        /**
         * Evaluates all Branches of a scheme
         * 
         * @param {string} instanceId The instancedId of the VM from where the Property is taken
         * @param {string} propertyName The name of the Property
         * 
         * @returns {Promise} Promise -> resolve: ([{operator: number, compare: {@link PropertyObject}, value: string|number}]) => void, reject: (string) => void
         * 
         * A Promise which is resolved with an array of schemeValues, compareOperators and compareValues(as property Object)
         * 
         * The CompareOperator is a number constant (see sigApi.SIG_CONST.SCHEME_OPERATOR_* constants)
         * 
         * The Promise gets rejected with a string describing the reason, if the input was invalid
         */
        getSchemeDataWithProperty(
            instanceId: string,
            propertyName: string
        ): Promise<{ operator: number, compare: PropertyObject, value: string | number }[]>
        /**
         * Returns the configuration data (references) of all scheme branches of the given scheme
         * 
         * @param {number|SchemeIdentifier} schemeId The id of the scheme. Important note: using only the name of the scheme is deprecated and should no longer be used! Use numeric Id or Identifier object instead...
         * 
         * @returns {Promise<SchemeBranchData[]>} Promise -> resolve: ( {@link SchemeBranchData}[] ) => void, reject: (`string`) => void
         * 
         * A Promise which is resolved with an array of scheme branch configurations consisting of compareOperator, comparePropertyObject and resultPropertyObject
         * 
         * The compareOperator is a number constant (see sigApi.SIG_CONST.SCHEME_OPERATOR_* constants)
         * 
         * The comparePropertyObject and resultPropertyObject are of type {@link PropertyObject}
         * 
         * The Promise gets rejected with an error text, if the input was invalid
         */
        getSchemeBranchData(
            schemeId: number | SchemeIdentifier
        ): Promise<SchemeBranchData[]>
        /**
         * Returns the configuration data (references) of all scheme branches if the given property is a scheme
         * 
         * @param {string} instanceId The instancedId of the VM where the scheme property is located
         * @param {string} propertyName The name of the scheme property
         * 
         * @returns {Promise<SchemeBranchData[]>} Promise -> resolve: ( {@link SchemeBranchData}[] ) => void, reject: (`string`) => void
         * 
         * A Promise which is resolved with an array of scheme branch configurations consisting of compareOperator, comparePropertyObject and resultPropertyObject
         * 
         * The compareOperator is a number constant (see sigApi.SIG_CONST.SCHEME_OPERATOR_* constants)
         * 
         * The comparePropertyObject and resultPropertyObject are of type {@link PropertyObject}
         * 
         * The Promise gets rejected with an error text, if the input was invalid
         */
        getSchemeBranchDataWithProperty(
            instanceId: string,
            propertyName: string
        ): Promise<SchemeBranchData[]>
        /**
         * Creates a property
         * 
         * For a propObj to be observable it requires a name and a dest != SIG_CONST.PROP_DEST_NONE.
         * 
         * Adds additional functions to property
         *  * addObserver({Function} callback({any} value), [{boolean} ignoreOldValueCheck = false]): {string} id
         *    Adds an observer callback to the property and returns an id for later removal
         *    callback parameter value is dependent on Property (see Property.getValue for more details)
         *  * removeObserver({string} id): {boolean}
         *    Removes an observer by its id (return value of addObserver)
         *  * overload({number|string}dataPoint, {number} selectionGroup, {number|string} target)
         *    The property will be overloaded with the given datapoint
         *  * setActive()
         *    The property will start to trigger logic and updates (properties are created in active state)
         *  * setInactive()
         *    The property will no longer trigger any logic or updates
         *  * destroy()
         *    The property will be destroyed to enable garbage collection - all observers will be removed
         * 
         * @param {PropertyObject} propObj The property blueprint of the property
         * @param {number} [predefPropMask=SIG_CONST.PROP_PREDEF_PROPS_MASK_AUTO] SIG_CONST.PROP_PREDEF_PROPS_MASK_*
         * @param {boolean} [keepPropertyStructure = false] If set to `true` {@link PropertyPropertySwitch}|{@link PropertyScheme} branches are not resolved
         *                                                  and the {@link PropertyPropertySwitch}|{@link PropertyScheme} is returned
         * @returns {Property|undefined} The newly created property or undefined if no property could be created
         */
        createProperty(
            propObj: PropertyObject,
            predefPropMask?: number,
            keepPropertyStructure?: boolean
        ): Property | undefined
        /**
         * Function to check if parameter object is a instanceof Property.
         * This function can be used without importing the type Property to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof Property, else false
         */
        instanceofProperty(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyConstant.
         * This function can be used without importing the type PropertyConstant to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyConstant, else false
         */
        instanceofPropertyConstant(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyUnit.
         * This function can be used without importing the type PropertyUnit to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyUnit, else false
         */
        instanceofPropertyUnit(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyText.
         * This function can be used without importing the type PropertyText to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyText, else false
         */
        instanceofPropertyText(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyCompositeControl.
         * This function can be used without importing the type PropertyCompositeControl to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyCompositeControl, else false
         */
        instanceofPropertyCompositeControl(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyFunctionBlock.
         * This function can be used without importing the type PropertyFunctionBlock to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyFunctionBlock, else false
         */
        instanceofPropertyFunctionBlock(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyEvent.
         * This function can be used without importing the type PropertyEvent to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyEvent, else false
         */
        instanceofPropertyEvent(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyDatapoint.
         * This function can be used without importing the type PropertyDatapoint to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyDatapoint, else false
         */
        instanceofPropertyDatapoint(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyScheme.
         * This function can be used without importing the type PropertyScheme to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyScheme, else false
         */
        instanceofPropertyScheme(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyPropertySwitch.
         * This function can be used without importing the type PropertyPropertySwitch to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyPropertySwitch, else false
         */
        instanceofPropertyPropertySwitch(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyResource.
         * This function can be used without importing the type PropertyResource to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyResource, else false
         */
        instanceofPropertyResource(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyFont.
         * This function can be used without importing the type PropertyFont to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyFont, else false
         */
        instanceofPropertyFont(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyFormat.
         * This function can be used without importing the type PropertyFormat to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyFormat, else false
         */
        instanceofPropertyFormat(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyMenu.
         * This function can be used without importing the type PropertyMenu to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyMenu, else false
         */
        instanceofPropertyMenu(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyAccessNumber.
         * This function can be used without importing the type PropertyAccessNumber to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyAccessNumber, else false
         */
        instanceofPropertyAccessNumber(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof PropertyCheckbit.
         * This function can be used without importing the type PropertyCheckbit to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof PropertyCheckbit, else false
         */
        instanceofPropertyCheckbit(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof Scheme.
         * This function can be used without importing the type Scheme to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof Scheme, else false
         */
        instanceofScheme(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof SchemeBranch.
         * This function can be used without importing the type SchemeBranch to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof SchemeBranch, else false
         */
        instanceofSchemeBranch(object: any): boolean
        /**
         * Function to check if parameter object is a instanceof CompositeControl.
         * This function can be used without importing the type CompositeControl to be used with the instanceof operator.
         * @param {*} object Any object to type check
         * @returns {boolean} Returns true if parameter object is instanceof CompositeControl, else false
         */
        instanceofCompositeControl(object: any): boolean
    }
}
