/**
 * Install ownership detection for AXM.
 *
 * @experimental This API is unstable and may change without notice.
 * @packageDocumentation
 */
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import * as ServiceMap from "effect/Context";
export type DetectionSource = "executable-path" | "resolved-executable-path" | "module-url" | "package-layout" | "package-manager-query" | "install-metadata" | "conflicting" | "unknown";
interface DetectionFields {
    readonly detectionSource?: DetectionSource;
    readonly evidence?: ReadonlyArray<string>;
    readonly confidence?: "high" | "medium" | "low";
    readonly managerOwnedExecutable?: string;
}
declare const Script_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
    readonly _tag: "Script";
} & import("effect/Pipeable").Pipeable;
export declare class Script extends Script_base<DetectionFields & {
    readonly execPath: string;
}> {
}
declare const Homebrew_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
    readonly _tag: "Homebrew";
} & import("effect/Pipeable").Pipeable;
export declare class Homebrew extends Homebrew_base<DetectionFields & {
    readonly execPath: string;
}> {
}
declare const Npm_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
    readonly _tag: "Npm";
} & import("effect/Pipeable").Pipeable;
export declare class Npm extends Npm_base<DetectionFields & {
    readonly importUrl: string;
}> {
}
declare const Pnpm_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
    readonly _tag: "Pnpm";
} & import("effect/Pipeable").Pipeable;
export declare class Pnpm extends Pnpm_base<DetectionFields & {
    readonly importUrl: string;
}> {
}
declare const Yarn_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
    readonly _tag: "Yarn";
} & import("effect/Pipeable").Pipeable;
export declare class Yarn extends Yarn_base<DetectionFields & {
    readonly importUrl: string;
    readonly managerMajorVersion?: number;
    readonly supported: boolean;
}> {
}
export type UnknownReason = "ambiguous" | "conflicting" | "unsupported" | "unknown";
declare const Unknown_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
    readonly _tag: "Unknown";
} & import("effect/Pipeable").Pipeable;
export declare class Unknown extends Unknown_base<DetectionFields & {
    readonly reason?: UnknownReason;
}> {
    constructor(props?: DetectionFields & {
        readonly reason?: UnknownReason;
    });
}
export type InstallMethodType = Script | Homebrew | Npm | Pnpm | Yarn | Unknown;
export declare const InstallMethodLiteral: Schema.Literals<readonly ["script", "homebrew", "npm", "pnpm", "yarn"]>;
export type InstallMethodName = typeof InstallMethodLiteral.Type;
export interface InstallMethodService {
    readonly detect: () => Effect.Effect<InstallMethodType>;
}
declare const InstallMethod_base: ServiceMap.ServiceClass<InstallMethod, "@agentxm/client-core/unstable/install-method/install-method/InstallMethod", InstallMethodService>;
export declare class InstallMethod extends InstallMethod_base {
}
export interface InstallMethodInputs {
    readonly execPath: string;
    readonly invocationPaths?: ReadonlyArray<string>;
    readonly importMetaUrl: string;
    readonly homeDir: string;
    readonly platform: string;
    readonly packageManager?: "npm" | "pnpm" | "yarn";
    readonly packageManagerVersion?: string;
    readonly managerOwnedExecutable?: string;
}
export declare const detectFromInputs: (inputs: InstallMethodInputs) => Effect.Effect<InstallMethodType, never, Path.Path | FileSystem.FileSystem>;
export declare const InstallMethodLive: Layer.Layer<InstallMethod, never, Path.Path | FileSystem.FileSystem>;
export declare const InstallMethodTest: (inputs: InstallMethodInputs) => Layer.Layer<InstallMethod, never, Path.Path | FileSystem.FileSystem>;
export {};
//# sourceMappingURL=install-method.d.ts.map