import type { GeoJsonDataType } from './types';
import { DataType, TypedValue } from './DataPrimitive';
/**
 * @implements {TypedValue}
 * TypeSafeValue implements the TypedValue interface, and adds additional methods
 */
export declare class TypeSafeValue<T extends DataType> implements TypedValue<T> {
    /**
     * isTypeSafe. This is a marker field. The presence of this field can be used at runtime to determine if TypedValue is rigorous,
     * loose. Loose TypedValue such as {type:'number', value:'cat'} are handy for testing, but can lie. Obviously 'cat'
     * is not a number. If the isTypeSafe field is present then the instance is a TypeSafeValue
     * @type {boolean}
     */
    readonly isTypeSafe: boolean;
    /**
     * coercedValue. This field retains the value after coercion.
     */
    readonly coercedValue: any;
    readonly type: T;
    readonly value: any;
    constructor(type: T, value: any, coercedValue: any);
    /**
     * returns a TypeSafeValue, either by converting the non TypeSafeValue to
     * a TypeSafeValue, or by simply returning the passed-in TypeSafeValue
     * @param {TypedValue<T>} typedValue
     * @returns {TypeSafeValue<T>}
     */
    static from<FromValueType extends DataType = DataType>(typedValue: TypedValue<FromValueType>): TypeSafeValue<FromValueType>;
    /**
     * Creates a TypeSafeValue from a raw value
     * @param value
     * @returns {TypeSafeValue<DataType>}
     */
    static fromRaw(value: any): TypeSafeValue<DataType>;
    /**
     * attempts to coerce the provided value to the provided type. Returns tuple
     * of the coerced value and a boolean telling if the coercion was clean (true)
     * or if the coercion was likely produced an unusable result, such as NaN for
     * a number, or '' for a color.
     * @param {TypedValue<T>} typedValue
     * @returns {[any]}
     */
    private static coerceValue;
    toRawCoercedValue(): string | number | null | GeoJsonDataType;
    toRawValue(): string | number | null | GeoJsonDataType;
}