import { JSXInterface } from '../jsx';
import { CSSResultGroup, FormFieldElement, PropertyValues, TapEvent, TemplateResult } from '@refinitiv-ui/core';
import { TemplateMap } from '@refinitiv-ui/core/directives/template-map.js';
import '../icon/index.js';
type SelectionDirection = 'forward' | 'backward' | 'none';
declare enum Direction {
    Up = 1,
    Down = -1
}
/**
 * Form control element for numbers.
 *
 * @fires value-changed - Fired when user commits a value change. The event is not triggered if `value` property is changed programmatically.
 * @fires error-changed - Fired when user inputs invalid value. The event is not triggered if `error` property is changed programmatically.
 * @fires step-up - Fired when user acts value up on both pressing arrow up or tapping the spinner up. The event is not triggered if stepUp method is called programmatically.
 * @fires step-down - Fired when user acts value down on both pressing arrow down or tapping the spinner down. The event is not triggered if stepDown method is called programmatically.
 *
 * @attr {boolean} disabled - Set disabled state
 * @prop {boolean} [disabled=false] - Set disabled state
 *
 * @attr {boolean} error - Set error state
 * @prop {boolean} [error=false] - Set error state
 *
 * @attr {string} placeholder - Set placeholder text
 * @prop {string} [placeholder=""] - Set placeholder text
 *
 * @attr {boolean} readonly - Set readonly state
 * @prop {boolean} [readonly=false] - Set readonly state
 *
 * @attr {boolean} transparent - Disables all other states and border/background styles.
 * @prop {boolean} [transparent=false] - Disables all other states and border/background styles.
 *
 * @attr {boolean} warning - Set warning state
 * @prop {boolean} [warning=false] - Set warning state
 *
 * @attr {string} value - Input's value
 * @prop {string} [value=""] - Input's value
 *
 * @attr {boolean} clears - Show clears button
 * @prop {boolean} [clears=false] - Show clears button
 */
export declare class NumberField extends FormFieldElement {
    /**
     * Element version number
     * @returns version number
     */
    static get version(): string;
    /**
     * A `CSSResultGroup` that will be used
     * to style the host, slotted children
     * and the internal template of the element.
     * @return CSS template
     */
    static get styles(): CSSResultGroup;
    /**
     * Time period (ms) before press repetition starts
     */
    private repeatDelay;
    /**
     * Time period (ms) between each repeat
     */
    private repeatRate;
    /**
     * Set spinner's visibility
     */
    noSpinner: boolean;
    /**
     * Set step value
     */
    step: string | null;
    /**
     * Set minimum value.
     * This value must be less than or equal to the value of the `max` attribute
     */
    min: string | null;
    /**
     * Set maximum value.
     * This value must be greater than or equal to the value of the `min` attribute
     */
    max: string | null;
    private interimValueState;
    /**
     * The value of the number entered into the input.
     * @param value number-field value
     * @default -
     */
    set value(value: string);
    get value(): string;
    /**
     * Returns the value of the element, interpreted as double number
     */
    get valueAsNumber(): number;
    /**
     * Get spinner up element
     */
    private spinnerUpEl?;
    /**
     * Get spinner down element
     */
    private spinnerDownEl?;
    /**
     * An object's returned from setTimeout to use with repeat delay.
     */
    private repeatDelayTimer;
    /**
     * An object's returned from setInterval to use with repeat rate.
     */
    private repeatRateTimer;
    /**
     * Called after the component is first rendered
     * @param changedProperties Properties which have changed
     * @returns {void}
     */
    protected firstUpdated(changedProperties: PropertyValues): void;
    /**
     * Updates the element
     * @param changedProperties Properties that has changed
     * @returns {void}
     */
    protected update(changedProperties: PropertyValues): void;
    /**
     * Called when the element’s DOM has been updated and rendered
     * @param changedProperties Properties that has changed
     * @returns {void}
     */
    protected updated(changedProperties: PropertyValues): void;
    /**
     * Convert string to number
     * @param value value to convert
     * @returns NaN if string is an invalid number or Infinity or empty string;
     */
    private stringToNumber;
    /**
     * Convert a float number to a fixed number
     * @param value Value to convert
     * @param [decimals] optional decimals. Default is based on step base and allowed value step
     * @returns fixed number
     */
    private toFixedNumber;
    /**
     * Convert step value from string to number or 'any'
     * @returns step value of input as a number or 'any'
     */
    private get stepValue();
    /**
     * Get the number of decimal places
     * @param value Value to check
     * @returns the number of decimal places
     */
    private getDecimalPlace;
    /**
     * Get number of decimals based on step base and allowed value step
     * @returns decimals
     */
    private get stepDecimals();
    /**
     * Check if passed value is a valid value
     * @override
     * @param value Value to check
     * @returns {boolean} false if value is invalid
     */
    protected isValidValue(value: string): boolean;
    /**
     * Get value as valid number string.
     * @param value A value to convert
     * @returns string value
     */
    private valueAsNumberString;
    /**
     * Get either inputValue or actual value dependant on control state
     * @returns string of input value
     */
    private get internalValue();
    /**
     * Handles key down input event
     * @param event Key down event object
     * @returns {void}
     */
    protected onInputKeyDown(event: KeyboardEvent): void;
    /**
     * Trigger step-up or step-down event and return the event is cancelled
     * @param direction Up or Down
     * @returns {boolean} false if cancelled event. And true otherwise.
     */
    private dispatchStepEvent;
    /**
     * Run when spinner has been tapped
     * @param event tap event
     * @returns {void}
     */
    protected onSpinnerTap(event: TapEvent): void;
    /**
     * Clear repeatDelayTimer and repeatRateTimer if exist
     * @returns {void}
     */
    protected clearTimer: () => void;
    /**
     * Step down or up and notify value change
     * @param direction Up or Down
     * @returns {void}
     */
    protected onApplyStep(direction: Direction): void;
    /**
     * Run before input changes
     * Prevent invalid characters
     * @param event before input event
     * @returns {void}
     */
    protected onBeforeInputChange(event: InputEvent): void;
    /**
     * Runs on input element `input` event
     * @param event `input` event
     * @returns {void}
     */
    protected onInputInput(event: InputEvent): void;
    /**
     * Runs on input element `change` event
     * @param event `change` event
     * @returns {void}
     */
    protected onInputChange(event: InputEvent): void;
    /**
     * Triggers when native input value change with input event or change event
     * @param event Input event
     * @returns {void}
     */
    protected onNativeInputChange(event: InputEvent): void;
    /**
     * Stripe characters from input text based on previous input and data
     * @param input The new input to process
     * @param oldInput Previous input
     * @param data The data that has been inserted
     * @returns the input where characters are striped away
     */
    private stripeInvalidCharacters;
    /**
     * On *user-interaction* set the value and notify.
     * This function will not call request update, but will fire value-changed event
     * @returns {void}
     */
    private setSilentlyValueAndNotify;
    /**
     * Get the allowed step value
     * @returns allowed step
     */
    private getAllowedValueStep;
    /**
     * Get the step base as per HTML5 specs
     * @returns step base
     */
    private get stepBase();
    /**
     * Count precision number
     * @param number value to count
     * @returns precision number
     */
    private getPrecision;
    /**
     * Check if value subtracted from the step base is not an integral multiple of the allowed value step
     * @param value value to check
     * @returns true if value is integral
     */
    private isValueIntegralMultipleOfStep;
    /**
     * Find the nearest value that, when subtracted from the `stepBase`
     * is an integral multiple of the `allowedValueStep`,
     * and that is less than `value` if the `direction` was `Down`, and more than value otherwise.
     * @param value the value to operate on
     * @param stepBase base to start calculation
     * @param allowedValueStep a step to go Down or Up
     * @param direction Direction, either -1 for Down or 1 for Up
     * @returns nearest number
     */
    private findNearestSteppedValue;
    /**
     * Apply step up or step down on the input
     * @param direction either go up or down
     * @param stepIncrement step increment factor
     * @returns {void}
     */
    private applyStepDirection;
    /**
     * Increases the input value by amount of step
     * @param [stepIncrement] The stepIncrement parameter is a numeric value. If no parameter is passed, stepIncrement defaults to 1.
     * @returns {void}
     */
    stepUp(stepIncrement?: number): void;
    /**
     * Decreases the input value by amount of step
     * @param [stepIncrement] The stepIncrement parameter is a numeric value. If no parameter is passed, stepIncrement defaults to 1.
     * @returns {void}
     */
    stepDown(stepIncrement?: number): void;
    /**
     * Returns whether input of the element should be validated or not based on the existence of validation constraints
     * @returns true if there is at least one validation constraint
     */
    private shouldValidate;
    /**
     * Validate the element input and mark it as error if its input is invalid.
     * @returns `true` if the element input is valid; otherwise, returns `false`.
     */
    reportValidity(): boolean;
    /**
     * Returns `true` if the element input is valid; otherwise, returns `false`.
     * @returns element input validity
     */
    checkValidity(): boolean;
    /**
     * @ignore
     */
    get selectionStart(): number | null;
    /**
     * @ignore
     */
    set selectionStart(index: number | null);
    /**
     * @ignore
     */
    get selectionEnd(): number | null;
    /**
     * @ignore
     */
    set selectionEnd(index: number | null);
    /**
     * @ignore
     */
    get selectionDirection(): SelectionDirection | null;
    /**
     * @ignore
     */
    set selectionDirection(direction: SelectionDirection | null);
    /**
     * @ignore
     */
    setSelectionRange(startSelection: number | null, endSelection: number | null, selectionDirection?: SelectionDirection): void;
    /**
     * Renders spinner
     * @returns {TemplateResult} spinner part template
     */
    protected renderSpinner(): TemplateResult;
    /**
     * Decorate `<input>` element with common properties extended from form field element:
     * type="text" - always `text`
     * part="input" - always "input", used for styling
     * inputmode="decimal" - show decimals keyboard by default
     * role="spinbutton" - number field is actually a spinner
     * aria-valuenow - current value or 0
     * aria-valuetext - current value or 0, need this to improve user-friendly and human-understandable when screen reader announce value
     * @keydown - Listener for `keydown` event. Runs `this.onInputKeyDown`
     * @beforeinput - Listener for `beforeinput` event. Runs `this.onBeforeInputChange`
     * @returns template map
     */
    protected get decorateInputMap(): TemplateMap;
    /**
     * A `TemplateResult` that will be used
     * to render the updated internal template.
     * @return {TemplateResult}  Render template
     */
    protected render(): TemplateResult;
}
declare global {
    interface HTMLElementTagNameMap {
        'ef-number-field': NumberField;
    }
}
export {};

declare global {
  interface HTMLElementTagNameMap {
    'ef-number-field': NumberField;
  }

  namespace JSX {
    interface IntrinsicElements {
      'ef-number-field': Partial<NumberField> | JSXInterface.HTMLAttributes<NumberField>;
    }
  }
}

export {};