@opentiny/vue-renderless 3.13.2 → 3.14.1

package/types/numeric.type.d.ts

@@ -34,6 +34,7 @@ declare const $constants: {
         change: string;
     };
     COMPONENT_NAME: string;
+    FILTER_OPTION: string[];
 };
 declare const numericProps: {
     _constants: {
@@ -50,6 +51,7 @@ declare const numericProps: {
                 change: string;
             };
             COMPONENT_NAME: string;
+            FILTER_OPTION: string[];
         };
     };
     allowEmpty: {
@@ -140,6 +142,28 @@ declare const numericProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    tip: StringConstructor;
+    shape: StringConstructor;
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    filter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    blank: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    changeCompat: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];
@@ -165,7 +189,7 @@ declare const initService: (service: INumericRenderlessParamUtils['service']) =>
     getNumberFormat: Function;
 };
 declare const getDecimal: (props: INumericProps) => (value: number) => BigIntDecimal;
-declare const watchValue: ({ api, state, nextTick }: Pick<INumericRenderlessParams, 'api' | 'state' | 'nextTick'>) => (value: number) => void;
+declare const watchValue: ({ api, props, state, nextTick }: Pick<INumericRenderlessParams, 'api' | 'state' | 'nextTick' | 'props'>) => (value: number) => void;
 declare const toPrecision: (state: INumericState) => ({ num, precision }: {
     num: number;
     precision: number;
@@ -182,28 +206,32 @@ declare const internalDecrease: ({ api, state }: Pick<INumericRenderlessParams,
 declare const increase: ({ api, props, state }: Pick<INumericRenderlessParams, 'api' | 'props' | 'state'>) => () => void;
 declare const decrease: ({ api, props, state }: Pick<INumericRenderlessParams, 'api' | 'props' | 'state'>) => () => void;
 declare const handleBlur: ({ constants, dispatch, emit, props, state, api }: Pick<INumericRenderlessParams, 'constants' | 'dispatch' | 'emit' | 'props' | 'state' | 'api'>) => (event: FocusEvent) => void;
-declare const handleFocus: ({ emit, state, props, api, refs }: Pick<INumericRenderlessParams, 'emit' | 'state' | 'props' | 'api' | 'refs'>) => (event: FocusEvent) => void;
-declare const focus: (refs: INumericRenderlessParams['refs']) => () => void;
-declare const setCurrentValue: ({ api, constants, dispatch, emit, props, state }: Pick<INumericRenderlessParams, 'api' | 'constants' | 'dispatch' | 'emit' | 'props' | 'state'>) => (newVal: number) => void;
+declare const handleFocus: ({ emit, state, props, api, vm }: Pick<INumericRenderlessParams, 'emit' | 'state' | 'props' | 'api' | 'vm'>) => (event: FocusEvent) => void;
+declare const focus: (vm: INumericRenderlessParams['vm']) => () => void;
+declare const setCurrentValue: ({ api, constants, dispatch, emit, props, state }: Pick<INumericRenderlessParams, 'api' | 'constants' | 'dispatch' | 'emit' | 'props' | 'state'>) => (newVal: number, emitChangeFlag?: boolean) => void;
 declare const handleInput: ({ state, api, emit, props }: Pick<INumericRenderlessParams, 'state' | 'api' | 'emit' | 'props'>) => (event: InputEvent) => void;
 declare const handleInputChange: ({ api, state, props }: Pick<INumericRenderlessParams, 'api' | 'state' | 'props'>) => (event: Event) => void;
-declare const select: (refs: INumericRenderlessParams['refs']) => () => any;
+declare const select: (vm: INumericRenderlessParams['vm']) => () => any;
 declare const mounted: ({ constants, parent, props, state }: Pick<INumericRenderlessParams, 'constants' | 'parent' | 'props' | 'state'>) => () => void;
 declare const unmounted: ({ parent, state }: Pick<INumericRenderlessParams, 'parent' | 'state'>) => () => void;
 declare const updated: ({ constants, parent, state }: Pick<INumericRenderlessParams, 'constants' | 'parent' | 'state'>) => () => void;
-declare const displayValue: ({ props, state }: Pick<INumericRenderlessParams, 'props' | 'state'>) => () => string | number;
+declare const displayValue: ({ props, state, api }: Pick<INumericRenderlessParams, 'props' | 'state' | 'api'>) => () => string | number;
 declare const getNumPecision: ({ api, props }: Pick<INumericRenderlessParams, 'api' | 'props'>) => () => number;
 declare const mouseEvent: ({ api, props, state }: Pick<INumericRenderlessParams, 'api' | 'props' | 'state'>) => (event: MouseEvent) => void | boolean;
 declare const dispatchDisplayedValue: ({ state, api, dispatch }: Pick<INumericRenderlessParams, 'state' | 'api' | 'dispatch'>) => () => void;
 declare const getDisplayedValue: ({ state, props }: Pick<INumericRenderlessParams, 'state' | 'props'>) => () => string;
 declare const getDisplayOnlyText: ({ parent, state, props }: Pick<INumericRenderlessParams, 'parent' | 'state' | 'props'>) => () => string | number;
+declare const filterValue: ({ state }: Pick<INumericRenderlessParams, 'state'>) => () => number | string;
+declare const handleClear: ({ state, emit }: Pick<INumericRenderlessParams, 'state' | 'emit'>) => () => void;
+declare const handleChange: ({ state, emit }: Pick<INumericRenderlessParams, 'state' | 'emit'>) => () => void;
 
 type INumericProps = ExtractPropTypes<typeof numericProps>;
 type INumericConstants = typeof $constants;
 interface INumericState {
-    currentValue: number;
-    userInput: number;
-    lastInput: number;
+    radioVal: string;
+    currentValue: number | string;
+    userInput: number | string;
+    lastInput: number | string;
     inputStatus: boolean;
     decimal: BigIntDecimal;
     strictInput: boolean;
@@ -244,6 +272,9 @@ interface INumericApi {
     dispatchDisplayedValue: ReturnType<typeof dispatchDisplayedValue>;
     getDisplayedValue: ReturnType<typeof getDisplayedValue>;
     getDisplayOnlyText: ReturnType<typeof getDisplayOnlyText>;
+    filterValue: ReturnType<typeof filterValue>;
+    handleClear: ReturnType<typeof handleClear>;
+    handleChange: ReturnType<typeof handleChange>;
 }
 type INumericRenderlessParams = ISharedRenderlessFunctionParams<INumericConstants> & {
     api: INumericApi;
@@ -259,7 +290,7 @@ interface INumericUnitPrecision {
     rounding?: string;
     zeroize: boolean;
 }
-interface INumericInitStateParams extends Pick<INumericRenderlessParams, 'reactive' | 'computed' | 'props' | 'api' | 'parent'> {
+interface INumericInitStateParams extends Pick<INumericRenderlessParams, 'constants' | 'reactive' | 'computed' | 'props' | 'api' | 'parent'> {
     $service: ReturnType<typeof initService>;
 }
 interface INumericGetEmitValueParams {

package/types/pager.type.d.ts

@@ -60,6 +60,10 @@ declare const pagerProps: {
         type: StringConstructor;
         validator: (value: any) => boolean;
     };
+    totalFixedLeft: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];
@@ -79,6 +83,7 @@ declare const watchCurrentPage: ({ state, api }: Pick<IPagerRenderlessParams, 'a
 declare const watchInternalPageCount: ({ state, api }: Pick<IPagerRenderlessParams, 'api' | 'state'>) => (pageCount: number | null) => void;
 declare const watchPageSize: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (pageSize: number) => void;
 declare const watchTotal: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (total: number | undefined) => void;
+declare const watchShowSizes: ({ nextTick, vm }: Pick<IPagerRenderlessParams, 'nextTick' | 'vm'>) => (newVal: boolean) => void;
 declare const handleSizeChange: ({ props, state, api, emit, vm }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api' | 'emit' | 'vm'>) => (val: number) => void;
 declare const handleJumperInput: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (e: Event) => void;
 declare const handleJumperChange: ({ props, state, api }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api'>) => () => void;
@@ -99,6 +104,7 @@ declare const buildBeforePageChangeParam: ({ state }: Pick<IPagerRenderlessParam
 declare const getValidCurrentPage: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (val: string | number) => any;
 declare const emitChange: ({ state, nextTick, emit }: Pick<IPagerRenderlessParams, 'emit' | 'state' | 'nextTick'>) => () => void;
 declare const setTotal: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (val: number) => void;
+declare const clickSizes: () => (e: Event) => void;
 
 type IPagerProps = ExtractPropTypes<typeof pagerProps>;
 interface IPagerState {
@@ -114,6 +120,10 @@ interface IPagerState {
     internalLayout: string[];
     totalText: string;
     internalPageCount: number | null;
+    showJumperSufix: boolean;
+    align: 'left' | 'center' | 'right';
+    totalI18n: 'total' | 'totals';
+    totalFixedLeft: boolean;
 }
 interface IPagerApi {
     state: IPagerState;
@@ -143,12 +153,14 @@ interface IPagerApi {
     getValidCurrentPage: ReturnType<typeof getValidCurrentPage>;
     emitChange: ReturnType<typeof emitChange>;
     setTotal: ReturnType<typeof setTotal>;
+    clickSizes: ReturnType<typeof clickSizes>;
     watchInternalCurrentPage: ReturnType<typeof watchInternalCurrentPage>;
     watchPageSizes: ReturnType<typeof watchPageSizes>;
     watchCurrentPage: ReturnType<typeof watchCurrentPage>;
     watchInternalPageCount: ReturnType<typeof watchInternalPageCount>;
     watchPageSize: ReturnType<typeof watchPageSize>;
     watchTotal: ReturnType<typeof watchTotal>;
+    watchShowSizes: ReturnType<typeof watchShowSizes>;
 }
 type IPagerRenderlessParams = ISharedRenderlessFunctionParams<never> & {
     api: IPagerApi;

package/types/picker.type.d.ts

@@ -43,6 +43,10 @@ declare const pickerProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    changeOnConfirm: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     disabled: BooleanConstructor;
     id: {
         default: string;
@@ -88,6 +92,7 @@ declare const pickerProps: {
     };
     dbTimezone: NumberConstructor;
     timezone: NumberConstructor;
+    timezoneOffset: NumberConstructor;
     iso8601: BooleanConstructor;
     displayOnly: {
         type: BooleanConstructor;
@@ -106,6 +111,19 @@ declare const pickerProps: {
         default: boolean;
     };
     formatWeeks: FunctionConstructor;
+    autoFormat: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: StringConstructor;
+    blank: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    changeCompat: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 };
 
 type IPickerProps = ExtractPropTypes<typeof pickerProps>;

package/types/popconfirm.type.d.ts

@@ -1,2 +1,87 @@
+import { ExtractPropTypes } from 'vue';
+import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.js';
 
-export { }
+declare const $constants: {
+    PC_PREFIXCLS: string;
+    MOBILE_PREFIXCLS: string;
+    Mode: string;
+    prefixcls(mode: any): any;
+    ICON_MAP: {
+        success: string;
+        error: string;
+        info: string;
+        warning: string;
+    };
+};
+declare const popConfirmProps: {
+    _constants: {
+        type: ObjectConstructor;
+        default: () => {
+            PC_PREFIXCLS: string;
+            MOBILE_PREFIXCLS: string;
+            Mode: string;
+            prefixcls(mode: any): any;
+            ICON_MAP: {
+                success: string;
+                error: string;
+                info: string;
+                warning: string;
+            };
+        };
+    };
+    message: StringConstructor;
+    customClass: StringConstructor;
+    popperOptions: ObjectConstructor;
+    trigger: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    cancelButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: StringConstructor;
+    placement: {
+        type: StringConstructor;
+        default: string;
+    };
+    width: (StringConstructor | NumberConstructor)[];
+    type: (StringConstructor | ObjectConstructor)[];
+    reference: {};
+    events: ObjectConstructor;
+    tiny_mode: StringConstructor;
+    tiny_mode_root: BooleanConstructor;
+    tiny_template: (FunctionConstructor | ObjectConstructor)[];
+    tiny_renderless: FunctionConstructor;
+    tiny_theme: StringConstructor;
+    tiny_chart_theme: ObjectConstructor;
+};
+
+declare const hide: ({ state, emit }: Pick<IPopconfirmRenderlessParams, 'state' | 'emit'>) => () => void;
+declare const show: ({ state, props, emit }: Pick<IPopconfirmRenderlessParams, 'state' | 'props' | 'emit'>) => (trigger: any) => void;
+declare const confirm: ({ state, api }: Pick<IPopconfirmRenderlessParams, 'state' | 'api'>) => () => void;
+declare const handleEmit: ({ state, emit, vm }: Pick<IPopconfirmRenderlessParams, 'state' | 'emit' | 'vm'>) => (type: any) => void;
+
+interface IPopconfirmState {
+    isLock: boolean;
+    showPopover: boolean;
+    getIcon: string;
+}
+type IPopconfirmProps = ExtractPropTypes<typeof popConfirmProps>;
+type IPopconfirmConstants = typeof $constants;
+type IPopconfirmRenderlessParams = ISharedRenderlessFunctionParams<IPopconfirmConstants> & {
+    api: IPopconfirmApi;
+    state: IPopconfirmState;
+    props: IPopconfirmProps;
+};
+interface IPopconfirmApi {
+    state: IPopconfirmState;
+    show: ReturnType<typeof show>;
+    hide: ReturnType<typeof hide>;
+    confirm: ReturnType<typeof confirm>;
+    handleEmit: ReturnType<typeof handleEmit>;
+}
+type IPopconfirmRenderlessParamUtils = ISharedRenderlessParamUtils<IPopconfirmConstants>;
+
+export { IPopconfirmApi, IPopconfirmConstants, IPopconfirmProps, IPopconfirmRenderlessParamUtils, IPopconfirmRenderlessParams, IPopconfirmState };

package/types/popeditor.type.d.ts

@@ -212,6 +212,10 @@ declare const popeditorProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    radioChangeClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     tiny_mode: StringConstructor;
     tiny_mode_root: BooleanConstructor;
     tiny_template: (FunctionConstructor | ObjectConstructor)[];

package/types/popover.type.d.ts

@@ -92,7 +92,7 @@ declare const popoverProps: {
  *
  */
 
-declare const mounted: ({ api, state, constants, props, nextTick, mode }: Pick<IPopoverRenderlessParams, "state" | "api" | "props" | "nextTick" | "mode"> & {
+declare const mounted: ({ api, state, constants, props, nextTick, mode }: Pick<IPopoverRenderlessParams, "state" | "props" | "nextTick" | "api" | "mode"> & {
     constants: {
         IDPREFIX: string;
     };
@@ -106,7 +106,7 @@ declare const handleBlur: ({ props, state }: Pick<IPopoverRenderlessParams, 'sta
 declare const handleMouseEnter: ({ props, state }: Pick<IPopoverRenderlessParams, 'state' | 'props'>) => () => void;
 declare const handleKeydown: ({ api, props }: Pick<IPopoverRenderlessParams, 'api' | 'props'>) => (event: KeyboardEvent) => void;
 declare const handleMouseLeave: ({ props, state }: Pick<IPopoverRenderlessParams, 'state' | 'props'>) => () => void;
-declare const handleDocumentClick: ({ refs, state }: Pick<IPopoverRenderlessParams, 'state' | 'refs'>) => (event: MouseEvent) => void;
+declare const handleDocumentClick: ({ vm, state }: Pick<IPopoverRenderlessParams, 'state' | 'vm'>) => (event: MouseEvent) => void;
 declare const handleAfterEnter: (emit: IPopoverRenderlessParams['emit']) => () => void;
 declare const handleAfterLeave: (emit: IPopoverRenderlessParams['emit']) => () => void;
 /** mobile.vue中，给listData项的点击事件 */
@@ -116,7 +116,7 @@ declare const destroyed: ({ state, api }: Pick<IPopoverRenderlessParams, 'state'
 declare const computedTooltipId: (constants: {
     IDPREFIX: string;
 }) => () => string;
-declare const wrapMounted: ({ api, props, refs, state }: Pick<IPopoverRenderlessParams, 'state' | 'api' | 'props' | 'refs'>) => () => void;
+declare const wrapMounted: ({ api, props, vm, state }: Pick<IPopoverRenderlessParams, 'state' | 'api' | 'props' | 'vm'>) => () => void;
 declare const observeCallback: ({ state, vm }: Pick<IPopoverRenderlessParams, 'state' | 'vm'>) => (mutationsList: any) => void;
 
 type IPopoverProps = ExtractPropTypes<typeof popoverProps>;

package/types/progress.type.d.ts

@@ -18,6 +18,7 @@ declare const $constants: {
         LARGE: number;
     };
     PROGRESS_STATUS: {
+        DEFAULT: string;
         SUCCESS: string;
         EXCEPTION: string;
         WARNING: string;
@@ -64,6 +65,7 @@ declare const progressProps: {
                 LARGE: number;
             };
             PROGRESS_STATUS: {
+                DEFAULT: string;
                 SUCCESS: string;
                 EXCEPTION: string;
                 WARNING: string;

package/types/radio.type.d.ts

@@ -61,8 +61,6 @@ declare const isDisplayOnly: ({ props }: Pick<IRadioRenderlessParams, 'props'>)
 declare const tabIndex: ({ props, state }: Pick<IRadioRenderlessParams, 'props' | 'state'>) => () => number;
 declare const getModel: ({ props, state }: Pick<IRadioRenderlessParams, 'props' | 'state'>) => () => IRadioState['model'];
 declare const setModel: ({ constants, dispatch, emit, props, vm, state }: Pick<IRadioRenderlessParams, 'constants' | 'dispatch' | 'emit' | 'props' | 'vm' | 'state'>) => (val: IRadioState['model']) => void;
-declare const dispatchDisplayedValue: ({ state, dispatch, api }: Pick<IRadioRenderlessParams, 'state' | 'dispatch' | 'api'>) => () => void;
-declare const getDisplayedValue: ({ vm, state, props }: Pick<IRadioRenderlessParams, 'vm' | 'props' | 'state'>) => () => string;
 
 type IRadioProps = ExtractPropTypes<typeof radioProps>;
 type IRadioConstants = typeof $constants;
@@ -95,8 +93,6 @@ interface IRadioApi {
     tabIndex: ReturnType<typeof tabIndex>;
     getModel: ReturnType<typeof getModel>;
     setModel: ReturnType<typeof setModel>;
-    dispatchDisplayedValue: ReturnType<typeof dispatchDisplayedValue>;
-    getDisplayedValue: ReturnType<typeof getDisplayedValue>;
 }
 type IRadioRenderlessParamUtils = ISharedRenderlessParamUtils<IRadioConstants>;
 

package/types/rate.type.d.ts

@@ -1,2 +1,237 @@
+import { ExtractPropTypes } from 'vue';
+import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.js';
 
-export { }
+declare const $constants: {
+    RATENODECLS: string;
+    ICON_PREFIXCLS: string;
+    DECIMALCLS: string;
+};
+declare const rateProps: {
+    _constants: {
+        type: ObjectConstructor;
+        default: () => {
+            RATENODECLS: string;
+            ICON_PREFIXCLS: string;
+            DECIMALCLS: string;
+        };
+    };
+    allowHalf: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colors: {
+        type: ArrayConstructor;
+        default: () => string[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabledVoidColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabledVoidIconClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    highThreshold: {
+        type: NumberConstructor;
+        default: number;
+    };
+    iconClasses: {
+        type: ArrayConstructor;
+        default: () => string[];
+    };
+    lowThreshold: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    radio: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scoreTemplate: {
+        type: StringConstructor;
+        default: string;
+    };
+    showScore: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    space: {
+        type: StringConstructor;
+        default: string;
+    };
+    textColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    textOnBottom: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    texts: {
+        type: ArrayConstructor;
+        default: () => any[];
+    };
+    voidColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    voidIconClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    tiny_mode: StringConstructor;
+    tiny_mode_root: BooleanConstructor;
+    tiny_template: (FunctionConstructor | ObjectConstructor)[];
+    tiny_renderless: FunctionConstructor;
+    tiny_theme: StringConstructor;
+    tiny_chart_theme: ObjectConstructor;
+};
+
+/**
+ * Copyright (c) 2022 - present TinyVue Authors.
+ * Copyright (c) 2022 - present Huawei Cloud Computing Technologies Co., Ltd.
+ *
+ * Use of this source code is governed by an MIT-style license.
+ *
+ * THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
+ * BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR
+ * A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+ *
+ */
+
+declare const computedActiveColor: (props: IRateProps) => (state: IRateState) => string;
+declare const computedActiveClass: (props: IRateProps) => (state: IRateState) => string;
+declare const getTextStyle: ({ props, state }: {
+    props: any;
+    state: any;
+}) => () => {
+    color: any;
+};
+declare const handelKey: ({ emit, props, state }: {
+    emit: any;
+    props: any;
+    state: any;
+}) => (event: any) => void;
+declare const selectValue: ({ emit, props, state }: {
+    emit: any;
+    props: any;
+    state: any;
+}) => (value: any) => void;
+declare const setCurrentValue: ({ constants: { RATENODECLS, DECIMALCLS, ICON_PREFIXCLS }, props, state, parent, api }: {
+    constants: {
+        RATENODECLS: any;
+        DECIMALCLS: any;
+        ICON_PREFIXCLS: any;
+    };
+    props: any;
+    state: any;
+    parent: any;
+    api: any;
+}) => ({ event, item }: {
+    event: any;
+    item: any;
+}) => void;
+declare const resetCurrentValue: ({ props, state }: {
+    props: any;
+    state: any;
+}) => () => void;
+declare const showDecimalIcon: ({ props, state }: {
+    props: any;
+    state: any;
+}) => (item: any) => any;
+declare const getIconStyle: ({ api, props, state }: {
+    api: any;
+    props: any;
+    state: any;
+}) => (item: any) => {
+    fill: any;
+    'font-size': any;
+};
+declare const computedText: ({ props, state }: Pick<IRateRenderlessParams, 'props' | 'state'>) => string;
+declare const computedDecimalStyle: ({ props, state }: Pick<IRateRenderlessParams, 'props' | 'state'>) => {
+    fill: string;
+    width: string;
+    clip: string;
+    clipPath: string;
+    fontSize: string;
+};
+declare const computedClasses: ({ props, state }: Pick<IRateRenderlessParams, 'props' | 'state'>) => string[];
+declare const computedClassMap: (props: IRateProps) => {
+    lowClass: unknown;
+    mediumClass: unknown;
+    highClass: unknown;
+    voidClass: string;
+    disabledVoidClass: string;
+};
+declare const computedColorMap: (props: IRateProps) => {
+    lowColor: unknown;
+    mediumColor: unknown;
+    highColor: unknown;
+    voidColor: string;
+    disabledVoidColor: string;
+};
+declare const computedVoidClass: ({ props, state }: Pick<IRateRenderlessParams, 'props' | 'state'>) => string;
+
+interface IRateState {
+    pointerAtLeftHalf: boolean;
+    colorMap: ReturnType<typeof computedColorMap>;
+    classMap: ReturnType<typeof computedClassMap>;
+    text: ReturnType<typeof computedText>;
+    activeClass: string;
+    activeColor: string;
+    classes: ReturnType<typeof computedClasses>;
+    decimalIconClass: string;
+    voidClass: ReturnType<typeof computedVoidClass>;
+    decimalStyle: ReturnType<typeof computedDecimalStyle>;
+    hoverIndex: number;
+    currentValue: number;
+    mouseTarget: null | HTMLElement;
+}
+type IRateProps = ExtractPropTypes<typeof rateProps>;
+type IRateConstants = typeof $constants;
+type IRateRenderlessParams = ISharedRenderlessFunctionParams<IRateConstants> & {
+    api: IRateApi;
+    state: IRateState;
+    props: IRateProps;
+};
+interface IRateApi {
+    state: IRateState;
+    computedText: typeof computedText;
+    computedClasses: typeof computedClasses;
+    computedClassMap: typeof computedClassMap;
+    computedColorMap: typeof computedColorMap;
+    computedVoidClass: typeof computedVoidClass;
+    computedDecimalStyle: typeof computedDecimalStyle;
+    getTextStyle: ReturnType<typeof getTextStyle>;
+    handelKey: ReturnType<typeof handelKey>;
+    computedActiveColor: ReturnType<typeof computedActiveColor>;
+    computedActiveClass: ReturnType<typeof computedActiveClass>;
+    showDecimalIcon: ReturnType<typeof showDecimalIcon>;
+    getIconStyle: ReturnType<typeof getIconStyle>;
+    selectValue: ReturnType<typeof selectValue>;
+    resetCurrentValue: ReturnType<typeof resetCurrentValue>;
+    setCurrentValue: ReturnType<typeof setCurrentValue>;
+}
+type IRateRenderlessParamUtils = ISharedRenderlessParamUtils<IRateConstants>;
+
+export { IRateApi, IRateConstants, IRateProps, IRateRenderlessParamUtils, IRateRenderlessParams, IRateState };