import express from 'express';
import { Config } from '@backstage/config';
import * as _backstage_backend_plugin_api from '@backstage/backend-plugin-api';
import { DatabaseService, LoggerService, AuthService, SchedulerService, DiscoveryService } from '@backstage/backend-plugin-api';
import { RepositoryReportResponse, RenovateReport, TargetRepo, RenovateWrapper } from '@secustor/backstage-plugin-renovate-common';
import { QueueFactory, RunOptions, Runnable, AddResult } from '@secustor/backstage-plugin-renovate-node';
import { Entity } from '@backstage/catalog-model';

declare class DatabaseHandler {
    private client;
    private logger;
    static create(options: DatabaseCreationParameters): Promise<DatabaseHandler>;
    private constructor();
    addReport(options: AddReportParameters): Promise<void>;
    getReports(query?: ReportQueryParameters): Promise<RepositoryReportResponse>;
    getTargets(table?: 'reports' | 'dependencies'): Promise<ReportTargetQuery[]>;
    deleteReportsByTarget({ host, repository }: ReportTargetQuery, options?: DeleteOptions): Promise<number>;
    deleteReports(options?: DeleteOptions): Promise<number>;
    private updateDependencies;
    getDependencies(filters: DependenciesFilter, pagination?: Partial<PaginationOptions>): Promise<Pagination<DependencyRow[]>>;
    getDependenciesCount(filters: DependenciesFilter): Promise<number>;
    private applyDependencyFilters;
    /**
     * Gets the available values for the dependencies stored in the database.
     * If filters are supplied, OTHER values are filtered accordingly, if a filter is supplied, all values are returned
     * @param filters
     */
    getDependenciesValues(filters?: DependencyValueFilters): Promise<DependencyValues>;
    deleteDependencies(options: DeleteOptions): Promise<number>;
    deleteDependenciesByTarget({ host, repository }: ReportTargetQuery, options?: DeleteOptions): Promise<number>;
}

interface RouterOptions {
    auth: AuthService;
    rootConfig: Config;
    logger: LoggerService;
    databaseHandler: DatabaseHandler;
    runtimes: Map<string, RenovateWrapper>;
    queueFactories: Map<string, QueueFactory<RunOptions>>;
    scheduler: SchedulerService;
    discovery: DiscoveryService;
}
interface DependencyRow {
    id?: string;
    run_id: string;
    host: string;
    repository: string;
    extractionTimestamp: Date;
    manager: string;
    datasource: string;
    packageFile: string;
    depName: string;
    packageName?: string;
    depType?: string;
    currentValue?: string;
    currentVersion?: string;
    currentVersionTimestamp?: Date;
    skipReason?: string;
    registryUrl?: string;
    sourceUrl?: string;
    currentVersionReleased?: Date;
}
interface ReportTargetQuery {
    host?: string;
    repository?: string;
}
interface DeleteOptions {
    /**
     * If falsely (0, false or undefined) delete all reports
     * If keepLatest is a number keep this number of records.
     * In case it is boolean true, the behaviour is identical to 1
     */
    keepLatest?: boolean | number;
}
interface DatabaseCreationParameters {
    database: DatabaseService;
    logger: LoggerService;
}
interface ReportQueryParameters {
    host?: string;
    repository?: string;
}
interface AddReportParameters {
    runID: string;
    taskID: string;
    report: RenovateReport;
    target: TargetRepo;
    logger?: LoggerService;
}
interface DependenciesFilter extends DependencyValueFilters {
    latestOnly?: boolean;
}
declare const DependencyValueFiltersKeys: readonly ["datasource", "depName", "depType", "host", "manager", "packageFile", "repository"];
type DependencyValueFiltersKey = (typeof DependencyValueFiltersKeys)[number];
type DependencyValueFilters = Partial<Record<DependencyValueFiltersKey, string[]>>;
type DependencyValues = Record<DependencyValueFiltersKey, string[]>;
interface PaginationOptions {
    page: number;
    pageSize: number;
}
interface Pagination<T> {
    result: T;
    page: number;
    pageSize: number;
    pageCount: number;
    total: number;
}

declare class RenovateRunner implements Runnable<RunOptions> {
    private readonly databaseHandler;
    private readonly rootConfig;
    readonly logger: LoggerService;
    private readonly runtimes;
    private readonly queue;
    constructor(queueFactories: Map<string, QueueFactory<RunOptions>>, databaseHandler: DatabaseHandler, rootConfig: Config, logger: LoggerService, runtimes: Map<string, RenovateWrapper>);
    static from(options: RouterOptions): Promise<RenovateRunner>;
    addToQueue(...targets: (string | Entity | TargetRepo)[]): Promise<AddResult[]>;
    runNext(target: string | Entity | TargetRepo): Promise<AddResult>;
    run(props: RunOptions): Promise<void>;
    renovate({ id, target }: RunOptions, logger: LoggerService): Promise<RenovateReport>;
}

declare function createRouter(runner: RenovateRunner, options: RouterOptions): Promise<express.Router>;

/**
 * Renovate backend plugin
 *
 * @public
 */
declare const renovatePlugin: _backstage_backend_plugin_api.BackendFeature;

export { createRouter, renovatePlugin as default };