import { Construct } from 'constructs';
import { AssetOptions, FileAssetPackaging } from './assets';
import { FingerprintOptions } from './fs';
import { Stack } from './stack';
/**
 * (experimental) Initialization properties for `AssetStaging`.
 *
 * @experimental
 */
export interface AssetStagingProps extends FingerprintOptions, AssetOptions {
    /**
     * (experimental) The source file or directory to copy from.
     *
     * @experimental
     */
    readonly sourcePath: string;
}
/**
 * (experimental) Stages a file or directory from a location on the file system into a staging directory.
 *
 * This is controlled by the context key 'aws:cdk:asset-staging' and enabled
 * by the CLI by default in order to ensure that when the CDK app exists, all
 * assets are available for deployment. Otherwise, if an app references assets
 * in temporary locations, those will not be available when it exists (see
 * https://github.com/aws/aws-cdk/issues/1716).
 *
 * The `stagedPath` property is a stringified token that represents the location
 * of the file or directory after staging. It will be resolved only during the
 * "prepare" stage and may be either the original path or the staged path
 * depending on the context setting.
 *
 * The file/directory are staged based on their content hash (fingerprint). This
 * means that only if content was changed, copy will happen.
 *
 * @experimental
 */
export declare class AssetStaging extends Construct {
    /**
     * (experimental) The directory inside the bundling container into which the asset sources will be mounted.
     *
     * @experimental
     */
    static readonly BUNDLING_INPUT_DIR = "/asset-input";
    /**
     * (experimental) The directory inside the bundling container into which the bundled output should be written.
     *
     * @experimental
     */
    static readonly BUNDLING_OUTPUT_DIR = "/asset-output";
    /**
     * (experimental) Clears the asset hash cache.
     *
     * @experimental
     */
    static clearAssetHashCache(): void;
    /**
     * Cache of asset hashes based on asset configuration to avoid repeated file
     * system and bundling operations.
     */
    private static assetCache;
    /**
     * (experimental) Absolute path to the asset data.
     *
     * If asset staging is disabled, this will just be the source path or
     * a temporary directory used for bundling.
     *
     * If asset staging is enabled it will be the staged path.
     *
     * IMPORTANT: If you are going to call `addFileAsset()`, use
     * `relativeStagedPath()` instead.
     *
     * @experimental
     */
    readonly absoluteStagedPath: string;
    /**
     * (experimental) The absolute path of the asset as it was referenced by the user.
     *
     * @experimental
     */
    readonly sourcePath: string;
    /**
     * (experimental) A cryptographic hash of the asset.
     *
     * @experimental
     */
    readonly assetHash: string;
    /**
     * (experimental) How this asset should be packaged.
     *
     * @experimental
     */
    readonly packaging: FileAssetPackaging;
    /**
     * (experimental) Whether this asset is an archive (zip or jar).
     *
     * @experimental
     */
    readonly isArchive: boolean;
    private readonly fingerprintOptions;
    private readonly hashType;
    private readonly assetOutdir;
    /**
     * A custom source fingerprint given by the user
     *
     * Will not be used literally, always hashed later on.
     */
    private customSourceFingerprint?;
    private readonly cacheKey;
    private readonly sourceStats;
    /**
     * @experimental
     */
    constructor(scope: Construct, id: string, props: AssetStagingProps);
    /**
     * (experimental) Return the path to the staged asset, relative to the Cloud Assembly (manifest) directory of the given stack.
     *
     * Only returns a relative path if the asset was staged, returns an absolute path if
     * it was not staged.
     *
     * A bundled asset might end up in the outDir and still not count as
     * "staged"; if asset staging is disabled we're technically expected to
     * reference source directories, but we don't have a source directory for the
     * bundled outputs (as the bundle output is written to a temporary
     * directory). Nevertheless, we will still return an absolute path.
     *
     * A non-obvious directory layout may look like this:
     *
     * ```
     *    CLOUD ASSEMBLY ROOT
     *      +-- asset.12345abcdef/
     *      +-- assembly-Stage
     *            +-- MyStack.template.json
     *            +-- MyStack.assets.json <- will contain { "path": "../asset.12345abcdef" }
     * ```
     *
     * @experimental
     */
    relativeStagedPath(stack: Stack): string;
    /**
     * Stage the source to the target by copying
     *
     * Optionally skip if staging is disabled, in which case we pretend we did something but we don't really.
     */
    private stageByCopying;
    /**
     * Stage the source to the target by bundling
     *
     * Optionally skip, in which case we pretend we did something but we don't really.
     */
    private stageByBundling;
    /**
     * Whether staging has been disabled
     */
    private get stagingDisabled();
    /**
     * Copies or moves the files from sourcePath to targetPath.
     *
     * Moving implies the source directory is temporary and can be trashed.
     *
     * Will not do anything if source and target are the same.
     */
    private stageAsset;
    /**
     * Determine the directory where we're going to write the bundling output
     *
     * This is the target directory where we're going to write the staged output
     * files if we can (if the hash is fully known), or a temporary directory
     * otherwise.
     */
    private determineBundleDir;
    /**
     * Bundles an asset to the given directory
     *
     * If the given directory already exists, assume that everything's already
     * in order and don't do anything.
     *
     * @param options Bundling options
     * @param bundleDir Where to create the bundle directory
     * @returns The fully resolved bundle output directory.
     */
    private bundle;
    private calculateHash;
}
