import type { AuxiliaryIdentifierStrategy } from '../http/auxiliary/AuxiliaryIdentifierStrategy';
import type { ResourceSet } from '../storage/ResourceSet';
import type { ResourceStore } from '../storage/ResourceStore';
import type { IdentifierStrategy } from '../util/identifiers/IdentifierStrategy';
import type { AccessChecker } from './access/AccessChecker';
import type { PermissionReaderInput } from './PermissionReader';
import { PermissionReader } from './PermissionReader';
import type { PermissionMap } from './permissions/Permissions';
/**
 * Finds the permissions of a resource as defined in the corresponding ACL resource.
 * Does not make any deductions such as checking parent containers for create permissions
 * or applying control permissions for ACL resources.
 *
 * Specific access checks are done by the provided {@link AccessChecker}.
 */
export declare class WebAclReader extends PermissionReader {
    protected readonly logger: import("..").Logger;
    private readonly aclStrategy;
    private readonly resourceSet;
    private readonly aclStore;
    private readonly identifierStrategy;
    private readonly accessChecker;
    constructor(aclStrategy: AuxiliaryIdentifierStrategy, resourceSet: ResourceSet, aclStore: ResourceStore, identifierStrategy: IdentifierStrategy, accessChecker: AccessChecker);
    /**
     * Checks if an agent is allowed to execute the requested actions.
     * Will throw an error if this is not the case.
     */
    handle({ credentials, requestedModes }: PermissionReaderInput): Promise<PermissionMap>;
    /**
     * Finds the permissions in the provided WebACL quads.
     *
     * Rather than restricting the search to only the required modes,
     * we collect all modes in order to have complete metadata (for instance, for the WAC-Allow header).
     *
     * @param aclMap - A map containing stores of ACL data linked to their relevant identifiers.
     * @param credentials - Credentials to check permissions for.
     */
    private findPermissions;
    /**
     * Determines the available permissions for the given credentials.
     * @param acl - Store containing all relevant authorization triples.
     * @param credentials - Credentials to find the permissions for.
     */
    private determinePermissions;
    /**
     * Finds the ACL data relevant for all the given resources.
     * The input set will be modified in place.
     *
     * @param targets - Targets to find ACL data for.
     *
     * @returns A map linking ACL resources to the relevant identifiers.
     */
    private getAclMatches;
    /**
     * Finds the ACL document relevant for the given identifier,
     * following the steps defined in https://solidproject.org/TR/2021/wac-20210711#effective-acl-resource.
     *
     * @param identifier - {@link ResourceIdentifier} of which we need the ACL document.
     *
     * @returns The {@link ResourceIdentifier} of the relevant ACL document.
     */
    private getAclRecursive;
    /**
     * For every ACL/identifier combination it finds the relevant ACL triples for that identifier.
     * This is done in such a way that store results are reused for all matching identifiers.
     * The split is based on the `acl:accessTo` and `acl:default` triples.
     *
     * @param map - Map of matches that need to be filtered.
     */
    private findAuthorizationStatements;
    /**
     * Extracts all rules from the store that are relevant for the given target,
     * based on either the `acl:accessTo` or `acl:default` predicates.
     * @param store - Store to filter.
     * @param target - The identifier of which the acl rules need to be known.
     * @param directAcl - If the store contains triples from the direct acl resource of the target or not.
     *                    Determines if `acl:accessTo` or `acl:default` are used.
     *
     * @returns A store containing the relevant triples for the given target.
     */
    private filterStore;
}
