@opentiny/vue-renderless 3.12.1 → 3.13.0-alpha.1

package/types/pager.type.d.ts

@@ -1,2 +1,172 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { ISharedRenderlessFunctionParams, ISharedRenderlessParamUtils } from './shared.type.js';
 
-export { }
+declare const pagerProps: {
+    accurateJumper: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    appendToBody: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    currentPage: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    hideOnSinglePage: BooleanConstructor;
+    isBeforePageChange: BooleanConstructor;
+    layout: StringConstructor;
+    mode: StringConstructor;
+    nextText: StringConstructor;
+    pageCount: NumberConstructor;
+    pageSize: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    pageSizes: {
+        type: PropType<number[]>;
+        default: () => number[];
+    };
+    pagerCount: {
+        type: NumberConstructor;
+        validator: (value: any) => boolean;
+        default: () => number;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    showTotalLoading: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    customTotal: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: () => boolean;
+    };
+    popperClass: StringConstructor;
+    prevText: StringConstructor;
+    total: NumberConstructor;
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    align: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    totalFixedLeft: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    tiny_mode: StringConstructor;
+    tiny_mode_root: BooleanConstructor;
+    tiny_template: (FunctionConstructor | ObjectConstructor)[];
+    tiny_renderless: FunctionConstructor;
+    tiny_theme: StringConstructor;
+    tiny_chart_theme: ObjectConstructor;
+};
+
+declare const computedShowPager: ({ props, state }: Pick<IPagerRenderlessParams, 'props' | 'state'>) => () => boolean;
+declare const computedInternalLayout: ({ props }: Pick<IPagerRenderlessParams, 'props'>) => () => string[];
+declare const computedTotalText: ({ props, t }: Pick<IPagerRenderlessParams, 'props' | 't'>) => () => string;
+declare const computedInternalPageCount: ({ props, state }: Pick<IPagerRenderlessParams, 'props' | 'state'>) => () => number | null;
+declare const handleJumperFocus: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (e: Event) => void;
+declare const watchInternalCurrentPage: ({ state, emit }: Pick<IPagerRenderlessParams, 'state' | 'emit'>) => (currentPage: number) => void;
+declare const watchPageSizes: ({ state, props }: Pick<IPagerRenderlessParams, 'props' | 'state'>) => (newVal: number[]) => void;
+declare const watchCurrentPage: ({ state, api }: Pick<IPagerRenderlessParams, 'api' | 'state'>) => (curPage: number) => void;
+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;
+declare const handleJumperClick: ({ props, state, api }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api'>) => () => void;
+declare const isValueNumber: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => () => boolean;
+declare const parseValueNumber: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => () => void;
+declare const handleSizeShowPopover: ({ state, props }: Pick<IPagerRenderlessParams, 'props' | 'state'>) => () => void;
+declare const handleSizeHidePopover: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => () => void;
+declare const canJumperGo: ({ props, state, vm }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'vm'>) => () => boolean;
+declare const beforeSizeChangeHandler: ({ state, emit }: Pick<IPagerRenderlessParams, 'emit' | 'state'>) => (params: any) => void;
+declare const beforePagerChangeHandler: ({ state, emit }: Pick<IPagerRenderlessParams, 'emit' | 'state'>) => (params: any) => void;
+declare const copyEmit: ({ emit }: Pick<IPagerRenderlessParams, 'emit'>) => (...args: any[]) => void;
+declare const beforeChangeHandler: ({ state, api }: Pick<IPagerRenderlessParams, 'api' | 'state'>) => (val?: number) => boolean;
+declare const handleCurrentChange: ({ state, api }: Pick<IPagerRenderlessParams, 'api' | 'state'>) => (val: number) => void;
+declare const prev: ({ state, props, api, emit }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api' | 'emit'>) => () => void;
+declare const next: ({ props, state, api, emit }: Pick<IPagerRenderlessParams, 'props' | 'state' | 'api' | 'emit'>) => () => void;
+declare const buildBeforePageChangeParam: ({ state }: Pick<IPagerRenderlessParams, 'state'>) => (param: any) => any;
+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 {
+    showPager: boolean;
+    showSizes: boolean;
+    internalCurrentPage: number;
+    internalPageSize: number;
+    lastEmittedPage: number;
+    userChangePageSize: boolean;
+    internalTotal: number | undefined;
+    jumperValue: string;
+    jumperBackup: string;
+    internalLayout: string[];
+    totalText: string;
+    internalPageCount: number | null;
+    showJumperSufix: boolean;
+    align: 'left' | 'center' | 'right';
+    totalI18n: 'total' | 'totals';
+    totalFixedLeft: boolean;
+}
+interface IPagerApi {
+    state: IPagerState;
+    t: IPagerRenderlessParamUtils['t'];
+    computedShowPager: ReturnType<typeof computedShowPager>;
+    computedInternalLayout: ReturnType<typeof computedInternalLayout>;
+    computedTotalText: ReturnType<typeof computedTotalText>;
+    computedInternalPageCount: ReturnType<typeof computedInternalPageCount>;
+    handleJumperFocus: ReturnType<typeof handleJumperFocus>;
+    handleSizeChange: ReturnType<typeof handleSizeChange>;
+    handleJumperInput: ReturnType<typeof handleJumperInput>;
+    handleJumperChange: ReturnType<typeof handleJumperChange>;
+    handleJumperClick: ReturnType<typeof handleJumperClick>;
+    isValueNumber: ReturnType<typeof isValueNumber>;
+    parseValueNumber: ReturnType<typeof parseValueNumber>;
+    handleSizeShowPopover: ReturnType<typeof handleSizeShowPopover>;
+    handleSizeHidePopover: ReturnType<typeof handleSizeHidePopover>;
+    canJumperGo: ReturnType<typeof canJumperGo>;
+    beforeSizeChangeHandler: ReturnType<typeof beforeSizeChangeHandler>;
+    beforePagerChangeHandler: ReturnType<typeof beforePagerChangeHandler>;
+    copyEmit: ReturnType<typeof copyEmit>;
+    beforeChangeHandler: ReturnType<typeof beforeChangeHandler>;
+    handleCurrentChange: ReturnType<typeof handleCurrentChange>;
+    prev: ReturnType<typeof prev>;
+    next: ReturnType<typeof next>;
+    buildBeforePageChangeParam: ReturnType<typeof buildBeforePageChangeParam>;
+    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;
+    state: IPagerState;
+    props: IPagerProps;
+};
+type IPagerRenderlessParamUtils = ISharedRenderlessParamUtils<never>;
+
+export { IPagerApi, IPagerProps, IPagerRenderlessParamUtils, IPagerRenderlessParams, IPagerState };

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,15 @@ declare const pickerProps: {
         default: boolean;
     };
     formatWeeks: FunctionConstructor;
+    autoFormat: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: StringConstructor;
+    blank: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 };
 
 type IPickerProps = ExtractPropTypes<typeof pickerProps>;

package/types/popconfirm.type.d.ts

@@ -1,2 +1,86 @@
+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;
+    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/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 };