import type { ComponentIssue, IssueObject } from './component-issue';
import { ImportNonMainFiles } from './import-non-main-files';
import { MissingDependenciesOnFs } from './missing-dependencies-on-fs';
import { MissingDists } from './missing-dists';
import { MissingPackagesDependenciesOnFs } from './missing-packages-dependencies-on-fs';
import { MissingManuallyConfiguredPackages } from './missing-manually-configured-packages';
import { ParseErrors } from './parse-errors';
import { RelativeComponents } from './relative-components';
import { RelativeComponentsAuthored } from './relative-components-authored';
import { ResolveErrors } from './resolve-errors';
import { UntrackedDependencies } from './untracked-dependencies';
import { LegacyInsideHarmony } from './legacy-inside-harmony';
import { MultipleEnvs } from './multiple-envs';
import { MissingLinksFromNodeModulesToSrc } from './missing-links-from-nm-to-src';
import { CircularDependencies } from './circular-dependencies';
import { DuplicateComponentAndPackage } from './duplicate-component-and-package';
import { MergeConfigHasConflict } from './merge-config-has-conflict';
import { NonLoadedEnv } from './non-loaded-env';
import { ExternalEnvWithoutVersion } from './external-env-without-version';
import { RemovedDependencies } from './removed-dependencies';
import { SelfReference } from './self-reference';
import { ImportFromDirectory } from './import-from-directory';
import { DeprecatedDependencies } from './deprecated-dependencies';
import { RemovedEnv } from './removed-env';
export declare const IssuesClasses: {
    MissingPackagesDependenciesOnFs: typeof MissingPackagesDependenciesOnFs;
    MissingManuallyConfiguredPackages: typeof MissingManuallyConfiguredPackages;
    UntrackedDependencies: typeof UntrackedDependencies;
    ResolveErrors: typeof ResolveErrors;
    RelativeComponents: typeof RelativeComponents;
    RelativeComponentsAuthored: typeof RelativeComponentsAuthored;
    ParseErrors: typeof ParseErrors;
    MissingDists: typeof MissingDists;
    LegacyInsideHarmony: typeof LegacyInsideHarmony;
    MissingDependenciesOnFs: typeof MissingDependenciesOnFs;
    ImportNonMainFiles: typeof ImportNonMainFiles;
    MultipleEnvs: typeof MultipleEnvs;
    MissingLinksFromNodeModulesToSrc: typeof MissingLinksFromNodeModulesToSrc;
    CircularDependencies: typeof CircularDependencies;
    DuplicateComponentAndPackage: typeof DuplicateComponentAndPackage;
    MergeConfigHasConflict: typeof MergeConfigHasConflict;
    NonLoadedEnv: typeof NonLoadedEnv;
    ExternalEnvWithoutVersion: typeof ExternalEnvWithoutVersion;
    RemovedDependencies: typeof RemovedDependencies;
    RemovedEnv: typeof RemovedEnv;
    DeprecatedDependencies: typeof DeprecatedDependencies;
    SelfReference: typeof SelfReference;
    ImportFromDirectory: typeof ImportFromDirectory;
};
export type IssuesNames = keyof typeof IssuesClasses;
export declare class IssuesList {
    /**
     * only reason to have "issues" as public is to avoid the error "Types have separate declarations of a private property"
     * because it is used in the legacy as well. it's possible to remove it from bit-repo and install as a package, but it's not
     * convenient for now.
     */
    _issues: ComponentIssue[];
    constructor(
    /**
     * only reason to have "issues" as public is to avoid the error "Types have separate declarations of a private property"
     * because it is used in the legacy as well. it's possible to remove it from bit-repo and install as a package, but it's not
     * convenient for now.
     */
    _issues?: ComponentIssue[]);
    get count(): number;
    isEmpty(): boolean;
    outputForCLI(): string;
    toObject(): {
        type: string;
        description: string;
        data: any;
    }[];
    /**
     * @deprecated use toObjectIncludeDataAsString instead
     * this method changes the "data" prop to string, which can be unexpected, and at times both are needed, the raw and the string.
     * if you change to use `toObjectIncludeDataAsString`, make sure to call "dataAsString" instead of "data" when needed.
     */
    toObjectWithDataAsString(): {
        type: string;
        description: string;
        data: string;
    }[];
    add(issue: ComponentIssue): void;
    delete(IssueClass: typeof ComponentIssue): void;
    hasTagBlockerIssues(): boolean;
    getIssue<T extends ComponentIssue>(IssueClass: {
        new (): T;
    }): T | undefined;
    getIssueByName<T extends ComponentIssue>(issueType: IssuesNames): T | undefined;
    getAllIssues(): ComponentIssue[];
    getAllIssueNames(): string[];
    createIssue<T extends ComponentIssue>(IssueClass: {
        new (): T;
    }): T;
    getOrCreate<T extends ComponentIssue>(IssueClass: {
        new (): T;
    }): T;
    shouldBlockSavingInCache(): boolean;
    shouldBlockTagging(): boolean;
    filterNonTagBlocking(): IssuesList;
    toObjectIncludeDataAsString(): Array<IssueObject & {
        dataAsString: string;
    }>;
    serialize(): {
        type: string;
        data: string;
    }[];
    static deserialize(data: Record<string, any>): IssuesList;
}