type PathInfoVariables = {
    [variable: string]: string | number;
    readonly length: number;
};
/**
 * Uma classe utilitária para analisar, manipular e comparar caminhos hierárquicos.
 * Facilita o trabalho com caminhos que podem conter segmentos de string e índices de array,
 * como 'users/123/posts[0]'.
 *
 * @class PathInfo
 *
 * @example
 * ```ts
 * // Criando uma instância a partir de uma string
 * const path = new PathInfo('users/123/posts[0]');
 *
 * // Acessando propriedades
 * console.log(path.path);      // => "users/123/posts[0]"
 * console.log(path.keys);      // => ['', 'users', '123', 'posts', 0]
 * console.log(path.key);       // => 0
 * console.log(path.parent?.path); // => "users/123/posts"
 *
 * // Criando caminhos filhos
 * const titlePath = path.child('title');
 * console.log(titlePath.path); // => "users/123/posts[0]/title"
 * ```
 */
export declare class PathInfo {
    /**
     * A string de caminho normalizada e completa.
     * @readonly
     * @example
     * ```ts
     * const p = new PathInfo('users/123/posts[0]');
     * console.log(p.path); // "users/123/posts[0]"
     * ```
     */
    readonly path: string;
    /**
     * Um array dos segmentos (chaves) que compõem o caminho.
     * Chaves de objeto são strings, e índices de array são números.
     * O primeiro elemento é uma string vazia para representar a raiz.
     * @readonly
     * @example
     * ```ts
     * const p = new PathInfo('users/123/posts[0]');
     * console.log(p.keys); // ['', 'users', '123', 'posts', 0]
     * ```
     */
    readonly keys: Array<string | number>;
    /**
     * Cria uma nova instância de `PathInfo` analisando um caminho.
     * O caminho pode ser fornecido como uma string (com notação de barra e colchetes)
     * ou como um array de segmentos de caminho que serão concatenados.
     *
     * @param {string | Array<string | number | PathInfo>} path O caminho a ser analisado.
     *
     * @example
     * ```ts
     * // Criando a partir de uma string
     * const pathFromString = new PathInfo('users/123/posts[0]');
     * console.log(pathFromString.path); // => "users/123/posts[0]"
     * console.log(pathFromString.keys); // => ['', 'users', '123', 'posts', 0]
     *
     * // Criando a partir de um array de segmentos
     * const pathFromArray = new PathInfo(['users', 123, 'posts', 0]);
     * console.log(pathFromArray.path); // => "users/123/posts[0]"
     *
     * // Criando a partir de uma combinação complexa
     * const part1 = 'users/123';
     * const part2 = new PathInfo('posts');
     * const pathFromParts = new PathInfo([part1, part2, 0, 'title']);
     * console.log(pathFromParts.path); // => "users/123/posts[0]/title"
     * ```
     */
    constructor(path: string | Array<string | number | PathInfo>);
    /**
     * Obtém o último segmento (chave ou índice) do caminho.
     * Retorna `null` se o caminho estiver vazio.
     * @example
     * ```ts
     * const p = new PathInfo('users/123/posts[0]');
     * console.log(p.key); // 0
     *
     * const p2 = new PathInfo('users/123');
     * console.log(p2.key); // "123"
     * ```
     */
    get key(): string | number | null;
    /**
     * Obtém uma nova instância de `PathInfo` representando o caminho pai.
     * Retorna `null` se o caminho não tiver um pai (ou seja, for a raiz).
     * @example
     * ```ts
     * const p = new PathInfo('users/123/profile');
     * const parent = p.parent;
     * console.log(parent.path); // "users/123"
     * ```
     */
    get parent(): PathInfo | null;
    /**
     * Obtém a string do caminho pai.
     * É um atalho conveniente para `this.parent?.path`.
     * @example
     * ```ts
     * const p = new PathInfo('users/123/profile');
     * console.log(p.parentPath); // "users/123"
     * ```
     */
    get parentPath(): string | null;
    /**
     * Um alias para a propriedade `keys`. Retorna o array de segmentos (chaves) que compõem o caminho.
     *
     * @returns {Array<string | number>} Um array de segmentos de caminho.
     * @see {@link keys}
     * @example
     * ```ts
     * const p = new PathInfo('users/123/posts[0]');
     * console.log(p.pathKeys); // ['', 'users', '123', 'posts', 0]
     * ```
     */
    get pathKeys(): Array<string | number>;
    /**
     * Retorna a representação em string do caminho.
     * Este método é chamado automaticamente quando a instância de `PathInfo`
     * é usada em um contexto que espera uma string (como concatenação ou logging).
     *
     * @returns {string} A string completa do caminho.
     *
     * @example
     * ```ts
     * const path = new PathInfo('users/123');
     *
     * // Chamada explícita
     * console.log(path.toString()); // => "users/123"
     *
     * // Chamada implícita em template string
     * const fullUrl = `https://example.com/api/${path}`;
     * console.log(fullUrl); // => "https://example.com/api/users/123"
     * ```
     */
    toString(): string;
    /**
     * Cria uma nova instância de `PathInfo` para um caminho filho.
     * Este método permite navegar para baixo na hierarquia de caminhos.
     *
     * @param {string | number | Array<string | number>} childKey A chave ou índice do filho.
     * Pode ser uma única chave (`'profile'`), um índice (`0`), ou um caminho completo (`'posts/1/title'`).
     * @returns {PathInfo} Uma nova instância de `PathInfo` representando o caminho filho.
     *
     * @example
     * ```ts
     * const userPath = new PathInfo('users/123');
     *
     * // Navegando para um filho com uma chave de string
     * const profilePath = userPath.child('profile');
     * console.log(profilePath.path); // => "users/123/profile"
     *
     * // Navegando para um filho com um caminho composto
     * const postTitlePath = userPath.child('posts[0]/title');
     * console.log(postTitlePath.path); // => "users/123/posts[0]/title"
     * ```
     */
    child(childKey: string | number | Array<string | number>): PathInfo;
    /**
     * Obtém a string de um caminho filho.
     * É um atalho conveniente para `this.child(childKey).path`.
     *
     * @param {string | number | Array<string | number>} childKey A chave ou índice do filho a ser anexado.
     * @returns {string} A string completa do caminho filho resultante.
     *
     * @example
     * ```ts
     * const userPath = new PathInfo('users/123');
     *
     * const profilePathString = userPath.childPath('profile');
     * console.log(profilePathString); // => "users/123/profile"
     * ```
     */
    childPath(childKey: string | number | Array<string | number>): string;
    /**
     * Verifica se este caminho corresponde estruturalmente a outro caminho.
     *
     * A comparação é flexível e considera wildcards (`*`) e variáveis nomeadas (`$name`)
     * como correspondentes a qualquer segmento na mesma posição no outro caminho.
     *
     * @param {string | PathInfo} otherPath O outro caminho a ser comparado.
     * @returns {boolean} Retorna `true` se os caminhos corresponderem, caso contrário `false`.
     *
     * @example
     * ```ts
     * const templatePath = new PathInfo('users/$uid/posts/*');
     *
     * // Corresponde a um caminho concreto
     * console.log(templatePath.equals('users/ewout/posts/post1')); // => true
     *
     * // A correspondência é bidirecional
     * const concretePath = new PathInfo('users/ewout/posts/post1');
     * console.log(concretePath.equals(templatePath)); // => true
     *
     * // Não corresponde se o número de segmentos for diferente
     * console.log(templatePath.equals('users/ewout/posts')); // => false
     * ```
     */
    equals(otherPath: string | PathInfo): boolean;
    /**
     * Verifica se o caminho atual é um ancestral do caminho descendente fornecido.
     *
     * Um caminho é considerado um ancestral se o caminho descendente começar com todos os
     * segmentos do caminho atual. A comparação é flexível e lida com wildcards (`*`)
     * e variáveis (`$name`).
     *
     * @param {string | PathInfo} descendantPath O caminho a ser verificado como descendente.
     * @returns {boolean} Retorna `true` se o caminho atual for um ancestral, caso contrário `false`.
     *
     * @example
     * ```ts
     * const userPath = new PathInfo('users/123');
     *
     * // 'users/123' é um ancestral de 'users/123/posts'
     * console.log(userPath.isAncestorOf('users/123/posts')); // => true
     *
     * // Um caminho não é ancestral de si mesmo
     * console.log(userPath.isAncestorOf('users/123')); // => false
     *
     * // A comparação funciona com wildcards
     * const templatePath = new PathInfo('users/*');
     * console.log(templatePath.isAncestorOf('users/abc/profile')); // => true
     * ```
     */
    isAncestorOf(descendantPath: string | PathInfo): boolean;
    /**
     * Verifica se o caminho atual é um descendente do caminho ancestral fornecido.
     *
     * Um caminho é considerado um descendente se começar com todos os segmentos do caminho
     * ancestral. A comparação é flexível e lida com wildcards (`*`) e variáveis (`$name`).
     *
     * @param {string | PathInfo} ancestorPath O caminho a ser verificado como ancestral.
     * @returns {boolean} Retorna `true` se o caminho atual for um descendente, caso contrário `false`.
     *
     * @example
     * ```ts
     * const postPath = new PathInfo('users/123/posts/post1');
     *
     * // 'users/123/posts/post1' é um descendente de 'users/123'
     * console.log(postPath.isDescendantOf('users/123')); // => true
     *
     * // Um caminho não é descendente de si mesmo
     * console.log(postPath.isDescendantOf('users/123/posts/post1')); // => false
     *
     * // A comparação funciona com wildcards
     * console.log(postPath.isDescendantOf('users/*\/posts')); // => true
     * ```
     */
    isDescendantOf(ancestorPath: string | PathInfo): boolean;
    /**
     * Verifica se o caminho atual e outro caminho estão na mesma "trilha".
     *
     * Dois caminhos estão na mesma trilha se um for ancestral do outro, ou se forem idênticos.
     * Essencialmente, isso verifica se um caminho é um prefixo do outro.
     * A comparação é flexível e lida com wildcards (`*`) e variáveis (`$name`).
     *
     * @param {string | PathInfo} otherPath O outro caminho a ser verificado.
     * @returns {boolean} Retorna `true` se os caminhos estiverem na mesma trilha, caso contrário `false`.
     *
     * @example
     * ```ts
     * const userPath = new PathInfo('users/123');
     * const userPostsPath = new PathInfo('users/123/posts');
     *
     * // Um ancestral está na trilha de seu descendente
     * console.log(userPath.isOnTrailOf(userPostsPath)); // => true
     *
     * // Um descendente está na trilha de seu ancestral
     * console.log(userPostsPath.isOnTrailOf(userPath)); // => true
     *
     * // Um caminho está na trilha de si mesmo
     * console.log(userPath.isOnTrailOf('users/123')); // => true
     *
     * // Caminhos não relacionados não estão na mesma trilha
     * console.log(userPath.isOnTrailOf('products/456')); // => false
     * ```
     */
    isOnTrailOf(otherPath: string | PathInfo): boolean;
    /**
     * Verifica se o caminho atual é um filho direto do caminho pai fornecido.
     *
     * @param {string | PathInfo} otherPath O caminho a ser verificado como pai.
     * @returns {boolean} Retorna `true` se o caminho atual for um filho direto, caso contrário `false`.
     *
     * @example
     * ```ts
     * const childPath = new PathInfo('users/123/posts');
     *
     * // 'users/123/posts' é um filho direto de 'users/123'
     * console.log(childPath.isChildOf('users/123')); // => true
     *
     * // Não é um filho direto de 'users'
     * console.log(childPath.isChildOf('users')); // => false
     * ```
     */
    isChildOf(otherPath: string | PathInfo): boolean;
    /**
     * Verifica se o caminho atual é o pai direto do caminho filho fornecido.
     *
     * @param {string | PathInfo} otherPath O caminho a ser verificado como filho.
     * @returns {boolean} Retorna `true` se o caminho atual for o pai direto, caso contrário `false`.
     *
     * @example
     * ```ts
     * const parentPath = new PathInfo('users/123');
     *
     * console.log(parentPath.isParentOf('users/123/posts')); // => true
     * console.log(parentPath.isParentOf('users/123/posts/post1')); // => false
     * ```
     */
    isParentOf(otherPath: string | PathInfo): boolean;
    /**
     * Um método de fábrica estático para criar uma nova instância de `PathInfo`.
     * É uma alternativa conveniente ao uso direto do construtor.
     *
     * @param {string | Array<string | number | PathInfo>} path O caminho a ser analisado. Pode ser uma string (ex: 'users/123') ou um array de segmentos de caminho.
     * @returns {PathInfo} Uma nova instância de `PathInfo`.
     *
     * @example
     * ```ts
     * const pathInfo = PathInfo.get('users/123/profile');
     * console.log(pathInfo.path); // => "users/123/profile"
     * console.log(pathInfo.key);  // => "profile"
     * ```
     */
    static get(path: string | Array<string | number | PathInfo>): PathInfo;
    /**
     * Um método utilitário estático para construir a string de um caminho filho.
     *
     * @param {string} path O caminho pai.
     * @param {string | number} childKey A chave ou índice do filho a ser anexado.
     * @returns {string} A string completa do caminho filho resultante.
     *
     * @example
     * ```ts
     * const userProfilePath = PathInfo.getChildPath('users/123', 'profile');
     * console.log(userProfilePath); // => "users/123/profile"
     *
     * const firstPostPath = PathInfo.getChildPath('users/123/posts', 0);
     * console.log(firstPostPath); // => "users/123/posts[0]"
     * ```
     */
    static getChildPath(path: string, childKey: string | number): string;
    /**
     * Analisa uma string de caminho e a converte em um array de seus segmentos (chaves).
     *
     * Este método estático fornece uma maneira pública de obter os segmentos de um caminho,
     * como chaves de objeto (string) ou índices de array (number).
     *
     * @param {string} path A string de caminho a ser analisada (ex: 'users/123/posts[0]').
     * @returns {Array<string | number>} Um array contendo os segmentos do caminho.
     *
     * @example
     * ```ts
     * const segments = PathInfo.getPathKeys('users/123/posts[0]/title');
     * console.log(segments);
     * // => ['users', '123', 'posts', 0, 'title']
     *
     * const userSegments = PathInfo.getPathKeys('users/ewout');
     * console.log(userSegments);
     * // => ['users', 'ewout']
     * ```
     */
    static getPathKeys(path: string): Array<string | number>;
    /**
     * (Internal) Analisa um caminho de template e extrai uma lista de suas chaves de variáveis.
     * Este método identifica wildcards (`*`) e variáveis nomeadas (`$name`) e retorna
     * um array com informações sobre elas, incluindo seus índices e nomes.
     *
     * @param {string} varPath O caminho do template contendo as variáveis (ex: 'users/$uid/posts/*').
     * @returns {(string | number)[]} Um array contendo os descritores das variáveis.
     *   - Para cada `*` ou `$name`, um índice numérico é adicionado.
     *   - Para cada `$name`, o nome completo (ex: '$uid') e o nome curto (ex: 'uid') também são adicionados.
     * @internal
     *
     * @example
     * ```ts
     * const keys = PathInfo.variablesKeys('users/$uid/posts/*');
     * // => [0, '$uid', 'uid', 1]
     *
     * const keys2 = PathInfo.variablesKeys('items/*');
     * // => [0]
     * ```
     */
    static variablesKeys(varPath: string): (string | number)[];
    /**
     * Extrai valores de um caminho completo (`fullPath`) que correspondem a variáveis
     * em um caminho de template (`varPath`).
     *
     * Este método compara a estrutura de um caminho de template, que pode conter wildcards (`*`)
     * e variáveis nomeadas (`$name`), com um caminho real. Se as estruturas corresponderem,
     * ele retorna um objeto contendo os valores extraídos.
     *
     * @param {string} varPath O caminho do template contendo as variáveis (ex: 'users/$uid/posts/*').
     * @param {string} fullPath O caminho completo e real do qual os valores serão extraídos.
     * @returns {PathInfoVariables}
     * Um objeto semelhante a um array com os valores extraídos.
     * - Os valores são acessíveis por índice numérico (ex: `vars[0]`).
     * - Variáveis nomeadas também são acessíveis pelo nome (ex: `vars.uid` e `vars.$uid`).
     * - Retorna um objeto com `length: 0` se os caminhos não corresponderem.
     *
     * @example
     * ```ts
     * const vars1 = PathInfo.extractVariables('users/$uid/posts/$postid', 'users/ewout/posts/post1');
     * // vars1 é: { 0: 'ewout', 1: 'post1', $uid: 'ewout', uid: 'ewout', $postid: 'post1', postid: 'post1', length: 2 }
     *
     * const vars2 = PathInfo.extractVariables('users/*\/posts/*\/$property', 'users/ewout/posts/post1/title');
     * // vars2 é: { 0: 'ewout', 1: 'post1', 2: 'title', $property: 'title', property: 'title', length: 3 }
     *
     * const vars3 = PathInfo.extractVariables('users/$user/friends[*]/$friend', 'users/dora/friends[4]/diego');
     * // vars3 é: { 0: 'dora', 1: 4, 2: 'diego', $user: 'dora', user: 'dora', $friend: 'diego', friend: 'diego', length: 3 }
     * ```
     */
    static extractVariables(varPath: string, fullPath: string): PathInfoVariables;
    /**
     * Preenche as variáveis em um caminho de template (`varPath`) com os valores
     * correspondentes de um caminho completo (`fullPath`).
     *
     * Este método cria um novo caminho substituindo wildcards (`*`) e variáveis nomeadas (`$name`)
     * no template pelos segmentos do caminho completo. Ele lança um erro se as estruturas
     * dos caminhos não forem compatíveis.
     *
     * @param {string} varPath O caminho do template contendo as variáveis (ex: 'users/$uid/posts/*').
     * @param {string} fullPath O caminho completo e real que fornecerá os valores para as variáveis.
     * @returns {string} Uma nova string de caminho com as variáveis preenchidas.
     *
     * @example
     * ```ts
     * const template = 'users/$uid/posts/*';
     * const concretePath = 'users/ewout/posts/post1/title';
     *
     * // O caminho resultante terá o mesmo comprimento que o template.
     * const filledPath = PathInfo.fillVariables(template, concretePath);
     * console.log(filledPath);
     * // => "users/ewout/posts/post1"
     * ```
     */
    static fillVariables(varPath: string, fullPath: string): string;
    /**
     * Preenche as variáveis em um caminho de template com valores de um objeto ou array.
     *
     * Este método substitui wildcards (`*`) e variáveis nomeadas (`$name`) em um caminho
     * de template pelos valores fornecidos em um objeto `vars`. A substituição é feita
     * com base na ordem das variáveis no caminho e nos índices numéricos do objeto `vars`.
     *
     * @param {string} varPath O caminho do template contendo as variáveis (ex: 'users/$uid/posts/*').
     * @param {any} vars Um objeto ou array-like contendo os valores para as variáveis.
     *   Deve ser compatível com o objeto retornado por `PathInfo.extractVariables`.
     * @returns {string} Uma nova string de caminho com as variáveis preenchidas.
     *
     * @example
     * ```ts
     * const template = 'users/$uid/posts/*';
     * const variables = { 0: 'ewout', 1: 'post123', uid: 'ewout' };
     *
     * const finalPath = PathInfo.fillVariables2(template, variables);
     * console.log(finalPath); // => "users/ewout/posts/post123"
     * ```
     */
    static fillVariables2(varPath: string, vars: Omit<PathInfoVariables, "length">): string;
}
export {};
//# sourceMappingURL=index.d.ts.map