import { User } from '../icc-api/model/User';
import { HealthcareParty } from '../icc-api/model/HealthcareParty';
import { Patient } from '../icc-api/model/Patient';
import { Device } from '../icc-api/model/Device';
import { CryptoActorStub, CryptoActorStubWithType } from '../icc-api/model/CryptoActorStub';
import { DataOwnerTypeEnum } from '../icc-api/model/DataOwnerTypeEnum';
import { AuthenticationProvider } from './auth/AuthenticationProvider';
import { IccDataownerApi } from '../icc-api/api/IccDataownerApi';
import { DataOwnerWithType } from '../icc-api/model/DataOwnerWithType';
export type DataOwnerOrStub = DataOwner | CryptoActorStub;
export type DataOwner = HealthcareParty | Patient | Device;
/**
 * Extended API for managing data owners (healthcare parties, patients, and devices).
 * Provides methods to retrieve data owner information, manage hierarchies, and handle cryptographic keys.
 */
export declare class IccDataOwnerXApi extends IccDataownerApi {
    private currentDataOwnerType;
    private currentDataOwnerHierarchyIds;
    private get selfDataOwnerId();
    constructor(host: string, headers: {
        [key: string]: string;
    }, authenticationProvider?: AuthenticationProvider, fetchImpl?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
    /**
     * Gets the public keys of a data owner to be used for encryption with RSA-OAEP+SHA-1, in hex format.
     * @param dataOwner a data owner.
     * @return the public keys for the data owner in hex format.
     */
    getHexPublicKeysWithSha1Of(dataOwner: DataOwnerOrStub): Set<string>;
    /**
     * Gets the public keys of a data owner to be used for encryption with RSA-OAEP+SHA-256, in hex format.
     * @param dataOwner a data owner.
     * @return the public keys for the data owner in hex format.
     */
    getHexPublicKeysWithSha256Of(dataOwner: DataOwnerOrStub): Set<string>;
    /**
     * Gets all public keys of a data owner to be used for encryption, in hex format. Note that this may include keys that should be used for different
     * encryption algorithms.
     */
    getHexPublicKeysOf(dataOwner: DataOwnerOrStub): Set<string>;
    /**
     * Gets the crypto actor stub for the current data owner. This is a lightweight representation containing only
     * cryptographic information without full data owner details.
     * @return the crypto actor stub of the current data owner.
     * @throws if the current user is not a data owner.
     */
    getCurrentDataOwnerStub(): Promise<CryptoActorStubWithType>;
    /**
     * If the logged user is a data owner get the current data owner. This information is cached without expiration, and will only be updated in case
     * of forced refresh.
     * @throws if the current user is not a data owner.
     */
    getCurrentDataOwnerId(): Promise<string>;
    /**
     * If the logged user is a data owner get its parent hierarchy. This information is cached without expiration, and will only be updated in case
     * of forced refresh.
     * The resulting array starts with the topmost parent (the only ancestor without a parent) and ends with the data owner itself.
     * @throws if the current user is not a data owner.
     */
    getCurrentDataOwnerHierarchyIds(): Promise<string[]>;
    /**
     * Get the hierarchy for the current data owner starting from the specified parent.
     * @param parentId the id of a parent in the current data owner hierarchy.
     * @return an array starting at the topmost parent and ending at the provided parent id.
     * @throws if the provided id is not part of the data owner hierarchy.
     */
    getCurrentDataOwnerHierarchyIdsFrom(parentId: string): Promise<string[]>;
    /**
     * If the logged user is a data owner get the current data owner and all of his parents.
     * @throws if the current user is not a data owner.
     * @return the current data owner hierarchy, starting from the topmost parent to the current data owner.
     */
    getCurrentDataOwnerHierarchy(): Promise<DataOwnerWithType[]>;
    /**
     * If the logged user is a data owner get the type of the current data owner. This information is cached.
     * @throws if the current user is not a data owner
     */
    getCurrentDataOwnerType(): Promise<DataOwnerTypeEnum>;
    /**
     * Get the id of the data owner entity for a user.
     * @param user a user that is also a data owner.
     * @return the id of the data owner corresponding to the provided user.
     * @throws if the user is not a data owner.
     */
    getDataOwnerIdOf(user: User): string;
    /**
     * Get a data owner. Note that this does not decrypt patient data owners.
     * @param ownerId id of the data owner to retrieve (patient, medical device, hcp, ...)
     * @return the data owner with the provided id
     * @throws if you have no access to the data owner. Use {@link getCryptoActorStub}.
     */
    getDataOwner(ownerId: string): Promise<DataOwnerWithType>;
    /**
     * Get a crypto actor stub for a data owner.
     * @param ownerId id of the data owner for which you want to retrieve the stub (patient, medical device, hcp, ...)
     * @return the crypto actor stub of the data owner with the provided id
     */
    getCryptoActorStub(ownerId: string): Promise<CryptoActorStubWithType>;
    /**
     * Clears the cache of current data owner id and parent hierarchy ids. The hierarchy of a data owner should not normally change over time, so this
     * method should be rarely needed.
     */
    clearCurrentDataOwnerIdsCache(): void;
    private checkDataOwnerIntegrity;
    private forceLoadCurrentDataOwnerHierarchyAndCacheIds;
}
