import * as _backstage_backend_plugin_api from '@backstage/backend-plugin-api';
import { LoggerService, AuthService, CacheService, SchedulerService, SchedulerServiceTaskRunner } from '@backstage/backend-plugin-api';
import { CatalogProcessor, CatalogProcessorEmit, CatalogProcessorCache, EntityProvider, EntityProviderConnection } from '@backstage/plugin-catalog-node';
import { LocationSpec } from '@backstage/plugin-catalog-common';
import { Entity } from '@backstage/catalog-model';
import { ExtensionsPlugin, ExtensionsPackage, ExtensionsCollection } from '@red-hat-developer-hub/backstage-plugin-extensions-common';
import { DynamicPluginProvider } from '@backstage/backend-dynamic-feature-service';
import { CatalogApi } from '@backstage/catalog-client';
import { Config } from '@backstage/config';

/**
 * @public
 */
declare const catalogModuleExtensions: _backstage_backend_plugin_api.BackendFeature;

/**
 * @public
 */
declare class ExtensionsPluginProcessor implements CatalogProcessor {
    private readonly validators;
    getProcessorName(): string;
    validateEntityKind(entity: Entity): Promise<boolean>;
    postProcessEntity(entity: ExtensionsPlugin, _location: LocationSpec, emit: CatalogProcessorEmit): Promise<Entity>;
}
/**
 * @public
 * @deprecated Use ExtensionsPluginProcessor instead
 */
declare const MarketplacePluginProcessor: typeof ExtensionsPluginProcessor;

/**
 * @public
 */
declare class ExtensionsCollectionProcessor implements CatalogProcessor {
    private readonly validators;
    validateEntityKind(entity: Entity): Promise<boolean>;
    getProcessorName(): string;
    postProcessEntity(entity: Entity, _location: LocationSpec, emit: CatalogProcessorEmit): Promise<Entity>;
}
/**
 * @public
 * @deprecated Use ExtensionsCollectionProcessor instead
 */
declare const MarketplaceCollectionProcessor: typeof ExtensionsCollectionProcessor;

/**
 * @public
 */
type Plugins = {
    [pluginName: string]: string;
};
/**
 * @public
 */
type CachedData = {
    plugins: Plugins;
    cachedTime: number;
};
/**
 * @public
 */
declare class DynamicPackageInstallStatusProcessor implements CatalogProcessor {
    private readonly pluginProvider;
    private readonly logger;
    private readonly cacheTTLMilliseconds;
    constructor(deps: {
        logger: LoggerService;
        pluginProvider: DynamicPluginProvider;
    });
    getProcessorName(): string;
    getCachedPlugins(cache: CatalogProcessorCache, entityRef: string): Promise<CachedData>;
    /**
     * Determines if cached data is expired based on TTL
     *
     * @param cachedData - The cached data for this entity
     * @returns True if data is expired
     */
    private isExpired;
    private getPackageInstallStatus;
    preProcessEntity(entity: Entity, _location: LocationSpec, _emit: CatalogProcessorEmit, _originLocation: LocationSpec, cache: CatalogProcessorCache): Promise<Entity>;
}

/**
 * @public
 */
declare class LocalPackageInstallStatusProcessor implements CatalogProcessor {
    private workspacesPath;
    private customPaths;
    /**
     *
     * @param paths - pass the workspaces to find the installed packages. Defaults to backstage default workspaces ['packages/app', 'packages/backend']
     */
    constructor(paths?: string[]);
    getProcessorName(): string;
    findWorkspacesPath(startPath?: string): string;
    private isPackageInstalled;
    preProcessEntity(entity: ExtensionsPackage): Promise<ExtensionsPackage>;
}

/**
 * @public
 */
declare class ExtensionsPackageProcessor implements CatalogProcessor {
    private readonly validators;
    getProcessorName(): string;
    validateEntityKind(entity: Entity): Promise<boolean>;
    postProcessEntity(entity: ExtensionsPackage, _location: LocationSpec, emit: CatalogProcessorEmit): Promise<Entity>;
}
/**
 * @public
 * @deprecated Use ExtensionsPackageProcessor instead
 */
declare const MarketplacePackageProcessor: typeof ExtensionsPackageProcessor;

/**
 * @public
 */
declare class PluginInstallStatusProcessor implements CatalogProcessor {
    private readonly auth;
    private readonly catalog;
    private readonly logger;
    private readonly cache;
    private readonly cacheTTLSeconds;
    constructor(deps: {
        auth: AuthService;
        catalog: CatalogApi;
        logger: LoggerService;
        cache: CacheService;
        scheduler: SchedulerService;
    });
    getProcessorName(): string;
    private cachePackageInstallStatuses;
    private refreshPackages;
    private getPluginPackageInstallStatuses;
    private getPluginInstallStatus;
    preProcessEntity(entity: Entity, _location: LocationSpec, _emit: CatalogProcessorEmit, _originLocation: LocationSpec): Promise<Entity>;
}

/**
 * @public
 */
type JsonFileData<T> = {
    filePath: string;
    content: T;
};

/**
 * @public
 */
declare abstract class BaseEntityProvider<T extends Entity> implements EntityProvider {
    private connection?;
    private taskRunner;
    private config?;
    private readonly logger?;
    private static readonly EXTENSIONS_DIRECTORY;
    private static readonly DEPRECATED_MARKETPLACE_DIRECTORY;
    constructor(taskRunner: SchedulerServiceTaskRunner, config?: Config, logger?: LoggerService);
    abstract getProviderName(): string;
    abstract getKind(): string;
    private addProviderAnnotations;
    getEntities(allEntities: JsonFileData<T>[]): T[];
    connect(connection: EntityProviderConnection): Promise<void>;
    /**
     * Resolves a directory path (absolute or relative to process.cwd())
     * and checks if it exists and is a directory
     */
    private resolveAndValidateDirectory;
    /**
     * Gets the extensions directory path from config or falls back to hardcoded fallback directories
     * Priority:
     *   - configured directory (if specified)
     *   - 'opt/app-root/src/dynamic-plugins-root/extensions'
     *   - 'opt/app-root/src/dynamic-plugins-root/marketplace'
     *   - '/extensions' (filesystem root)
     *   - '/marketplace' (filesystem root)
     */
    private getExtensionsDirectory;
    run(): Promise<void>;
}

/**
 * @public
 */
declare class ExtensionsPluginProvider extends BaseEntityProvider<ExtensionsPlugin> {
    getKind(): string;
    getProviderName(): string;
}
/**
 * @public
 * @deprecated Use ExtensionsPluginProvider instead
 */
declare const MarketplacePluginProvider: typeof ExtensionsPluginProvider;

/**
 * @public
 */
declare class ExtensionsCollectionProvider extends BaseEntityProvider<ExtensionsCollection> {
    getKind(): string;
    getProviderName(): string;
}
/**
 * @public
 * @deprecated Use ExtensionsCollectionProvider instead
 */
declare const MarketplaceCollectionProvider: typeof ExtensionsCollectionProvider;

/**
 * @public
 */
declare class ExtensionsPackageProvider extends BaseEntityProvider<ExtensionsPackage> {
    getKind(): string;
    getProviderName(): string;
}
/**
 * @public
 * @deprecated Use ExtensionsPackageProvider instead
 */
declare const MarketplacePackageProvider: typeof ExtensionsPackageProvider;

export { BaseEntityProvider, type CachedData, DynamicPackageInstallStatusProcessor, ExtensionsCollectionProcessor, ExtensionsCollectionProvider, ExtensionsPackageProcessor, ExtensionsPackageProvider, ExtensionsPluginProcessor, ExtensionsPluginProvider, type JsonFileData, LocalPackageInstallStatusProcessor, MarketplaceCollectionProcessor, MarketplaceCollectionProvider, MarketplacePackageProcessor, MarketplacePackageProvider, MarketplacePluginProcessor, MarketplacePluginProvider, PluginInstallStatusProcessor, type Plugins, catalogModuleExtensions, catalogModuleExtensions as default };