@hantera/design-system 0.0.0

package/dist/components/DecimalInput.stories.d.ts

@@ -0,0 +1,1033 @@
+import { Decimal } from 'decimal.js';
+declare const _default: {
+    title: string;
+    component: import('vue').DefineComponent<{
+        modelValue?: import('./DecimalInputValue').DecimalInputValue;
+        name?: string;
+        selectOnFocus?: boolean;
+        disabled?: boolean;
+        maxValue?: Decimal | number;
+        minValue?: Decimal | number;
+        allowPercentage?: boolean;
+    }, {
+        setError: (message?: string) => void;
+        focus: () => void;
+        select: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        blur: (value: Event) => any;
+        change: () => any;
+        focus: (value: Event) => any;
+        keydown: (value: KeyboardEvent) => any;
+        keypress: (value: KeyboardEvent) => any;
+        keyenter: (value: KeyboardEvent) => any;
+        "update:modelValue": (value: import('./DecimalInputValue').DecimalInputValue) => any;
+    }, string, import('vue').PublicProps, Readonly<{
+        modelValue?: import('./DecimalInputValue').DecimalInputValue;
+        name?: string;
+        selectOnFocus?: boolean;
+        disabled?: boolean;
+        maxValue?: Decimal | number;
+        minValue?: Decimal | number;
+        allowPercentage?: boolean;
+    }> & Readonly<{
+        onBlur?: ((value: Event) => any) | undefined;
+        onChange?: (() => any) | undefined;
+        onFocus?: ((value: Event) => any) | undefined;
+        onKeydown?: ((value: KeyboardEvent) => any) | undefined;
+        onKeypress?: ((value: KeyboardEvent) => any) | undefined;
+        onKeyenter?: ((value: KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./DecimalInputValue').DecimalInputValue) => any) | undefined;
+    }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+};
+export default _default;
+export declare const Regular: any;
+export declare const MinValue: (args: any) => {
+    components: {
+        DecimalInput: import('vue').DefineComponent<{
+            modelValue?: import('./DecimalInputValue').DecimalInputValue;
+            name?: string;
+            selectOnFocus?: boolean;
+            disabled?: boolean;
+            maxValue?: Decimal | number;
+            minValue?: Decimal | number;
+            allowPercentage?: boolean;
+        }, {
+            setError: (message?: string) => void;
+            focus: () => void;
+            select: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            blur: (value: Event) => any;
+            change: () => any;
+            focus: (value: Event) => any;
+            keydown: (value: KeyboardEvent) => any;
+            keypress: (value: KeyboardEvent) => any;
+            keyenter: (value: KeyboardEvent) => any;
+            "update:modelValue": (value: import('./DecimalInputValue').DecimalInputValue) => any;
+        }, string, import('vue').PublicProps, Readonly<{
+            modelValue?: import('./DecimalInputValue').DecimalInputValue;
+            name?: string;
+            selectOnFocus?: boolean;
+            disabled?: boolean;
+            maxValue?: Decimal | number;
+            minValue?: Decimal | number;
+            allowPercentage?: boolean;
+        }> & Readonly<{
+            onBlur?: ((value: Event) => any) | undefined;
+            onChange?: (() => any) | undefined;
+            onFocus?: ((value: Event) => any) | undefined;
+            onKeydown?: ((value: KeyboardEvent) => any) | undefined;
+            onKeypress?: ((value: KeyboardEvent) => any) | undefined;
+            onKeyenter?: ((value: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: import('./DecimalInputValue').DecimalInputValue) => any) | undefined;
+        }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    };
+    setup(): {
+        value: import('vue').Ref<{
+            value: {
+                readonly d: number[];
+                readonly e: number;
+                readonly s: number;
+                absoluteValue: () => Decimal;
+                abs: () => Decimal;
+                ceil: () => Decimal;
+                clampedTo: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                clamp: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                comparedTo: (n: Decimal.Value) => number;
+                cmp: (n: Decimal.Value) => number;
+                cosine: () => Decimal;
+                cos: () => Decimal;
+                cubeRoot: () => Decimal;
+                cbrt: () => Decimal;
+                decimalPlaces: () => number;
+                dp: () => number;
+                dividedBy: (n: Decimal.Value) => Decimal;
+                div: (n: Decimal.Value) => Decimal;
+                dividedToIntegerBy: (n: Decimal.Value) => Decimal;
+                divToInt: (n: Decimal.Value) => Decimal;
+                equals: (n: Decimal.Value) => boolean;
+                eq: (n: Decimal.Value) => boolean;
+                floor: () => Decimal;
+                greaterThan: (n: Decimal.Value) => boolean;
+                gt: (n: Decimal.Value) => boolean;
+                greaterThanOrEqualTo: (n: Decimal.Value) => boolean;
+                gte: (n: Decimal.Value) => boolean;
+                hyperbolicCosine: () => Decimal;
+                cosh: () => Decimal;
+                hyperbolicSine: () => Decimal;
+                sinh: () => Decimal;
+                hyperbolicTangent: () => Decimal;
+                tanh: () => Decimal;
+                inverseCosine: () => Decimal;
+                acos: () => Decimal;
+                inverseHyperbolicCosine: () => Decimal;
+                acosh: () => Decimal;
+                inverseHyperbolicSine: () => Decimal;
+                asinh: () => Decimal;
+                inverseHyperbolicTangent: () => Decimal;
+                atanh: () => Decimal;
+                inverseSine: () => Decimal;
+                asin: () => Decimal;
+                inverseTangent: () => Decimal;
+                atan: () => Decimal;
+                isFinite: () => boolean;
+                isInteger: () => boolean;
+                isInt: () => boolean;
+                isNaN: () => boolean;
+                isNegative: () => boolean;
+                isNeg: () => boolean;
+                isPositive: () => boolean;
+                isPos: () => boolean;
+                isZero: () => boolean;
+                lessThan: (n: Decimal.Value) => boolean;
+                lt: (n: Decimal.Value) => boolean;
+                lessThanOrEqualTo: (n: Decimal.Value) => boolean;
+                lte: (n: Decimal.Value) => boolean;
+                logarithm: (n?: Decimal.Value) => Decimal;
+                log: (n?: Decimal.Value) => Decimal;
+                minus: (n: Decimal.Value) => Decimal;
+                sub: (n: Decimal.Value) => Decimal;
+                modulo: (n: Decimal.Value) => Decimal;
+                mod: (n: Decimal.Value) => Decimal;
+                naturalExponential: () => Decimal;
+                exp: () => Decimal;
+                naturalLogarithm: () => Decimal;
+                ln: () => Decimal;
+                negated: () => Decimal;
+                neg: () => Decimal;
+                plus: (n: Decimal.Value) => Decimal;
+                add: (n: Decimal.Value) => Decimal;
+                precision: (includeZeros?: boolean) => number;
+                sd: (includeZeros?: boolean) => number;
+                round: () => Decimal;
+                sine: () => Decimal;
+                sin: () => Decimal;
+                squareRoot: () => Decimal;
+                sqrt: () => Decimal;
+                tangent: () => Decimal;
+                tan: () => Decimal;
+                times: (n: Decimal.Value) => Decimal;
+                mul: (n: Decimal.Value) => Decimal;
+                toBinary: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toDecimalPlaces: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toDP: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toExponential: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFixed: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFraction: (max_denominator?: Decimal.Value) => Decimal[];
+                toHexadecimal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toHex: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding?: Decimal.Rounding): string;
+                };
+                toJSON: () => string;
+                toNearest: (n: Decimal.Value, rounding?: Decimal.Rounding) => Decimal;
+                toNumber: () => number;
+                toOctal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toPower: (n: Decimal.Value) => Decimal;
+                pow: (n: Decimal.Value) => Decimal;
+                toPrecision: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toSignificantDigits: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toSD: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toString: () => string;
+                truncated: () => Decimal;
+                trunc: () => Decimal;
+                valueOf: () => string;
+            };
+            isPercentage: boolean;
+        }, {
+            value: Decimal;
+            isPercentage: boolean;
+        } | {
+            value: {
+                readonly d: number[];
+                readonly e: number;
+                readonly s: number;
+                absoluteValue: () => Decimal;
+                abs: () => Decimal;
+                ceil: () => Decimal;
+                clampedTo: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                clamp: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                comparedTo: (n: Decimal.Value) => number;
+                cmp: (n: Decimal.Value) => number;
+                cosine: () => Decimal;
+                cos: () => Decimal;
+                cubeRoot: () => Decimal;
+                cbrt: () => Decimal;
+                decimalPlaces: () => number;
+                dp: () => number;
+                dividedBy: (n: Decimal.Value) => Decimal;
+                div: (n: Decimal.Value) => Decimal;
+                dividedToIntegerBy: (n: Decimal.Value) => Decimal;
+                divToInt: (n: Decimal.Value) => Decimal;
+                equals: (n: Decimal.Value) => boolean;
+                eq: (n: Decimal.Value) => boolean;
+                floor: () => Decimal;
+                greaterThan: (n: Decimal.Value) => boolean;
+                gt: (n: Decimal.Value) => boolean;
+                greaterThanOrEqualTo: (n: Decimal.Value) => boolean;
+                gte: (n: Decimal.Value) => boolean;
+                hyperbolicCosine: () => Decimal;
+                cosh: () => Decimal;
+                hyperbolicSine: () => Decimal;
+                sinh: () => Decimal;
+                hyperbolicTangent: () => Decimal;
+                tanh: () => Decimal;
+                inverseCosine: () => Decimal;
+                acos: () => Decimal;
+                inverseHyperbolicCosine: () => Decimal;
+                acosh: () => Decimal;
+                inverseHyperbolicSine: () => Decimal;
+                asinh: () => Decimal;
+                inverseHyperbolicTangent: () => Decimal;
+                atanh: () => Decimal;
+                inverseSine: () => Decimal;
+                asin: () => Decimal;
+                inverseTangent: () => Decimal;
+                atan: () => Decimal;
+                isFinite: () => boolean;
+                isInteger: () => boolean;
+                isInt: () => boolean;
+                isNaN: () => boolean;
+                isNegative: () => boolean;
+                isNeg: () => boolean;
+                isPositive: () => boolean;
+                isPos: () => boolean;
+                isZero: () => boolean;
+                lessThan: (n: Decimal.Value) => boolean;
+                lt: (n: Decimal.Value) => boolean;
+                lessThanOrEqualTo: (n: Decimal.Value) => boolean;
+                lte: (n: Decimal.Value) => boolean;
+                logarithm: (n?: Decimal.Value) => Decimal;
+                log: (n?: Decimal.Value) => Decimal;
+                minus: (n: Decimal.Value) => Decimal;
+                sub: (n: Decimal.Value) => Decimal;
+                modulo: (n: Decimal.Value) => Decimal;
+                mod: (n: Decimal.Value) => Decimal;
+                naturalExponential: () => Decimal;
+                exp: () => Decimal;
+                naturalLogarithm: () => Decimal;
+                ln: () => Decimal;
+                negated: () => Decimal;
+                neg: () => Decimal;
+                plus: (n: Decimal.Value) => Decimal;
+                add: (n: Decimal.Value) => Decimal;
+                precision: (includeZeros?: boolean) => number;
+                sd: (includeZeros?: boolean) => number;
+                round: () => Decimal;
+                sine: () => Decimal;
+                sin: () => Decimal;
+                squareRoot: () => Decimal;
+                sqrt: () => Decimal;
+                tangent: () => Decimal;
+                tan: () => Decimal;
+                times: (n: Decimal.Value) => Decimal;
+                mul: (n: Decimal.Value) => Decimal;
+                toBinary: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toDecimalPlaces: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toDP: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toExponential: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFixed: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFraction: (max_denominator?: Decimal.Value) => Decimal[];
+                toHexadecimal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toHex: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding?: Decimal.Rounding): string;
+                };
+                toJSON: () => string;
+                toNearest: (n: Decimal.Value, rounding?: Decimal.Rounding) => Decimal;
+                toNumber: () => number;
+                toOctal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toPower: (n: Decimal.Value) => Decimal;
+                pow: (n: Decimal.Value) => Decimal;
+                toPrecision: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toSignificantDigits: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toSD: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toString: () => string;
+                truncated: () => Decimal;
+                trunc: () => Decimal;
+                valueOf: () => string;
+            };
+            isPercentage: boolean;
+        }>;
+    };
+    template: string;
+};
+export declare const ForceNegative: (args: any) => {
+    components: {
+        DecimalInput: import('vue').DefineComponent<{
+            modelValue?: import('./DecimalInputValue').DecimalInputValue;
+            name?: string;
+            selectOnFocus?: boolean;
+            disabled?: boolean;
+            maxValue?: Decimal | number;
+            minValue?: Decimal | number;
+            allowPercentage?: boolean;
+        }, {
+            setError: (message?: string) => void;
+            focus: () => void;
+            select: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            blur: (value: Event) => any;
+            change: () => any;
+            focus: (value: Event) => any;
+            keydown: (value: KeyboardEvent) => any;
+            keypress: (value: KeyboardEvent) => any;
+            keyenter: (value: KeyboardEvent) => any;
+            "update:modelValue": (value: import('./DecimalInputValue').DecimalInputValue) => any;
+        }, string, import('vue').PublicProps, Readonly<{
+            modelValue?: import('./DecimalInputValue').DecimalInputValue;
+            name?: string;
+            selectOnFocus?: boolean;
+            disabled?: boolean;
+            maxValue?: Decimal | number;
+            minValue?: Decimal | number;
+            allowPercentage?: boolean;
+        }> & Readonly<{
+            onBlur?: ((value: Event) => any) | undefined;
+            onChange?: (() => any) | undefined;
+            onFocus?: ((value: Event) => any) | undefined;
+            onKeydown?: ((value: KeyboardEvent) => any) | undefined;
+            onKeypress?: ((value: KeyboardEvent) => any) | undefined;
+            onKeyenter?: ((value: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: import('./DecimalInputValue').DecimalInputValue) => any) | undefined;
+        }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    };
+    setup(): {
+        value: import('vue').Ref<{
+            value: {
+                readonly d: number[];
+                readonly e: number;
+                readonly s: number;
+                absoluteValue: () => Decimal;
+                abs: () => Decimal;
+                ceil: () => Decimal;
+                clampedTo: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                clamp: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                comparedTo: (n: Decimal.Value) => number;
+                cmp: (n: Decimal.Value) => number;
+                cosine: () => Decimal;
+                cos: () => Decimal;
+                cubeRoot: () => Decimal;
+                cbrt: () => Decimal;
+                decimalPlaces: () => number;
+                dp: () => number;
+                dividedBy: (n: Decimal.Value) => Decimal;
+                div: (n: Decimal.Value) => Decimal;
+                dividedToIntegerBy: (n: Decimal.Value) => Decimal;
+                divToInt: (n: Decimal.Value) => Decimal;
+                equals: (n: Decimal.Value) => boolean;
+                eq: (n: Decimal.Value) => boolean;
+                floor: () => Decimal;
+                greaterThan: (n: Decimal.Value) => boolean;
+                gt: (n: Decimal.Value) => boolean;
+                greaterThanOrEqualTo: (n: Decimal.Value) => boolean;
+                gte: (n: Decimal.Value) => boolean;
+                hyperbolicCosine: () => Decimal;
+                cosh: () => Decimal;
+                hyperbolicSine: () => Decimal;
+                sinh: () => Decimal;
+                hyperbolicTangent: () => Decimal;
+                tanh: () => Decimal;
+                inverseCosine: () => Decimal;
+                acos: () => Decimal;
+                inverseHyperbolicCosine: () => Decimal;
+                acosh: () => Decimal;
+                inverseHyperbolicSine: () => Decimal;
+                asinh: () => Decimal;
+                inverseHyperbolicTangent: () => Decimal;
+                atanh: () => Decimal;
+                inverseSine: () => Decimal;
+                asin: () => Decimal;
+                inverseTangent: () => Decimal;
+                atan: () => Decimal;
+                isFinite: () => boolean;
+                isInteger: () => boolean;
+                isInt: () => boolean;
+                isNaN: () => boolean;
+                isNegative: () => boolean;
+                isNeg: () => boolean;
+                isPositive: () => boolean;
+                isPos: () => boolean;
+                isZero: () => boolean;
+                lessThan: (n: Decimal.Value) => boolean;
+                lt: (n: Decimal.Value) => boolean;
+                lessThanOrEqualTo: (n: Decimal.Value) => boolean;
+                lte: (n: Decimal.Value) => boolean;
+                logarithm: (n?: Decimal.Value) => Decimal;
+                log: (n?: Decimal.Value) => Decimal;
+                minus: (n: Decimal.Value) => Decimal;
+                sub: (n: Decimal.Value) => Decimal;
+                modulo: (n: Decimal.Value) => Decimal;
+                mod: (n: Decimal.Value) => Decimal;
+                naturalExponential: () => Decimal;
+                exp: () => Decimal;
+                naturalLogarithm: () => Decimal;
+                ln: () => Decimal;
+                negated: () => Decimal;
+                neg: () => Decimal;
+                plus: (n: Decimal.Value) => Decimal;
+                add: (n: Decimal.Value) => Decimal;
+                precision: (includeZeros?: boolean) => number;
+                sd: (includeZeros?: boolean) => number;
+                round: () => Decimal;
+                sine: () => Decimal;
+                sin: () => Decimal;
+                squareRoot: () => Decimal;
+                sqrt: () => Decimal;
+                tangent: () => Decimal;
+                tan: () => Decimal;
+                times: (n: Decimal.Value) => Decimal;
+                mul: (n: Decimal.Value) => Decimal;
+                toBinary: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toDecimalPlaces: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toDP: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toExponential: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFixed: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFraction: (max_denominator?: Decimal.Value) => Decimal[];
+                toHexadecimal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toHex: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding?: Decimal.Rounding): string;
+                };
+                toJSON: () => string;
+                toNearest: (n: Decimal.Value, rounding?: Decimal.Rounding) => Decimal;
+                toNumber: () => number;
+                toOctal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toPower: (n: Decimal.Value) => Decimal;
+                pow: (n: Decimal.Value) => Decimal;
+                toPrecision: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toSignificantDigits: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toSD: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toString: () => string;
+                truncated: () => Decimal;
+                trunc: () => Decimal;
+                valueOf: () => string;
+            };
+            isPercentage: boolean;
+        }, {
+            value: Decimal;
+            isPercentage: boolean;
+        } | {
+            value: {
+                readonly d: number[];
+                readonly e: number;
+                readonly s: number;
+                absoluteValue: () => Decimal;
+                abs: () => Decimal;
+                ceil: () => Decimal;
+                clampedTo: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                clamp: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                comparedTo: (n: Decimal.Value) => number;
+                cmp: (n: Decimal.Value) => number;
+                cosine: () => Decimal;
+                cos: () => Decimal;
+                cubeRoot: () => Decimal;
+                cbrt: () => Decimal;
+                decimalPlaces: () => number;
+                dp: () => number;
+                dividedBy: (n: Decimal.Value) => Decimal;
+                div: (n: Decimal.Value) => Decimal;
+                dividedToIntegerBy: (n: Decimal.Value) => Decimal;
+                divToInt: (n: Decimal.Value) => Decimal;
+                equals: (n: Decimal.Value) => boolean;
+                eq: (n: Decimal.Value) => boolean;
+                floor: () => Decimal;
+                greaterThan: (n: Decimal.Value) => boolean;
+                gt: (n: Decimal.Value) => boolean;
+                greaterThanOrEqualTo: (n: Decimal.Value) => boolean;
+                gte: (n: Decimal.Value) => boolean;
+                hyperbolicCosine: () => Decimal;
+                cosh: () => Decimal;
+                hyperbolicSine: () => Decimal;
+                sinh: () => Decimal;
+                hyperbolicTangent: () => Decimal;
+                tanh: () => Decimal;
+                inverseCosine: () => Decimal;
+                acos: () => Decimal;
+                inverseHyperbolicCosine: () => Decimal;
+                acosh: () => Decimal;
+                inverseHyperbolicSine: () => Decimal;
+                asinh: () => Decimal;
+                inverseHyperbolicTangent: () => Decimal;
+                atanh: () => Decimal;
+                inverseSine: () => Decimal;
+                asin: () => Decimal;
+                inverseTangent: () => Decimal;
+                atan: () => Decimal;
+                isFinite: () => boolean;
+                isInteger: () => boolean;
+                isInt: () => boolean;
+                isNaN: () => boolean;
+                isNegative: () => boolean;
+                isNeg: () => boolean;
+                isPositive: () => boolean;
+                isPos: () => boolean;
+                isZero: () => boolean;
+                lessThan: (n: Decimal.Value) => boolean;
+                lt: (n: Decimal.Value) => boolean;
+                lessThanOrEqualTo: (n: Decimal.Value) => boolean;
+                lte: (n: Decimal.Value) => boolean;
+                logarithm: (n?: Decimal.Value) => Decimal;
+                log: (n?: Decimal.Value) => Decimal;
+                minus: (n: Decimal.Value) => Decimal;
+                sub: (n: Decimal.Value) => Decimal;
+                modulo: (n: Decimal.Value) => Decimal;
+                mod: (n: Decimal.Value) => Decimal;
+                naturalExponential: () => Decimal;
+                exp: () => Decimal;
+                naturalLogarithm: () => Decimal;
+                ln: () => Decimal;
+                negated: () => Decimal;
+                neg: () => Decimal;
+                plus: (n: Decimal.Value) => Decimal;
+                add: (n: Decimal.Value) => Decimal;
+                precision: (includeZeros?: boolean) => number;
+                sd: (includeZeros?: boolean) => number;
+                round: () => Decimal;
+                sine: () => Decimal;
+                sin: () => Decimal;
+                squareRoot: () => Decimal;
+                sqrt: () => Decimal;
+                tangent: () => Decimal;
+                tan: () => Decimal;
+                times: (n: Decimal.Value) => Decimal;
+                mul: (n: Decimal.Value) => Decimal;
+                toBinary: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toDecimalPlaces: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toDP: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toExponential: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFixed: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFraction: (max_denominator?: Decimal.Value) => Decimal[];
+                toHexadecimal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toHex: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding?: Decimal.Rounding): string;
+                };
+                toJSON: () => string;
+                toNearest: (n: Decimal.Value, rounding?: Decimal.Rounding) => Decimal;
+                toNumber: () => number;
+                toOctal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toPower: (n: Decimal.Value) => Decimal;
+                pow: (n: Decimal.Value) => Decimal;
+                toPrecision: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toSignificantDigits: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toSD: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toString: () => string;
+                truncated: () => Decimal;
+                trunc: () => Decimal;
+                valueOf: () => string;
+            };
+            isPercentage: boolean;
+        }>;
+    };
+    template: string;
+};
+export declare const AllowPercentage: (args: any) => {
+    components: {
+        DecimalInput: import('vue').DefineComponent<{
+            modelValue?: import('./DecimalInputValue').DecimalInputValue;
+            name?: string;
+            selectOnFocus?: boolean;
+            disabled?: boolean;
+            maxValue?: Decimal | number;
+            minValue?: Decimal | number;
+            allowPercentage?: boolean;
+        }, {
+            setError: (message?: string) => void;
+            focus: () => void;
+            select: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            blur: (value: Event) => any;
+            change: () => any;
+            focus: (value: Event) => any;
+            keydown: (value: KeyboardEvent) => any;
+            keypress: (value: KeyboardEvent) => any;
+            keyenter: (value: KeyboardEvent) => any;
+            "update:modelValue": (value: import('./DecimalInputValue').DecimalInputValue) => any;
+        }, string, import('vue').PublicProps, Readonly<{
+            modelValue?: import('./DecimalInputValue').DecimalInputValue;
+            name?: string;
+            selectOnFocus?: boolean;
+            disabled?: boolean;
+            maxValue?: Decimal | number;
+            minValue?: Decimal | number;
+            allowPercentage?: boolean;
+        }> & Readonly<{
+            onBlur?: ((value: Event) => any) | undefined;
+            onChange?: (() => any) | undefined;
+            onFocus?: ((value: Event) => any) | undefined;
+            onKeydown?: ((value: KeyboardEvent) => any) | undefined;
+            onKeypress?: ((value: KeyboardEvent) => any) | undefined;
+            onKeyenter?: ((value: KeyboardEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: import('./DecimalInputValue').DecimalInputValue) => any) | undefined;
+        }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+    };
+    setup(): {
+        value: import('vue').Ref<{
+            value: {
+                readonly d: number[];
+                readonly e: number;
+                readonly s: number;
+                absoluteValue: () => Decimal;
+                abs: () => Decimal;
+                ceil: () => Decimal;
+                clampedTo: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                clamp: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                comparedTo: (n: Decimal.Value) => number;
+                cmp: (n: Decimal.Value) => number;
+                cosine: () => Decimal;
+                cos: () => Decimal;
+                cubeRoot: () => Decimal;
+                cbrt: () => Decimal;
+                decimalPlaces: () => number;
+                dp: () => number;
+                dividedBy: (n: Decimal.Value) => Decimal;
+                div: (n: Decimal.Value) => Decimal;
+                dividedToIntegerBy: (n: Decimal.Value) => Decimal;
+                divToInt: (n: Decimal.Value) => Decimal;
+                equals: (n: Decimal.Value) => boolean;
+                eq: (n: Decimal.Value) => boolean;
+                floor: () => Decimal;
+                greaterThan: (n: Decimal.Value) => boolean;
+                gt: (n: Decimal.Value) => boolean;
+                greaterThanOrEqualTo: (n: Decimal.Value) => boolean;
+                gte: (n: Decimal.Value) => boolean;
+                hyperbolicCosine: () => Decimal;
+                cosh: () => Decimal;
+                hyperbolicSine: () => Decimal;
+                sinh: () => Decimal;
+                hyperbolicTangent: () => Decimal;
+                tanh: () => Decimal;
+                inverseCosine: () => Decimal;
+                acos: () => Decimal;
+                inverseHyperbolicCosine: () => Decimal;
+                acosh: () => Decimal;
+                inverseHyperbolicSine: () => Decimal;
+                asinh: () => Decimal;
+                inverseHyperbolicTangent: () => Decimal;
+                atanh: () => Decimal;
+                inverseSine: () => Decimal;
+                asin: () => Decimal;
+                inverseTangent: () => Decimal;
+                atan: () => Decimal;
+                isFinite: () => boolean;
+                isInteger: () => boolean;
+                isInt: () => boolean;
+                isNaN: () => boolean;
+                isNegative: () => boolean;
+                isNeg: () => boolean;
+                isPositive: () => boolean;
+                isPos: () => boolean;
+                isZero: () => boolean;
+                lessThan: (n: Decimal.Value) => boolean;
+                lt: (n: Decimal.Value) => boolean;
+                lessThanOrEqualTo: (n: Decimal.Value) => boolean;
+                lte: (n: Decimal.Value) => boolean;
+                logarithm: (n?: Decimal.Value) => Decimal;
+                log: (n?: Decimal.Value) => Decimal;
+                minus: (n: Decimal.Value) => Decimal;
+                sub: (n: Decimal.Value) => Decimal;
+                modulo: (n: Decimal.Value) => Decimal;
+                mod: (n: Decimal.Value) => Decimal;
+                naturalExponential: () => Decimal;
+                exp: () => Decimal;
+                naturalLogarithm: () => Decimal;
+                ln: () => Decimal;
+                negated: () => Decimal;
+                neg: () => Decimal;
+                plus: (n: Decimal.Value) => Decimal;
+                add: (n: Decimal.Value) => Decimal;
+                precision: (includeZeros?: boolean) => number;
+                sd: (includeZeros?: boolean) => number;
+                round: () => Decimal;
+                sine: () => Decimal;
+                sin: () => Decimal;
+                squareRoot: () => Decimal;
+                sqrt: () => Decimal;
+                tangent: () => Decimal;
+                tan: () => Decimal;
+                times: (n: Decimal.Value) => Decimal;
+                mul: (n: Decimal.Value) => Decimal;
+                toBinary: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toDecimalPlaces: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toDP: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toExponential: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFixed: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFraction: (max_denominator?: Decimal.Value) => Decimal[];
+                toHexadecimal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toHex: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding?: Decimal.Rounding): string;
+                };
+                toJSON: () => string;
+                toNearest: (n: Decimal.Value, rounding?: Decimal.Rounding) => Decimal;
+                toNumber: () => number;
+                toOctal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toPower: (n: Decimal.Value) => Decimal;
+                pow: (n: Decimal.Value) => Decimal;
+                toPrecision: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toSignificantDigits: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toSD: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toString: () => string;
+                truncated: () => Decimal;
+                trunc: () => Decimal;
+                valueOf: () => string;
+            };
+            isPercentage: boolean;
+        }, {
+            value: Decimal;
+            isPercentage: boolean;
+        } | {
+            value: {
+                readonly d: number[];
+                readonly e: number;
+                readonly s: number;
+                absoluteValue: () => Decimal;
+                abs: () => Decimal;
+                ceil: () => Decimal;
+                clampedTo: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                clamp: (min: Decimal.Value, max: Decimal.Value) => Decimal;
+                comparedTo: (n: Decimal.Value) => number;
+                cmp: (n: Decimal.Value) => number;
+                cosine: () => Decimal;
+                cos: () => Decimal;
+                cubeRoot: () => Decimal;
+                cbrt: () => Decimal;
+                decimalPlaces: () => number;
+                dp: () => number;
+                dividedBy: (n: Decimal.Value) => Decimal;
+                div: (n: Decimal.Value) => Decimal;
+                dividedToIntegerBy: (n: Decimal.Value) => Decimal;
+                divToInt: (n: Decimal.Value) => Decimal;
+                equals: (n: Decimal.Value) => boolean;
+                eq: (n: Decimal.Value) => boolean;
+                floor: () => Decimal;
+                greaterThan: (n: Decimal.Value) => boolean;
+                gt: (n: Decimal.Value) => boolean;
+                greaterThanOrEqualTo: (n: Decimal.Value) => boolean;
+                gte: (n: Decimal.Value) => boolean;
+                hyperbolicCosine: () => Decimal;
+                cosh: () => Decimal;
+                hyperbolicSine: () => Decimal;
+                sinh: () => Decimal;
+                hyperbolicTangent: () => Decimal;
+                tanh: () => Decimal;
+                inverseCosine: () => Decimal;
+                acos: () => Decimal;
+                inverseHyperbolicCosine: () => Decimal;
+                acosh: () => Decimal;
+                inverseHyperbolicSine: () => Decimal;
+                asinh: () => Decimal;
+                inverseHyperbolicTangent: () => Decimal;
+                atanh: () => Decimal;
+                inverseSine: () => Decimal;
+                asin: () => Decimal;
+                inverseTangent: () => Decimal;
+                atan: () => Decimal;
+                isFinite: () => boolean;
+                isInteger: () => boolean;
+                isInt: () => boolean;
+                isNaN: () => boolean;
+                isNegative: () => boolean;
+                isNeg: () => boolean;
+                isPositive: () => boolean;
+                isPos: () => boolean;
+                isZero: () => boolean;
+                lessThan: (n: Decimal.Value) => boolean;
+                lt: (n: Decimal.Value) => boolean;
+                lessThanOrEqualTo: (n: Decimal.Value) => boolean;
+                lte: (n: Decimal.Value) => boolean;
+                logarithm: (n?: Decimal.Value) => Decimal;
+                log: (n?: Decimal.Value) => Decimal;
+                minus: (n: Decimal.Value) => Decimal;
+                sub: (n: Decimal.Value) => Decimal;
+                modulo: (n: Decimal.Value) => Decimal;
+                mod: (n: Decimal.Value) => Decimal;
+                naturalExponential: () => Decimal;
+                exp: () => Decimal;
+                naturalLogarithm: () => Decimal;
+                ln: () => Decimal;
+                negated: () => Decimal;
+                neg: () => Decimal;
+                plus: (n: Decimal.Value) => Decimal;
+                add: (n: Decimal.Value) => Decimal;
+                precision: (includeZeros?: boolean) => number;
+                sd: (includeZeros?: boolean) => number;
+                round: () => Decimal;
+                sine: () => Decimal;
+                sin: () => Decimal;
+                squareRoot: () => Decimal;
+                sqrt: () => Decimal;
+                tangent: () => Decimal;
+                tan: () => Decimal;
+                times: (n: Decimal.Value) => Decimal;
+                mul: (n: Decimal.Value) => Decimal;
+                toBinary: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toDecimalPlaces: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toDP: {
+                    (decimalPlaces?: number): Decimal;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toExponential: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFixed: {
+                    (decimalPlaces?: number): string;
+                    (decimalPlaces: number, rounding: Decimal.Rounding): string;
+                };
+                toFraction: (max_denominator?: Decimal.Value) => Decimal[];
+                toHexadecimal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toHex: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding?: Decimal.Rounding): string;
+                };
+                toJSON: () => string;
+                toNearest: (n: Decimal.Value, rounding?: Decimal.Rounding) => Decimal;
+                toNumber: () => number;
+                toOctal: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toPower: (n: Decimal.Value) => Decimal;
+                pow: (n: Decimal.Value) => Decimal;
+                toPrecision: {
+                    (significantDigits?: number): string;
+                    (significantDigits: number, rounding: Decimal.Rounding): string;
+                };
+                toSignificantDigits: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toSD: {
+                    (significantDigits?: number): Decimal;
+                    (significantDigits: number, rounding: Decimal.Rounding): Decimal;
+                };
+                toString: () => string;
+                truncated: () => Decimal;
+                trunc: () => Decimal;
+                valueOf: () => string;
+            };
+            isPercentage: boolean;
+        }>;
+    };
+    template: string;
+};