import * as z from "zod/v4";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";
import { SetupFingerprintInfo } from "./setupfingerprintinfo.js";
/**
 * Types of packages that can be built
 */
export declare const PackageTypeEnum: {
    readonly Cli: "cli";
    readonly Cloudformation: "cloudformation";
    readonly Helm: "helm";
    readonly OperatorImage: "operator-image";
    readonly SandboxBundle: "sandbox-bundle";
    readonly Terraform: "terraform";
};
/**
 * Types of packages that can be built
 */
export type PackageTypeEnum = ClosedEnum<typeof PackageTypeEnum>;
/**
 * Status of a package build
 */
export declare const PackageStatus: {
    readonly Pending: "pending";
    readonly Building: "building";
    readonly Ready: "ready";
    readonly Failed: "failed";
    readonly Canceled: "canceled";
};
/**
 * Status of a package build
 */
export type PackageStatus = ClosedEnum<typeof PackageStatus>;
/**
 * Configuration for Terraform package generation.
 */
export type ConfigTerraform = {
    /**
     * Human-friendly application name shown in generated install artifacts.
     */
    displayName?: string | null | undefined;
    /**
     * AWS regions supported by the environment that built this package.
     */
    supportedAwsRegions?: Array<string> | undefined;
    type: "terraform";
};
/**
 * Configuration for a sandbox bundle package.
 *
 * @remarks
 *
 * The bundle is a zip holding one Dockerfile that layers the published Alien sandbox agent
 * onto the vendor's base image; everything the builder writes is derived from these fields.
 */
export type ConfigSandboxBundle = {
    /**
     * Full reference of the published sandbox agent image copied into the bundle.
     */
    agentImage: string;
    /**
     * The base container image the sandbox filesystem starts from. A release-pushed image
     *
     * @remarks
     * arrives resolved onto the private registry template with its {region} token intact.
     */
    baseImage: string;
    /**
     * Object key the bundle is written under in every regional bundle store.
     */
    objectKey: string;
    /**
     * Regions whose bundle store must receive this bundle. Part of the build input hash,
     *
     * @remarks
     * so a newly supported region re-mints the bundle instead of silently missing it.
     */
    supportedAwsRegions?: Array<string> | undefined;
    type: "sandbox-bundle";
};
/**
 * Branding configuration for the Operator image.
 */
export type ConfigOperatorImage = {
    /**
     * Short brand slug used for generated resource names.
     */
    brand?: string | null | undefined;
    /**
     * Human-friendly display name for logs and startup messages
     */
    displayName: string;
    /**
     * Branded environment variable prefix (e.g., "ACME").
     */
    envPrefix?: string | null | undefined;
    /**
     * Branded Kubernetes/cloud label domain (e.g., "acme.dev").
     */
    labelDomain?: string | null | undefined;
    /**
     * Image name (e.g., "acme-operator")
     */
    name: string;
    type: "operator-image";
};
/**
 * Configuration for the Helm chart package
 */
export type ConfigHelm = {
    /**
     * Chart name (e.g., "acme-operator")
     */
    chartName: string;
    /**
     * Human-friendly description of the chart
     */
    description: string;
    type: "helm";
};
/**
 * Configuration for CloudFormation packages
 */
export type ConfigCloudformation = {
    /**
     * Human-friendly application name shown in generated install artifacts.
     */
    displayName?: string | null | undefined;
    /**
     * AWS regions supported by the environment that built this package.
     */
    supportedAwsRegions?: Array<string> | undefined;
    type: "cloudformation";
};
/**
 * Target OS and architecture for compiled binaries.
 *
 * @remarks
 *
 * Used as keys in package output maps (CLI binaries, Terraform providers, etc.)
 * and for cross-compilation target selection during builds.
 */
export declare const PackageBinaryTarget: {
    readonly WindowsX64: "windows-x64";
    readonly LinuxX64: "linux-x64";
    readonly LinuxArm64: "linux-arm64";
    readonly DarwinArm64: "darwin-arm64";
};
/**
 * Target OS and architecture for compiled binaries.
 *
 * @remarks
 *
 * Used as keys in package output maps (CLI binaries, Terraform providers, etc.)
 * and for cross-compilation target selection during builds.
 */
export type PackageBinaryTarget = ClosedEnum<typeof PackageBinaryTarget>;
/**
 * Branding configuration for the deploy CLI binary.
 */
export type ConfigCli = {
    /**
     * Binary targets required by this package's setup consumer.
     *
     * @remarks
     *
     * Older package rows omit this field and retain the historical all-target
     * behavior. Callers creating new packages should state their target set.
     */
    binaryTargets?: Array<PackageBinaryTarget> | undefined;
    /**
     * Human-friendly display name for help banners and about text
     */
    displayName: string;
    /**
     * Binary name displayed in help and usage (e.g., "acmectl")
     */
    name: string;
    type: "cli";
};
/**
 * Type-specific configuration
 */
export type Config = ConfigCli | ConfigCloudformation | ConfigHelm | ConfigOperatorImage | ConfigSandboxBundle | ConfigTerraform;
/**
 * Information about a single Terraform module package for one target.
 */
export type PackageModules = {
    /**
     * Download URL for the module archive
     */
    downloadUrl: string;
    /**
     * Filename of the module archive
     */
    filename: string;
    /**
     * SHA256 checksum of the archive
     */
    shasum: string;
    /**
     * Size of the archive in bytes
     */
    size: number;
    /**
     * Terraform module source (hostname/namespace/name/provider, without scheme)
     */
    source: string;
    /**
     * Terraform module target (aws, gcp, azure, eks, gke, aks)
     */
    target: string;
    /**
     * Terraform input variables exposed by this module.
     */
    variables?: Array<string> | undefined;
};
/**
 * GPG public key for Terraform provider signature verification
 */
export type PackageGpgPublicKey = {
    /**
     * ASCII-armored public key
     */
    asciiArmor: string;
    /**
     * GPG key ID
     */
    keyId: string;
};
/**
 * Information about a single Terraform provider package for a specific platform
 */
export type PackagePlatforms = {
    /**
     * Download URL for the provider zip
     */
    downloadUrl: string;
    /**
     * Filename of the provider zip
     */
    filename: string;
    /**
     * SHA256 checksum of the zip file
     */
    shasum: string;
    /**
     * URL to the shasums signature file
     */
    shasumsSignatureUrl: string;
    /**
     * URL to the shasums file
     */
    shasumsUrl: string;
    /**
     * Size of the zip file in bytes
     */
    size: number;
};
/**
 * Terraform provider registry outputs.
 */
export type PackageProvider = {
    /**
     * GPG public key for Terraform provider signature verification
     */
    gpgPublicKey: PackageGpgPublicKey;
    /**
     * Provider packages for each target platform
     */
    platforms: {
        [k: string]: PackagePlatforms;
    };
    /**
     * Terraform provider source (hostname/namespace/type, without scheme)
     */
    source: string;
};
export declare const OutputsTypeTerraform: {
    readonly Terraform: "terraform";
};
export type OutputsTypeTerraform = ClosedEnum<typeof OutputsTypeTerraform>;
/**
 * Outputs from a Terraform package build.
 */
export type OutputsTerraform = {
    /**
     * Module registry artifacts by Terraform target.
     */
    modules: {
        [k: string]: PackageModules;
    };
    /**
     * Terraform provider registry outputs.
     */
    provider: PackageProvider;
    type: OutputsTypeTerraform;
};
export declare const OutputsTypeSandboxBundle: {
    readonly SandboxBundle: "sandbox-bundle";
};
export type OutputsTypeSandboxBundle = ClosedEnum<typeof OutputsTypeSandboxBundle>;
/**
 * Outputs from a sandbox bundle package build.
 */
export type OutputsSandboxBundle = {
    /**
     * Bundle URI with the {region} token in the bucket, resolved by the deploy-time emitters.
     */
    bundleUriTemplate: string;
    /**
     * Object key the bundle was written under in every regional bundle store.
     */
    objectKey: string;
    /**
     * Regions whose bundle store received this bundle.
     */
    regions: Array<string>;
    /**
     * SHA256 checksum of the region-neutral bundle zip; a region-templated base image makes
     *
     * @remarks
     * each regional object differ from it only in the rendered region.
     */
    sha256: string;
    /**
     * Region-neutral bundle zip size in bytes.
     */
    size: number;
    type: OutputsTypeSandboxBundle;
};
/**
 * Information about a single CloudFormation template package for one target.
 */
export type PackageTargets = {
    /**
     * AWS Console quick-launch URL
     */
    launchStackUrl: string;
    /**
     * SHA256 checksum of the template
     */
    sha256: string;
    /**
     * Template size in bytes
     */
    size: number;
    /**
     * S3 URL to the CloudFormation stack policy
     */
    stackPolicyUrl: string;
    /**
     * CloudFormation target (aws, eks)
     */
    target: string;
    /**
     * S3 URL to the CloudFormation template
     */
    templateUrl: string;
};
export declare const OutputsTypeCloudformation: {
    readonly Cloudformation: "cloudformation";
};
export type OutputsTypeCloudformation = ClosedEnum<typeof OutputsTypeCloudformation>;
/**
 * Outputs from a CloudFormation package build.
 */
export type OutputsCloudformation = {
    /**
     * Template artifacts by CloudFormation target.
     */
    targets: {
        [k: string]: PackageTargets;
    };
    type: OutputsTypeCloudformation;
};
export declare const OutputsTypeHelm: {
    readonly Helm: "helm";
};
export type OutputsTypeHelm = ClosedEnum<typeof OutputsTypeHelm>;
/**
 * Outputs from a Helm chart package build
 */
export type OutputsHelm = {
    /**
     * OCI chart reference (e.g., "oci://public.ecr.aws/acme/charts/project-id")
     */
    chart: string;
    /**
     * Chart version (e.g., "1.2.3")
     */
    version: string;
    type: OutputsTypeHelm;
};
export declare const OutputsTypeOperatorImage: {
    readonly OperatorImage: "operator-image";
};
export type OutputsTypeOperatorImage = ClosedEnum<typeof OutputsTypeOperatorImage>;
/**
 * Outputs from an Operator image package build
 */
export type OutputsOperatorImage = {
    /**
     * Image digest (e.g., "sha256:abc123...")
     */
    digest: string;
    /**
     * Full image reference (e.g., "public.ecr.aws/acme/operators/project-id:1.2.3")
     */
    image: string;
    /**
     * DNS-style label domain embedded into the Operator binary, if whitelabeled.
     */
    labelDomain?: string | null | undefined;
    type: OutputsTypeOperatorImage;
};
/**
 * Information about a single binary artifact
 */
export type PackageBinaries = {
    /**
     * SHA256 checksum
     */
    sha256: string;
    /**
     * File size in bytes
     */
    size: number;
    /**
     * Download URL for the binary
     */
    url: string;
};
/**
 * Source provenance for a generated CLI package.
 */
export type PackageBuildInfo = {
    /**
     * Alien source commit used to build the source CLI and agent binaries.
     */
    alienSha: string;
    /**
     * Compute backend source revision used by optional package extensions, if applicable.
     */
    horizonSha: string;
    /**
     * Machine runtime release manifest embedded into the generated CLI.
     */
    machineBundleManifestUrl?: string | null | undefined;
    /**
     * Source revision used to build the package service and optional extensions.
     */
    platformSha: string;
    /**
     * SHA256 checksum of the source runtime helper binary shipped with the CLI package, when present.
     */
    sourceAgentBinarySha256?: string | null | undefined;
    /**
     * SHA256 checksum of the source deploy CLI binary before white-label config is appended.
     */
    sourceCliBinarySha256: string;
};
export declare const OutputsTypeCli: {
    readonly Cli: "cli";
};
export type OutputsTypeCli = ClosedEnum<typeof OutputsTypeCli>;
/**
 * Outputs from a CLI package build
 */
export type OutputsCli = {
    /**
     * Binary information for each target platform
     */
    binaries: {
        [k: string]: PackageBinaries;
    };
    /**
     * Source provenance for a generated CLI package.
     */
    buildInfo: PackageBuildInfo;
    type: OutputsTypeCli;
};
/**
 * Package outputs (only when status is 'ready')
 */
export type PackageOutputsUnion = OutputsSandboxBundle | OutputsCli | OutputsOperatorImage | OutputsHelm | OutputsTerraform | OutputsCloudformation | any;
/**
 * Coarse package build phase
 */
export declare const BuildPhase: {
    readonly Building: "building";
    readonly Publishing: "publishing";
};
/**
 * Coarse package build phase
 */
export type BuildPhase = ClosedEnum<typeof BuildPhase>;
export type Package = {
    /**
     * Unique identifier for the package.
     */
    id: string;
    /**
     * Unique identifier for the project.
     */
    projectId: string;
    /**
     * Unique identifier for the workspace.
     */
    workspaceId: string;
    /**
     * Types of packages that can be built
     */
    type: PackageTypeEnum;
    /**
     * Status of a package build
     */
    status: PackageStatus;
    /**
     * Package version (e.g., '1.0.0', 'rel_abc123')
     */
    version: string;
    /**
     * Release used as package build input. Null for release-less packages such as Operate Operator images.
     */
    sourceReleaseId?: string | null | undefined;
    /**
     * Per-target setup compatibility fingerprints copied from the source release
     */
    setupFingerprints: {
        [k: string]: SetupFingerprintInfo;
    };
    /**
     * Hash of Platform-known package build request inputs: package type, source release, setup fingerprints, package config, and setup contract version
     */
    packageBuildInputHash: string;
    /**
     * Type-specific configuration
     */
    config: ConfigCli | ConfigCloudformation | ConfigHelm | ConfigOperatorImage | ConfigSandboxBundle | ConfigTerraform;
    /**
     * Package outputs (only when status is 'ready')
     */
    outputs?: OutputsSandboxBundle | OutputsCli | OutputsOperatorImage | OutputsHelm | OutputsTerraform | OutputsCloudformation | any | null | undefined;
    /**
     * Error information if status is 'failed'
     */
    error?: any | null | undefined;
    /**
     * Builder-recorded source binary SHA256 (for cli/terraform packages)
     */
    sourceBinarySha256?: string | null | undefined;
    /**
     * Number of build retries
     */
    retries: number;
    lockedAt?: Date | null | undefined;
    lockedBy?: string | null | undefined;
    /**
     * Expiration of the current builder lease
     */
    leaseExpiresAt?: Date | null | undefined;
    /**
     * Coarse package build phase
     */
    buildPhase?: BuildPhase | null | undefined;
    /**
     * Last successful builder lease renewal or phase change
     */
    lastProgressAt?: Date | null | undefined;
    createdAt: Date;
    updatedAt: Date;
    completedAt?: Date | null | undefined;
};
/** @internal */
export declare const PackageTypeEnum$inboundSchema: z.ZodEnum<typeof PackageTypeEnum>;
/** @internal */
export declare const PackageStatus$inboundSchema: z.ZodEnum<typeof PackageStatus>;
/** @internal */
export declare const ConfigTerraform$inboundSchema: z.ZodType<ConfigTerraform, unknown>;
export declare function configTerraformFromJSON(jsonString: string): SafeParseResult<ConfigTerraform, SDKValidationError>;
/** @internal */
export declare const ConfigSandboxBundle$inboundSchema: z.ZodType<ConfigSandboxBundle, unknown>;
export declare function configSandboxBundleFromJSON(jsonString: string): SafeParseResult<ConfigSandboxBundle, SDKValidationError>;
/** @internal */
export declare const ConfigOperatorImage$inboundSchema: z.ZodType<ConfigOperatorImage, unknown>;
export declare function configOperatorImageFromJSON(jsonString: string): SafeParseResult<ConfigOperatorImage, SDKValidationError>;
/** @internal */
export declare const ConfigHelm$inboundSchema: z.ZodType<ConfigHelm, unknown>;
export declare function configHelmFromJSON(jsonString: string): SafeParseResult<ConfigHelm, SDKValidationError>;
/** @internal */
export declare const ConfigCloudformation$inboundSchema: z.ZodType<ConfigCloudformation, unknown>;
export declare function configCloudformationFromJSON(jsonString: string): SafeParseResult<ConfigCloudformation, SDKValidationError>;
/** @internal */
export declare const PackageBinaryTarget$inboundSchema: z.ZodEnum<typeof PackageBinaryTarget>;
/** @internal */
export declare const ConfigCli$inboundSchema: z.ZodType<ConfigCli, unknown>;
export declare function configCliFromJSON(jsonString: string): SafeParseResult<ConfigCli, SDKValidationError>;
/** @internal */
export declare const Config$inboundSchema: z.ZodType<Config, unknown>;
export declare function configFromJSON(jsonString: string): SafeParseResult<Config, SDKValidationError>;
/** @internal */
export declare const PackageModules$inboundSchema: z.ZodType<PackageModules, unknown>;
export declare function packageModulesFromJSON(jsonString: string): SafeParseResult<PackageModules, SDKValidationError>;
/** @internal */
export declare const PackageGpgPublicKey$inboundSchema: z.ZodType<PackageGpgPublicKey, unknown>;
export declare function packageGpgPublicKeyFromJSON(jsonString: string): SafeParseResult<PackageGpgPublicKey, SDKValidationError>;
/** @internal */
export declare const PackagePlatforms$inboundSchema: z.ZodType<PackagePlatforms, unknown>;
export declare function packagePlatformsFromJSON(jsonString: string): SafeParseResult<PackagePlatforms, SDKValidationError>;
/** @internal */
export declare const PackageProvider$inboundSchema: z.ZodType<PackageProvider, unknown>;
export declare function packageProviderFromJSON(jsonString: string): SafeParseResult<PackageProvider, SDKValidationError>;
/** @internal */
export declare const OutputsTypeTerraform$inboundSchema: z.ZodEnum<typeof OutputsTypeTerraform>;
/** @internal */
export declare const OutputsTerraform$inboundSchema: z.ZodType<OutputsTerraform, unknown>;
export declare function outputsTerraformFromJSON(jsonString: string): SafeParseResult<OutputsTerraform, SDKValidationError>;
/** @internal */
export declare const OutputsTypeSandboxBundle$inboundSchema: z.ZodEnum<typeof OutputsTypeSandboxBundle>;
/** @internal */
export declare const OutputsSandboxBundle$inboundSchema: z.ZodType<OutputsSandboxBundle, unknown>;
export declare function outputsSandboxBundleFromJSON(jsonString: string): SafeParseResult<OutputsSandboxBundle, SDKValidationError>;
/** @internal */
export declare const PackageTargets$inboundSchema: z.ZodType<PackageTargets, unknown>;
export declare function packageTargetsFromJSON(jsonString: string): SafeParseResult<PackageTargets, SDKValidationError>;
/** @internal */
export declare const OutputsTypeCloudformation$inboundSchema: z.ZodEnum<typeof OutputsTypeCloudformation>;
/** @internal */
export declare const OutputsCloudformation$inboundSchema: z.ZodType<OutputsCloudformation, unknown>;
export declare function outputsCloudformationFromJSON(jsonString: string): SafeParseResult<OutputsCloudformation, SDKValidationError>;
/** @internal */
export declare const OutputsTypeHelm$inboundSchema: z.ZodEnum<typeof OutputsTypeHelm>;
/** @internal */
export declare const OutputsHelm$inboundSchema: z.ZodType<OutputsHelm, unknown>;
export declare function outputsHelmFromJSON(jsonString: string): SafeParseResult<OutputsHelm, SDKValidationError>;
/** @internal */
export declare const OutputsTypeOperatorImage$inboundSchema: z.ZodEnum<typeof OutputsTypeOperatorImage>;
/** @internal */
export declare const OutputsOperatorImage$inboundSchema: z.ZodType<OutputsOperatorImage, unknown>;
export declare function outputsOperatorImageFromJSON(jsonString: string): SafeParseResult<OutputsOperatorImage, SDKValidationError>;
/** @internal */
export declare const PackageBinaries$inboundSchema: z.ZodType<PackageBinaries, unknown>;
export declare function packageBinariesFromJSON(jsonString: string): SafeParseResult<PackageBinaries, SDKValidationError>;
/** @internal */
export declare const PackageBuildInfo$inboundSchema: z.ZodType<PackageBuildInfo, unknown>;
export declare function packageBuildInfoFromJSON(jsonString: string): SafeParseResult<PackageBuildInfo, SDKValidationError>;
/** @internal */
export declare const OutputsTypeCli$inboundSchema: z.ZodEnum<typeof OutputsTypeCli>;
/** @internal */
export declare const OutputsCli$inboundSchema: z.ZodType<OutputsCli, unknown>;
export declare function outputsCliFromJSON(jsonString: string): SafeParseResult<OutputsCli, SDKValidationError>;
/** @internal */
export declare const PackageOutputsUnion$inboundSchema: z.ZodType<PackageOutputsUnion, unknown>;
export declare function packageOutputsUnionFromJSON(jsonString: string): SafeParseResult<PackageOutputsUnion, SDKValidationError>;
/** @internal */
export declare const BuildPhase$inboundSchema: z.ZodEnum<typeof BuildPhase>;
/** @internal */
export declare const Package$inboundSchema: z.ZodType<Package, unknown>;
export declare function packageFromJSON(jsonString: string): SafeParseResult<Package, SDKValidationError>;
//# sourceMappingURL=package.d.ts.map