import * as Config from "effect/Config";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as Argument from "effect/unstable/cli/Argument";
import * as Flag from "effect/unstable/cli/Flag";
import { type AuthProvider, AuthProviders } from "../../Auth/AuthProvider.ts";
import { type AlchemyProfileProviders } from "../../Auth/Profile.ts";
import * as Stack from "../../Stack.ts";
import { Stage } from "../../Stage.ts";
export declare const USER: Config.Config<string>;
export declare const STAGE: Effect.Effect<string | undefined, Config.ConfigError, never>;
/**
 * Catches user cancellations (Ctrl+C inside a prompt, surfaced as
 * {@link PromptCancelled} or wrapped in an {@link AuthError}) and exits
 * the CLI cleanly with a friendly message instead of dumping a stack
 * trace.
 */
export declare const handleCancellation: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void | A, E, R>;
export declare const stage: Flag.Flag<string>;
export declare const envFile: Flag.Flag<Option.Option<string>>;
export declare const dryRun: Flag.Flag<boolean>;
export declare const yes: Flag.Flag<boolean>;
export declare const force: Flag.Flag<boolean>;
export declare const script: Argument.Argument<string>;
export declare const profile: Flag.Flag<string>;
export declare const resourceFilter: Flag.Flag<string | undefined>;
export declare const TAIL_COLORS: string[];
export declare const TAIL_RESET = "\u001B[0m";
export declare const formatLocalTimestamp: (date: Date) => string;
export declare const parseResourceFilter: (filter: string | undefined) => ReadonlySet<string> | undefined;
export declare const parseSince: (value: string) => Date;
/**
 * Wraps a CLI command handler with a top-level OpenTelemetry span
 * (`cli.<command>`) and bumps the `alchemy.cli.invocations` counter.
 *
 * `attrs` runs against the parsed command args and contributes
 * additional attributes to the span (e.g. stage, profile, dry-run flag).
 *
 * Usage:
 * ```ts
 * Command.make(
 *   "deploy",
 *   { ...flags },
 *   instrumentCommand("deploy", (a) => ({
 *     "alchemy.stage": a.stage,
 *     "alchemy.profile": a.profile,
 *   }))(execStack),
 * );
 * ```
 */
export declare const instrumentCommand: <AttrsArgs = unknown>(command: string, attrs?: (args: AttrsArgs) => Record<string, unknown>) => <Args extends AttrsArgs, A, E, R>(handler: (args: Args) => Effect.Effect<A, E, R>) => ((args: Args) => Effect.Effect<A, E, R>);
/**
 * Render a profile's stored credential entries the same way across
 * `alchemy login` and `alchemy profile show`: one `── Provider ──`
 * header per entry, then either the provider's own `prettyPrint` block
 * (preferred) or a JSON-style fallback when the provider isn't
 * registered in the supplied {@link AuthProviders} registry.
 */
export declare const printProfile: (profile: string, stored: AlchemyProfileProviders, registry: {
    [providerName: string]: AuthProvider<any, any>;
}) => Effect.Effect<void, never, never>;
export declare const importStack: (main: string) => Effect.Effect<Effect.Effect<Stack.CompiledStack<unknown, unknown>, unknown, import("../../AlchemyContext.ts").AlchemyContext | import("../../Auth/Profile.ts").AlchemyProfile | import("../../Artifacts.ts").ArtifactStore | AuthProviders | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("../Cli.ts").Cli | import("../../Auth/Credentials.ts").CredentialsStore | import("effect/FileSystem").FileSystem | import("effect/unstable/http/HttpClient").HttpClient | Path.Path | import("effect/Scope").Scope | Stage> & {
    stackName: string;
    stage: string;
    providers: Layer.Layer<never>;
    state: Layer.Layer<never>;
}, never, Path.Path>;
export interface BuildStackProvidersOptions {
    /** Stack entrypoint to import (e.g. `"alchemy.run.ts"`). */
    main: string;
    envFile: Option.Option<string>;
    profile: string;
    /**
     * Registry to populate. Pass a pre-seeded registry (e.g. one that already
     * has built-in providers) to layer the stack's providers on top of it,
     * overriding by name. Defaults to a fresh empty registry.
     */
    registry?: AuthProviders["Service"];
    /**
     * Logger layer used during the build. Defaults to the file logger
     * (`out`). `alchemy unsafe nuke` overrides this to log to the console in
     * debug mode.
     */
    logger?: Layer.Layer<never, never, never>;
    /**
     * Extra layer merged into the placeholder scaffold — e.g.
     * `Layer.succeed(MinimumLogLevel, ...)`, which sets a fiber-ref default
     * and so contributes no context service (`Layer<never>`).
     */
    extra?: Layer.Layer<never, never, never>;
}
/**
 * Import a stack entrypoint and build its `providers()` (+ `state()`) layer
 * out of band against placeholder {@link Stack.Stack}/{@link Stage} services,
 * so its `AuthProviderLayer` registrations land in an {@link AuthProviders}
 * registry and the built context holds every resource provider plus the
 * cloud-environment services their operations need.
 *
 * Shared by `alchemy login`, `alchemy profile show`, and `alchemy unsafe
 * nuke`. The caller decides what to do with the result — use `authProviders`
 * (login / profile show) or `context` (nuke) — and whether a missing/invalid
 * entrypoint is fatal (login / nuke let it propagate) or best-effort
 * (profile show wraps the call in `Effect.catchCause`).
 */
export declare const buildStackProviders: (options: BuildStackProvidersOptions) => Effect.Effect<{
    authProviders: {
        [providerName: string]: AuthProvider<any, any>;
    };
    context: import("effect/Context").Context<AuthProviders | Stack.Stack | Stage>;
    stackEffect: Effect.Effect<Stack.CompiledStack<unknown, unknown>, unknown, import("../../AlchemyContext.ts").AlchemyContext | import("../../Auth/Profile.ts").AlchemyProfile | import("../../Artifacts.ts").ArtifactStore | AuthProviders | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("../Cli.ts").Cli | import("../../Auth/Credentials.ts").CredentialsStore | import("effect/FileSystem").FileSystem | import("effect/unstable/http/HttpClient").HttpClient | Path.Path | import("effect/Scope").Scope | Stage> & {
        stackName: string;
        stage: string;
        providers: Layer.Layer<never>;
        state: Layer.Layer<never>;
    };
}, import("effect/PlatformError").PlatformError, import("../../AlchemyContext.ts").AlchemyContext | import("effect/FileSystem").FileSystem | Path.Path | import("effect/Scope").Scope>;
/**
 * The auth providers Alchemy ships with. Used as the baseline registry so
 * `alchemy login` works from any folder (no `alchemy.run.ts` required) and
 * `alchemy profile show` can pretty-print any provider a profile mentions,
 * even one the current stack doesn't wire up.
 */
export declare const builtinAuth: Layer.Layer<never, never, import("../../Auth/Profile.ts").AlchemyProfile | AuthProviders | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("../../Auth/Credentials.ts").CredentialsStore>;
/**
 * Build {@link builtinAuth} against `registry` so every built-in auth
 * provider registers itself, without importing any stack entrypoint.
 */
export declare const buildBuiltinAuthProviders: (options: {
    envFile: Option.Option<string>;
    profile: string;
    /** Registry to populate. Defaults to a fresh empty registry. */
    registry?: AuthProviders["Service"];
}) => Effect.Effect<{
    [providerName: string]: AuthProvider<any, any>;
}, import("effect/PlatformError").PlatformError, import("../../AlchemyContext.ts").AlchemyContext | import("../../Auth/Profile.ts").AlchemyProfile | import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("../../Auth/Credentials.ts").CredentialsStore | import("effect/FileSystem").FileSystem | Path.Path | import("effect/Scope").Scope>;
//# sourceMappingURL=_shared.d.ts.map