interface Charmap {
    [key: string]: string;
}

interface Mappable {
    map: (pos: number, assoc?: number) => number;
    mapResult: (pos: number, assoc?: number) => MapResult;
}
declare class MapResult {
    readonly pos: number;
    get deleted(): boolean;
    get deletedBefore(): boolean;
    get deletedAfter(): boolean;
    get deletedAcross(): boolean;
}
declare class StepMap implements Mappable {
    constructor(ranges: readonly number[], inverted?: boolean);
    mapResult(pos: number, assoc?: number): MapResult;
    map(pos: number, assoc?: number): number;
    forEach(f: (oldStart: number, oldEnd: number, newStart: number, newEnd: number) => void): void;
    invert(): StepMap;
    static offset(n: number): StepMap;
    static empty: StepMap;
}
declare class Mapping implements Mappable {
    from: number;
    to: number;
    constructor(maps?: readonly StepMap[], mirror?: number[] | undefined, from?: number, to?: number);
    get maps(): readonly StepMap[];
    private _maps;
    private ownData;
    slice(from?: number, to?: number): Mapping;
    appendMap(map: StepMap, mirrors?: number): void;
    appendMapping(mapping: Mapping): void;
    getMirror(n: number): number | undefined;
    appendMappingInverted(mapping: Mapping): void;
    invert(): Mapping;
    map(pos: number, assoc?: number): number;
    mapResult(pos: number, assoc?: number): MapResult;
}

type OptionReplaceArrayItem = [
    string | RegExp,
    string | ((match: RegExpExecArray) => string)
];
type OptionReplaceArray = OptionReplaceArrayItem[];
type OptionReplaceObject = {
    [from: string]: string | ((match: RegExpExecArray) => string);
};
type OptionReplaceCombined = OptionReplaceArray | OptionReplaceObject;
type OptionsTransliterate = {
    /**
     * Ignore a list of strings untouched
     * @example tr('你好，世界', { ignore: ['你'] }) // 你 Hao , Shi Jie
     */
    ignore?: string[];
    /**
     * Replace a list of string / regex in the source string into the provided target string before transliteration
     * The option can either be an array or an object
     * @example tr('你好，世界', { replace: {你: 'You'} }) // You Hao , Shi Jie
     * @example tr('你好，世界', { replace: [['你', 'You']] }) // You Hao , Shi Jie
     * @example tr('你好，世界', { replace: [[/你/g, 'You']] }) // You Hao , Shi Jie
     */
    replace?: OptionReplaceCombined;
    /**
     * Same as `replace` but after transliteration
     */
    replaceAfter?: OptionReplaceCombined;
    /**
     * Decides whether or not to trim the result string after transliteration
     * @default false
     */
    trim?: boolean;
    /**
     * Any characters not known by this library will be replaced by a specific string `unknown`
     * @default ''
     */
    unknown?: string;
    /**
     * Fix Chinese spacing. For example, `你好` is transliterated to `Ni Hao` instead of `NiHao`. If you don't need to transliterate Chinese characters, set it to false to false to improve performance.
     * @default true
     */
    fixChineseSpacing?: boolean;
    /**
     * The locale to interpret the text as
     */
    locale?: Intl.Locale;
};
type OptionsSlugify = OptionsTransliterate & {
    /**
     * Whether the result need to be converted into lowercase
     * @default true
     */
    lowercase?: boolean;
    /**
     * Whether the result need to be converted into uppercase
     * @default false
     */
    uppercase?: boolean;
    /**
     * Custom separator string
     * @default '-'
     */
    separator?: string;
    /**
     * Allowed characters.
     * When `allowedChars` is set to `'abc'`, then only characters match `/[abc]/g` will be preserved.
     * Other characters will all be converted to `separator`
     * @default 'a-zA-Z0-9-_.~''
     */
    allowedChars?: string;
    /**
     * Fix Chinese spacing. For example, `你好` is transliterated to `Ni Hao` instead of `NiHao`. If you don't need to transliterate Chinese characters, set it to false to false to improve performance.
     */
    fixChineseSpacing?: boolean;
};
type TransliterationFunction<T> = {
    (source: string, options?: T): Promise<{
        result: string;
        mapping: Mapping;
    }>;
    /**
     * Set default config
     * @param options
     * @param reset
     */
    config: (options?: T, reset?: boolean) => T;
    /**
     * Set charmap data
     * @param data
     * @param reset
     * @memberof Transliterate
     */
    setData: (data?: Charmap, reset?: boolean) => Charmap;
    /**
     * Used by browser
     */
    noConflict?: () => TransliterationFunction<T>;
};
type TransliterateFunction = TransliterationFunction<OptionsTransliterate>;
type SlugifyFunction = TransliterationFunction<OptionsSlugify>;

export { Mapping as M, type SlugifyFunction as S, type TransliterateFunction as T, StepMap as a };
