import type { DataTransformer, DecryptFn, EncryptFn, MvAttribute, MvRecord } from '../types';
import BaseSchemaType from './BaseSchemaType';
import type { SchemaTypeDefinitionBoolean } from './BooleanType';
import type { SchemaTypeDefinitionISOCalendarDateTime } from './ISOCalendarDateTimeType';
import type { SchemaTypeDefinitionISOCalendarDate } from './ISOCalendarDateType';
import type { SchemaTypeDefinitionISOTime } from './ISOTimeType';
import type { SchemaTypeDefinitionNumber } from './NumberType';
import type { SchemaTypeDefinitionString } from './StringType';
export interface ScalarTypeConstructorOptions {
    encrypt?: EncryptFn;
    decrypt?: DecryptFn;
}
export type SchemaTypeDefinitionScalar = SchemaTypeDefinitionBoolean | SchemaTypeDefinitionISOCalendarDateTime | SchemaTypeDefinitionISOCalendarDate | SchemaTypeDefinitionISOTime | SchemaTypeDefinitionNumber | SchemaTypeDefinitionString;
type RecordSetType = string | null | (string | null | (string | null)[])[];
export type SchemaTypePath = [number] | [number, number] | [number, number, number];
/** Abstract Scalar Schema Type */
declare abstract class BaseScalarType extends BaseSchemaType implements DataTransformer {
    /** Data definition which this schema type was constructed from */
    readonly definition: SchemaTypeDefinitionScalar;
    /** 0-indexed Array path */
    readonly path: SchemaTypePath;
    /** Multivalue dictionary id */
    readonly dictionary: string | null;
    /** Required validation value for the schema type */
    protected readonly required: boolean;
    /** Indicates whether data should be encrypted/decrypted */
    private readonly encrypted;
    /** Encrypt function to call on sensitive data before writing to the database */
    private readonly encrypt?;
    /** Decrypt function to call on sensitive data encrypted in the database */
    private readonly decrypt?;
    /** Data transformer */
    protected abstract readonly dataTransformer: DataTransformer;
    protected constructor(definition: SchemaTypeDefinitionScalar, { encrypt, decrypt }?: ScalarTypeConstructorOptions);
    /** Get value from mv data */
    get(record: MvRecord): unknown;
    /** Transform into multivalue format and set specified value into mv record */
    set(originalRecord: MvRecord, value: unknown): MvRecord;
    /** Transform from mv data to externally formatted data */
    transformFromDb(value: unknown): unknown;
    /** Transform from externally formatted data to mv data */
    transformToDb(value: unknown): string | null;
    /** Transform query constants to the format schema */
    transformToQuery(value: unknown): string;
    /** Validate the scalar type */
    validate(value: unknown): string[];
    /** Get data from the specified keypath */
    getFromMvData(record: MvRecord): MvAttribute;
    /** Set specified value into mv record */
    setIntoMvData(originalRecord: MvRecord, setValue: RecordSetType): MvRecord;
    /** Required validator */
    protected validateRequired: (value: unknown) => boolean;
    /** Type validator */
    protected validateType: (value: unknown) => boolean;
    /** Create validation object for required validation */
    private createRequiredValidator;
    /** Create validation object for type validation */
    private createTypeValidator;
    /**
     * Convert a 1-index string array path definition (e.g. '1.1.1') to a 0-index array path definition (e.g. [0, 0, 0])
     * @throws {@link InvalidParameterError} Path definition must be a string of integers split by periods
     */
    private normalizeMvPath;
    /** Encrypt a transformed property */
    private encryptData;
    /** Encrypt a single value */
    private encryptSingle;
    /** Decrypt a multivalue attribute */
    private decryptData;
    /** Decrypt a single value */
    private decryptSingle;
}
export default BaseScalarType;