/**
 * @typedef {import('./project.mjs').Project} Project
 * @typedef {import('./milestone.mjs').Milestone} Milestone
 */
/**
 * @typedef {Object} DecodedRepositoryName
 * @property {string} [base]
 * @property {string} [group]
 * @property {string} [repository]
 * @property {string} [branch]
 */
/**
 * @typedef {Object} MessageDestination
 * Endpoint to deliver log messages to.
 * @property {function(string):void} info
 * @property {function(string):void} debug
 * @property {function(string):void} warn
 * @property {function(string):void} error
 * @property {function(string):void} trace
 */
/**
 * @param {Object} [options]
 * @param {string} [options.url]
 * @param {MessageDestination} [options.messageDestination]
 * @property {MessageDestination} messageDestination
 * @property {string} url
 * @property {string} api
 */
export class BaseProvider extends BaseObject {
    /**
     * Prefix used to form environment variables.
     * 'GITHUB_' -> 'GITHUB_TOKEN'
     * @return {string} identifier for environment options
     */
    static get instanceIdentifier(): string;
    /**
     * Extract options suitable for the constructor.
     * Form the given set of environment variables.
     * Object with the detected key value pairs is delivered.
     * @param {Object} [env] as from process.env
     * @param {string} instanceIdentifier part of variable name.
     * @return {Object|undefined} undefined if no suitable environment variables have been found
     */
    static optionsFromEnvironment(env?: any, instanceIdentifier?: string): any | undefined;
    /**
     * Check if given options are sufficient to create a provider.
     * @param {Object} options
     * @return {boolean} true if options ar sufficient to construct a provider
     */
    static areOptionsSufficcient(options: any): boolean;
    static get attributes(): {
        /**
         * Name of the provider.
         */
        name: {
            env: string;
            type: string;
            isKey: boolean;
            writable: boolean;
            mandatory: boolean;
            private?: boolean;
            depends?: string;
            additionalAttributes: string[];
            description?: string;
            default?: any;
            set?: Function;
            get?: Function;
        };
        url: import("pacc").AttributeDefinition;
        description: import("pacc").AttributeDefinition;
        priority: import("pacc").AttributeDefinition;
        /**
         * To forward info/warn and error messages to
         */
        messageDestination: {
            type: string;
            default: Console;
            writable: boolean;
            private: boolean;
            isKey: boolean;
            mandatory: boolean;
            depends?: string;
            additionalAttributes: string[];
            description?: string;
            set?: Function;
            get?: Function;
            env?: string[] | string;
        };
    };
    /**
     * @typedef {Object} parsedName
     *
     */
    /**
     * Creates a new provider for a given set of options.
     * @param {Object} options additional options
     * @param {string} [options.instanceIdentifier] name of the provider instance
     * @param {string} [options.description]
     * @param {Object} env taken from process.env
     * @return {BaseProvider|undefined} newly created provider or undefined if options are not sufficient to construct a provider
     */
    static initialize(options: {
        instanceIdentifier?: string;
        description?: string;
    }, env: any): BaseProvider | undefined;
    get priority(): number;
    /**
     * @param {any} other
     * @return {boolean} true if other provider is the same as the receiver
     */
    equals(other: any): boolean;
    /**
     * All supported base urls.
     * For github something like:
     * - git@github.com
     * - git://github.com
     * - git+ssh://github.com
     * - https://github.com
     * - git+https://github.com
     * By default we provide provider name with ':'.
     * @return {string[]} common base urls of all repositories
     */
    get repositoryBases(): string[];
    /**
     * Does the provider support the base name.
     * @param {string} [base] to be checked
     * @return {boolean} true if base is supported or base is undefined
     */
    supportsBase(base?: string): boolean;
    /**
     * Bring a repository name into its normal form by removing any clutter.
     * Like .git suffix or #branch names.
     * @param {string} name
     * @param {boolean} forLookup
     * @return {string|undefined} normalized name
     */
    normalizeRepositoryName(name: string, forLookup: boolean): string | undefined;
    /**
     * Bring a group name into its normal form by removing any clutter.
     * Like .git suffix or #branch names.
     * @param {string} name
     * @param {boolean} forLookup
     * @return {string|undefined} normalized name
     */
    normalizeGroupName(name: string, forLookup: boolean): string | undefined;
    /**
     * Are repository names case sensitive.
     * Overwrite and return false if you want to have case insensitive repository lookup.
     * @return {boolean} true
     */
    get areRepositoryNamesCaseSensitive(): boolean;
    /**
     * Are repositroy group names case sensitive.
     * Overwrite and return false if you want to have case insensitive group lookup.
     * @return {boolean} true
     */
    get areGroupNamesCaseSensitive(): boolean;
    /**
     * Parses repository name and tries to split it into
     * base, group, repository and branch.
     * @param {string} [name]
     * @param {string} focus where lies the focus if only one path component is given
     * @returns {DecodedRepositoryName} result
     */
    parseName(name?: string, focus?: string): DecodedRepositoryName;
    /**
     * Create a repository.
     * @param {string} name of group and repository
     * @param {Object} [options]
     * @returns {Promise<Repository>}
     */
    createRepository(name: string, options?: any): Promise<Repository>;
    /**
     * List provider objects of a given type.
     *
     * @param {string} type name of the method to deliver typed iterator projects,milestones,hooks,repositories,branches,tags
     * @param {string[]} patterns group / repository filter
     * @return {AsyncIterable<Repository|PullRequest|Branch|Tag|Project|Milestone|Hook>} all matching repositories of the providers
     */
    list(type: string, patterns: string[]): AsyncIterable<Repository | PullRequest | Branch | Tag | Project | Milestone | Hook>;
    /**
     * List projects.
     * @param {string[]|string} [patterns]
     * @return {AsyncIterable<Project>} all matching projects of the provider
     */
    projects(patterns?: string[] | string): AsyncIterable<Project>;
    /**
     * List milestones.
     * @param {string[]|string} [patterns]
     * @return {AsyncIterable<Milestone>} all matching milestones of the provider
     */
    milestones(patterns?: string[] | string): AsyncIterable<Milestone>;
    /**
     * List repositories.
     * @param {string[]|string} [patterns]
     * @return {AsyncIterable<Repository>} all matching repos of the provider
     */
    repositories(patterns?: string[] | string): AsyncIterable<Repository>;
    /**
     * List branches.
     * @param {string[]|string} [patterns]
     * @return {AsyncIterable<Branch>} all matching branches of the provider
     */
    branches(patterns?: string[] | string): AsyncIterable<Branch>;
    /**
     * List tags.
     * @param {string[]|string} [patterns]
     * @return {AsyncIterable<Tag>} all matching tags of the provider
     */
    tags(patterns?: string[] | string): AsyncIterable<Tag>;
    /**
     * List hooks.
     * @param {string[]|string} [patterns]
     * @return {AsyncIterable<Hook>} all matching hooks of the provider
     */
    hooks(patterns?: string[] | string): AsyncIterable<Hook>;
    /**
     * List pull requests.
     * @param {string[]|string} [patterns]
     * @return {AsyncIterable<PullRequest>} all matching pullRequests of the provider
     */
    pullRequests(patterns?: string[] | string): AsyncIterable<PullRequest>;
    /**
     * Deliver the provider name.
     * @return {string} class name by default
     */
    get name(): string;
    /**
     * We are our own provider.
     * @return {BaseProvider} this
     */
    get provider(): BaseProvider;
    /**
     * List all defined entries from attributes.
     * @return {{name: string}}
     */
    toJSON(): {
        name: string;
    };
    initializeRepositories(): void;
    trace(...args: any[]): any;
    debug(...args: any[]): any;
    info(...args: any[]): any;
    warn(...args: any[]): any;
    error(...args: any[]): any;
    get repositoryGroupClass(): typeof RepositoryGroup;
    get hookClass(): typeof Hook;
    get repositoryClass(): typeof Repository;
    get branchClass(): typeof Branch;
    get tagClass(): typeof Tag;
    get pullRequestClass(): typeof PullRequest;
}
export type Project = import("./project.mjs").Project;
export type Milestone = import("./milestone.mjs").Milestone;
export type DecodedRepositoryName = {
    base?: string;
    group?: string;
    repository?: string;
    branch?: string;
};
/**
 * Endpoint to deliver log messages to.
 */
export type MessageDestination = {
    info: (arg0: string) => void;
    debug: (arg0: string) => void;
    warn: (arg0: string) => void;
    error: (arg0: string) => void;
    trace: (arg0: string) => void;
};
import { BaseObject } from "./base-object.mjs";
import { Repository } from "./repository.mjs";
import { PullRequest } from "./pull-request.mjs";
import { Branch } from "./branch.mjs";
import { Tag } from "./tag.mjs";
import { Hook } from "./hook.mjs";
import { RepositoryGroup } from "./repository-group.mjs";