import type { Result } from 'true-myth';
import type { PackFormat } from '../pack-emitter/pack-emitter.ts';
import type { ProgressBroadcaster as ProgressBroadcasterBase } from '../progress/progress-broadcaster.ts';
import type { BuildReport as ReportBuildReport } from '../report/aggregator/report-types.ts';
import type { PackageReleaseDiff } from '../report/release-diff/file-set-diff.ts';
import type { BuildAndPublishResult } from './package-processor.ts';
import type { CheckError, ResolvedPackage } from './resolved-package.ts';
import type { PartialError } from './scheduler.ts';
export type UnsatisfiedPeerDependency = {
    readonly packageName: string;
    readonly peer: string;
};
export declare const packPackageFailureType: {
    readonly bundleDependenciesUnsupported: "bundle-dependencies-unsupported";
    readonly packageNotFound: "package-not-found";
    readonly peerDependenciesUnsatisfied: "peer-dependencies-unsatisfied";
    readonly vendorInvalidDependencyName: "vendor-invalid-dependency-name";
    readonly vendorSymlinkTargetOutsidePackage: "vendor-symlink-target-outside-package";
};
type PeerDependenciesUnsatisfiedFailure = {
    readonly type: typeof packPackageFailureType.peerDependenciesUnsatisfied;
    readonly packageName: string;
    readonly items: readonly UnsatisfiedPeerDependency[];
};
type VendorSymlinkOutsidePackageFailure = {
    readonly type: typeof packPackageFailureType.vendorSymlinkTargetOutsidePackage;
    readonly packageName: string;
    readonly vendoredPackageName: string;
    readonly entryRelativePath: string;
    readonly resolvedTargetPath: string;
};
type VendorInvalidDependencyNameFailure = {
    readonly type: typeof packPackageFailureType.vendorInvalidDependencyName;
    readonly packageName: string;
    readonly sourcePackageName: string | undefined;
    readonly invalidDependencyName: string;
};
export type PackPackageFailure = PeerDependenciesUnsatisfiedFailure | VendorInvalidDependencyNameFailure | VendorSymlinkOutsidePackageFailure | {
    readonly type: typeof packPackageFailureType.bundleDependenciesUnsupported;
    readonly packageName: string;
} | {
    readonly type: typeof packPackageFailureType.packageNotFound;
    readonly packageName: string;
};
export type BuildAndPublishAllOptions = {
    readonly dryRun: boolean;
    readonly stage: boolean;
    readonly collectReport?: boolean;
};
export type ResolveAndLinkAllOptions = {
    readonly collectReport?: boolean;
};
export type BuildReport = ReportBuildReport;
export declare const configErrorType = "config";
export declare const partialFailureType = "partial";
export declare const releaseAnalysisClassification: {
    readonly dependencyOnly: "dependency-only";
    readonly firstPublish: "first-publish";
    readonly substantive: "substantive";
    readonly unchanged: "unchanged";
};
export type PublishAllOutcome = {
    readonly result: PublishAllResult;
    readonly getReport: () => BuildReport | undefined;
};
export type ResolveAndLinkAllOutcome = {
    readonly result: ResolveAndLinkAllResult;
    readonly getReport: () => BuildReport | undefined;
};
export type ConfigError = {
    type: typeof configErrorType;
    issues: readonly string[];
};
export type PublishFailure = CheckError | ConfigError | (PartialError<BuildAndPublishResult> & {
    type: typeof partialFailureType;
});
export type PublishAllResult = Result<readonly BuildAndPublishResult[], PublishFailure>;
export type PartialErrorResult = {
    type: typeof partialFailureType;
    error: PartialError<ResolvedPackage>;
};
export type ResolveAndLinkFailure = CheckError | ConfigError | PartialErrorResult;
export type ResolveAndLinkAllResult = Result<readonly ResolvedPackage[], ResolveAndLinkFailure>;
export type ReleaseDiffFailure = CheckError | ConfigError | (PartialError<PackageReleaseDiff> & {
    type: typeof partialFailureType;
});
export type ReleaseDiffAllResult = Result<readonly PackageReleaseDiff[], ReleaseDiffFailure>;
export type ReleaseDiffAllOutcome = {
    readonly result: ReleaseDiffAllResult;
    readonly getReport: () => BuildReport;
};
export type PackageReleaseAnalysisClassification = (typeof releaseAnalysisClassification)[keyof typeof releaseAnalysisClassification];
export type PackageReleaseAnalysis = {
    readonly classification: PackageReleaseAnalysisClassification;
    readonly latestPublishedAt?: Date | undefined;
    readonly latestPublishedVersion?: string | undefined;
    readonly name: string;
};
export type ReleaseAnalysis = {
    readonly classification: PackageReleaseAnalysisClassification;
    readonly mostRecentPublishedAt?: Date | undefined;
    readonly packageAnalyses: readonly PackageReleaseAnalysis[];
};
export type ReleaseAnalysisFailure = CheckError | ConfigError | (PartialError<PackageReleaseAnalysis> & {
    type: typeof partialFailureType;
});
export type ReleaseAnalysisResult = Result<ReleaseAnalysis, ReleaseAnalysisFailure>;
export type ReleaseAnalysisOutcome = {
    readonly result: ReleaseAnalysisResult;
    readonly getReport: () => BuildReport;
};
export type ReleasePlanRegistryMetadata = {
    readonly version: string;
    readonly publishedAt: Date | undefined;
    readonly gitHead: string | undefined;
};
export type ReleasePlanPackage = {
    readonly name: string;
    readonly previousVersion: string | undefined;
    readonly nextVersion: string;
    readonly artifactState: 'changed' | 'first-publish' | 'unchanged';
    readonly changed: boolean;
    readonly previousGitHead: string | undefined;
    readonly currentGitHead: string | undefined;
    readonly latestRegistryMetadata: ReleasePlanRegistryMetadata | undefined;
    readonly artifactFiles: readonly string[];
    readonly changedArtifactFiles: readonly string[];
    readonly sourceFiles: readonly string[];
    readonly changelogSourceFiles: readonly string[];
};
export type ReleasePlan = {
    readonly packages: readonly ReleasePlanPackage[];
};
export type ReleasePlanFailure = CheckError | ConfigError | (PartialError<ReleasePlanPackage> & {
    type: typeof partialFailureType;
});
export type ReleasePlanResult = Result<ReleasePlan, ReleasePlanFailure>;
export type ReleasePlanOutcome = {
    readonly result: ReleasePlanResult;
    readonly getReport: () => BuildReport;
};
export type PackPublicOptions = {
    readonly packageName: string;
    readonly format: PackFormat;
    readonly outputPath: string;
    readonly version: string;
    readonly vendorDependencies: boolean;
};
export type PackFailure = CheckError | ConfigError | PackPackageFailure | PartialErrorResult;
export type PackResult = Result<undefined, PackFailure>;
export type PackOutcome = {
    readonly result: PackResult;
};
export {};
//# sourceMappingURL=packtory-results.d.ts.map