/**
 * Implements some name resolution mechanism. Typical
 * ways to resolve a name is through aliasing or expanding
 * based on a prefix, but this interface mandates no constraints
 * except that the resolution should either produce a new name or
 * return its input parameter as is.
 */
export interface NameResolver {
    resolve(name: string): string;
    inverse(): NameResolver;
}
interface WithResolver {
    resolver: NameResolver;
}
declare class ResolverHolder implements WithResolver {
    resolver: DefaultNameResolver;
}
declare class AliasResolver implements NameResolver {
    private dict;
    constructor(aliases: object);
    inverse(): NameResolver;
    withAliases(moreAliases: object): AliasResolver;
    set(name: string, alias: string): AliasResolver;
    unset(alias: string): AliasResolver;
    clear(): AliasResolver;
    resolve(name: string): string;
}
declare class PrefixResolver implements NameResolver {
    private prefixes;
    constructor(prefixes: object);
    inverse(): NameResolver;
    withPrefixes(morePrefixes: object): PrefixResolver;
    set(prefix: string, expansion: string): PrefixResolver;
    unset(prefix: string): PrefixResolver;
    clear(): PrefixResolver;
    resolve(name: string): string;
}
/**
 * A ConNameResolver performs two name resolutions in sequence feeding
 * the result of the first into the second.
 */
declare class ConNameResolver implements NameResolver {
    private first;
    private second;
    constructor(first: NameResolver, second: NameResolver);
    inverse(): NameResolver;
    resolve(name: string): string;
}
export declare class DefaultNameResolver extends ConNameResolver {
    readonly aliasResolver: AliasResolver;
    readonly prefixResolver: PrefixResolver;
    constructor(aliasResolver: AliasResolver, prefixResolver: PrefixResolver);
    /**
     * Algorithm:
     *
     * 1. First the dictionary of aliases is used to translate
     * the name to its alias, if any. This is a single step, a single
     * alias lookup.
     * 2. If the name contains a prefix, the prefix resolver for
     * that prefix is invoked to resolve the name.
     *
     * Any more complex behavior, or any sort of recursion where the result
     * of a name resolution is further resolved, must be done through
     * composition of name resolvers and implementing the composition logic
     * in individual resolvers.
     *
     * @param name
     */
    resolve(name: string): string;
}
declare const standardPrefixes: {
    dcterms: string;
    owl: string;
    rdf: string;
    rdfs: string;
    sh: string;
    skos: string;
    xsd: string;
};
declare const resolvers: {
    default: () => DefaultNameResolver;
    byAlias: (aliases: object) => AliasResolver;
    byPrefix: (prefixes: object) => PrefixResolver;
};
export { ResolverHolder, WithResolver, resolvers, standardPrefixes };