import * as E from "@effect-ts/core/Either";
import type { Predicate } from "@effect-ts/core/Function";
import * as O from "@effect-ts/core/Option";
import type * as P from "@effect-ts/core/Prelude";
import * as HM from "@effect-ts/system/Collections/Immutable/HashMap";
import type { At } from "../At/index.js";
import type { Index } from "../Ix/index.js";
declare const Lens_base: import("@effect-ts/system/Case").CaseConstructorTagged<"Lens", "_tag">;
export declare class Lens<S, A> extends Lens_base<{
    readonly get: (s: S) => A;
    readonly set: (a: A) => (s: S) => S;
}> {
    readonly [">>>"]: {
        <B>(ab: Iso<A, B>): Lens<S, B>;
        <B>(ab: Lens<A, B>): Lens<S, B>;
        <B>(ab: Prism<A, B>): Optional<S, B>;
        <B>(ab: Optional<A, B>): Optional<S, B>;
        <B>(ab: Traversal<A, B>): Traversal<S, B>;
    };
}
declare const Prism_base: import("@effect-ts/system/Case").CaseConstructorTagged<"Prism", "_tag">;
export declare class Prism<S, A> extends Prism_base<{
    readonly getOption: (s: S) => O.Option<A>;
    readonly reverseGet: (a: A) => S;
}> {
    readonly [">>>"]: {
        <B>(ab: Iso<A, B>): Prism<S, B>;
        <B>(ab: Lens<A, B>): Optional<S, B>;
        <B>(ab: Prism<A, B>): Prism<S, B>;
        <B>(ab: Optional<A, B>): Optional<S, B>;
        <B>(ab: Traversal<A, B>): Traversal<S, B>;
    };
}
declare const Optional_base: import("@effect-ts/system/Case").CaseConstructorTagged<"Optional", "_tag">;
export declare class Optional<S, A> extends Optional_base<{
    readonly getOption: (s: S) => O.Option<A>;
    readonly set: (a: A) => (s: S) => S;
}> {
    readonly [">>>"]: {
        <B>(ab: Iso<A, B>): Optional<S, B>;
        <B>(ab: Lens<A, B>): Optional<S, B>;
        <B>(ab: Prism<A, B>): Optional<S, B>;
        <B>(ab: Optional<A, B>): Optional<S, B>;
        <B>(ab: Traversal<A, B>): Traversal<S, B>;
    };
}
declare const Iso_base: import("@effect-ts/system/Case").CaseConstructorTagged<"Iso", "_tag">;
export declare class Iso<S, A> extends Iso_base<{
    readonly get: (s: S) => A;
    readonly reverseGet: (a: A) => S;
}> {
    readonly [">>>"]: {
        <B>(ab: Iso<A, B>): Iso<S, B>;
        <B>(ab: Lens<A, B>): Lens<S, B>;
        <B>(ab: Prism<A, B>): Prism<S, B>;
        <B>(ab: Optional<A, B>): Optional<S, B>;
        <B>(ab: Traversal<A, B>): Traversal<S, B>;
    };
}
export interface ModifyF<S, A> {
    <F extends P.URIS, C = P.Auto>(F: P.Applicative<F, C>): <FK, FQ, FW, FX, FI, FS, FR, FE>(f: (a: A) => P.Kind<F, C, FK, FQ, FW, FX, FI, FS, FR, FE, A>) => (s: S) => P.Kind<F, C, FK, FQ, FW, FX, FI, FS, FR, FE, S>;
}
declare const Traversal_base: import("@effect-ts/system/Case").CaseConstructorTagged<"Traversal", "_tag">;
export declare class Traversal<S, A> extends Traversal_base<{
    readonly modifyF: ModifyF<S, A>;
}> {
    readonly [">>>"]: {
        <B>(ab: Iso<A, B>): Traversal<S, B>;
        <B>(ab: Lens<A, B>): Traversal<S, B>;
        <B>(ab: Prism<A, B>): Traversal<S, B>;
        <B>(ab: Optional<A, B>): Traversal<S, B>;
        <B>(ab: Traversal<A, B>): Traversal<S, B>;
    };
}
export declare const isoAsLens: <S, A>(sa: Iso<S, A>) => Lens<S, A>;
export declare const isoAsOptional: <S, A>(sa: Iso<S, A>) => Optional<S, A>;
/**
 * Compose an `Iso` with an `Iso`
 */
export declare const isoComposeIso: <A, B>(ab: Iso<A, B>) => <S>(sa: Iso<S, A>) => Iso<S, B>;
/**
 * View an `Iso` as a `Prism`
 */
export declare const isoAsPrism: <S, A>(sa: Iso<S, A>) => Prism<S, A>;
export declare const isoAsTraversal: <S, A>(sa: Iso<S, A>) => Traversal<S, A>;
export declare const lensAsOptional: <S, A>(sa: Lens<S, A>) => Optional<S, A>;
export declare const lensAsTraversal: <S, A>(sa: Lens<S, A>) => Traversal<S, A>;
export declare const lensComposeLens: <A, B>(ab: Lens<A, B>) => <S>(sa: Lens<S, A>) => Lens<S, B>;
export declare const lensComposePrism: <A, B>(ab: Prism<A, B>) => <S>(sa: Lens<S, A>) => Optional<S, B>;
export declare const lensId: <S>() => Lens<S, S>;
export declare const lensProp: <A, P extends keyof A>(prop: P) => <S>(lens: Lens<S, A>) => Lens<S, A[P]>;
export declare const lensProps: <A, P extends keyof A>(props_0: P, props_1: P, ...props_2: P[]) => <S>(lens: Lens<S, A>) => Lens<S, { [K in P]: A[K]; }>;
export declare const lensComponent: <A extends readonly unknown[], P extends keyof A>(prop: P) => <S>(lens: Lens<S, A>) => Lens<S, A[P]>;
export declare const prismAsOptional: <S, A>(sa: Prism<S, A>) => Optional<S, A>;
export declare const prismAsTraversal: <S, A>(sa: Prism<S, A>) => Traversal<S, A>;
export declare const prismModifyOption: <A>(f: (a: A) => A) => <S>(sa: Prism<S, A>) => (s: S) => O.Option<S>;
export declare const prismModify: <A>(f: (a: A) => A) => <S>(sa: Prism<S, A>) => (s: S) => S;
export declare const prismSet: <A>(a: A) => <S>(sa: Prism<S, A>) => (s: S) => S;
export declare const prismComposeLens: <A, B>(ab: Lens<A, B>) => <S>(sa: Prism<S, A>) => Optional<S, B>;
export declare const prismFromNullable: <A>() => Prism<A, NonNullable<A>>;
export declare function prismFromPredicate<A>(predicate: Predicate<A>): Prism<A, A>;
export declare const prismSome: <A>() => Prism<O.Option<A>, A>;
export declare const prismRight: <E, A>() => Prism<E.Either<E, A>, A>;
export declare const prismLeft: <E, A>() => Prism<E.Either<E, A>, E>;
/**
 * Compose a `Prism` with a `Prism`
 */
export declare const composePrism: <A, B>(ab: Prism<A, B>) => <S>(sa: Prism<S, A>) => Prism<S, B>;
export declare const optionalAsTraversal: <S, A>(sa: Optional<S, A>) => Traversal<S, A>;
export declare const optionalModifyOption: <A>(f: (a: A) => A) => <S>(optional: Optional<S, A>) => (s: S) => O.Option<S>;
export declare const optionalModify: <A>(f: (a: A) => A) => <S>(optional: Optional<S, A>) => (s: S) => S;
export declare const optionalComposeOptional: <A, B>(ab: Optional<A, B>) => <S>(sa: Optional<S, A>) => Optional<S, B>;
export declare const find: <A>(predicate: Predicate<A>) => Optional<ReadonlyArray<A>, A>;
export declare function traversalComposeTraversal<A, B>(ab: Traversal<A, B>): <S>(sa: Traversal<S, A>) => Traversal<S, B>;
export declare function fromForEach<T extends P.URIS, C = P.Auto>(T: P.ForEach<T, C>): <A, K = P.Initial<C, "K">, Q = P.Initial<C, "Q">, W = P.Initial<C, "W">, X = P.Initial<C, "X">, I = P.Initial<C, "I">, S = P.Initial<C, "S">, R = P.Initial<C, "R">, E = P.Initial<C, "E">>() => Traversal<P.Kind<T, C, K, Q, W, X, I, S, R, E, A>, A>;
export declare const indexArray: <A = never>() => Index<ReadonlyArray<A>, number, A>;
export declare function indexRecord<A = never>(): Index<Readonly<Record<string, A>>, string, A>;
export declare function indexHashMap<K = never, A = never>(): Index<Readonly<HM.HashMap<K, A>>, K, A>;
export declare function atRecord<A = never>(): At<Readonly<Record<string, A>>, string, O.Option<A>>;
export declare function atHashMap<K = never, A = never>(): At<Readonly<HM.HashMap<K, A>>, K, O.Option<A>>;
export {};
//# sourceMappingURL=index.d.ts.map