import { ConsumeUntil } from "./ConsumeUntil";
import { BooleanPath } from "./parsers/BooleanPath";
import { FloatPath } from "./parsers/FloatPath";
import { IntPath } from "./parsers/IntParser";
import { SplitStringPath } from "./parsers/SplitStringPath";
import { PathMatcher, PathResult } from "./PathMatcher";
export declare const v: {
    segment: ConsumeUntil;
    upToChars: (count: number) => ConsumeUntil;
    exactlyChars: (count: number) => ConsumeUntil;
    upToSegments: (count: number) => SplitStringPath;
    exactlySegments: (count: number) => SplitStringPath;
    restOfPath: SplitStringPath;
    restOfPathSegments: SplitStringPath;
    boolean: BooleanPath;
    float: FloatPath;
    int: IntPath;
    binary: IntPath;
    hex: IntPath;
};
export type VariablePaths<T extends object> = {
    readonly [K in keyof T]: PathMatcher<T[K]>;
};
export type Variable<T, K extends keyof T = keyof T> = {
    key: K;
};
export type Variables<T extends object> = {
    readonly [K in keyof T]: Variable<T, K>;
};
export declare class VariablePath<T, K extends keyof T> implements PathMatcher<{
    K: T[K];
}> {
    private readonly key;
    private readonly value;
    constructor(key: K, value: PathMatcher<T[K]>);
    consume(path: string): PathResult<{
        K: T[K];
    }>;
    expand(value: {
        K: T[K];
    }): string;
}
export type SegmentsFn<T extends object> = (vars: Variables<T>) => (Variable<T> | string)[];
export declare function variablesPath<T extends object>(variablePaths: VariablePaths<T>, segmentFn: SegmentsFn<T>): PathMatcher<T>;
//# sourceMappingURL=variables.d.ts.map