/**
 * A `Prism` is an optic used to select part of a sum type.
 *
 * Laws:
 *
 * 1. getOption(s).fold(s, reverseGet) = s
 * 2. getOption(reverseGet(a)) = Some(a)
 */
import type { Either } from "@effect-ts/core/Either";
import type { Predicate, Refinement } from "@effect-ts/core/Function";
import type { Newtype } from "@effect-ts/core/Newtype";
import * as O from "@effect-ts/core/Option";
import type { URI } from "@effect-ts/core/Prelude";
import * as P from "@effect-ts/core/Prelude";
import type { HashMap } from "@effect-ts/system/Collections/Immutable/HashMap";
import * as _ from "../Internal/index.js";
import { composePrism as compose, Prism } from "../Internal/index.js";
import type { Lens } from "../Lens/index.js";
import type { Optional } from "../Optional/index.js";
import type { Traversal } from "../Traversal/index.js";
import Option = O.Option;
export { Prism };
export declare const id: <S>() => _.Prism<S, S>;
export declare const fromPredicate: {
    <S, A extends S>(refinement: Refinement<S, A>): Prism<S, A>;
    <A>(predicate: Predicate<A>): Prism<A, A>;
};
/**
 * View a `Prism` as a `Optional`
 */
export declare const asOptional: <S, A>(sa: Prism<S, A>) => Optional<S, A>;
/**
 * View a `Prism` as a `Traversal`
 */
export declare const asTraversal: <S, A>(sa: Prism<S, A>) => Traversal<S, A>;
export { compose };
/**
 * Compose a `Prism` with a `Lens`
 */
export declare const composeLens: <A, B>(ab: Lens<A, B>) => <S>(sa: Prism<S, A>) => Optional<S, B>;
/**
 * Compose a `Prism` with an `Optional`
 */
export declare const composeOptional: <A, B>(ab: _.Optional<A, B>) => <S>(sa: _.Prism<S, A>) => _.Optional<S, B>;
export declare const set: <A>(a: A) => <S>(sa: Prism<S, A>) => (s: S) => S;
export declare const modifyOption: <A>(f: (a: A) => A) => <S>(sa: Prism<S, A>) => (s: S) => Option<S>;
export declare const modify: <A>(f: (a: A) => A) => <S>(sa: Prism<S, A>) => (s: S) => S;
/**
 * Return a `Prism` from a `Prism` focused on a nullable value
 */
export declare const fromNullable: <S, A>(sa: Prism<S, A>) => Prism<S, NonNullable<A>>;
export declare function filter<A, B extends A>(refinement: Refinement<A, B>): <S>(sa: Prism<S, A>) => Prism<S, B>;
export declare function filter<A>(predicate: Predicate<A>): <S>(sa: Prism<S, A>) => Prism<S, A>;
/**
 * Return a `Optional` from a `Prism` and a prop
 */
export declare const prop: <A, P extends keyof A>(prop: P) => <S>(sa: _.Prism<S, A>) => _.Optional<S, A[P]>;
/**
 * Return a `Optional` from a `Prism` and a list of props
 */
export declare const props: <A, P extends keyof A>(props_0: P, props_1: P, ...props_2: P[]) => <S>(sa: _.Prism<S, A>) => _.Optional<S, { [K in P]: A[K]; }>;
/**
 * Return a `Optional` from a `Prism` and a component
 */
export declare const component: <A extends readonly unknown[], P extends keyof A>(prop: P) => <S>(sa: _.Prism<S, A>) => _.Optional<S, A[P]>;
/**
 * Return a `Optional` from a `Prism` focused on a `ReadonlyArray`
 */
export declare const index: (i: number) => <S, A>(sa: _.Prism<S, readonly A[]>) => _.Optional<S, A>;
/**
 * Return a `Optional` from a `Prism` focused on a `ReadonlyRecord` and a key
 */
export declare const keyInRecord: (key: string) => <S, A>(sa: _.Prism<S, Readonly<Record<string, A>>>) => _.Optional<S, A>;
/**
 * Return a `Optional` from a `Prism` focused on a `ReadonlyRecord` and a required key
 */
export declare const atKeyInRecord: (key: string) => <S, A>(sa: _.Prism<S, Readonly<Record<string, A>>>) => _.Optional<S, O.Option<A>>;
/**
 * Return a `Optional` from a `Prism` focused on a `HashMap` and a key
 */
export declare const keyInHashMap: <K = never>(key: K) => <S, A>(sa: _.Prism<S, Readonly<HashMap<K, A>>>) => _.Optional<S, A>;
/**
 * Return a `Optional` from a `Prism` focused on a `HashMap` and a required key
 */
export declare const atKeyInHashMap: <K = never>(key: K) => <S, A>(sa: _.Prism<S, Readonly<HashMap<K, A>>>) => _.Optional<S, O.Option<A>>;
/**
 * Return a `Prism` from a `Prism` focused on the `Some` of a `Option` type
 */
export declare const some: <S, A>(soa: Prism<S, Option<A>>) => Prism<S, A>;
/**
 * Return a `Prism` from a `Prism` focused on the `Right` of a `Either` type
 */
export declare const right: <S, E, A>(sea: Prism<S, Either<E, A>>) => Prism<S, A>;
/**
 * Return a `Prism` from a `Prism` focused on the `Left` of a `Either` type
 */
export declare const left: <S, E, A>(sea: Prism<S, Either<E, A>>) => Prism<S, E>;
/**
 * Return a `Traversal` from a `Prism` focused on a `ForEach`
 */
export declare function forEach<T extends P.URIS, C = P.Auto>(T: P.ForEach<T, C>): <TK, TQ, TW, TX, TI, TS, TR, TE, S, A>(sta: Prism<S, P.Kind<T, C, TK, TQ, TW, TX, TI, TS, TR, TE, A>>) => Traversal<S, A>;
export declare const find: <A>(predicate: Predicate<A>) => <S>(sa: Prism<S, ReadonlyArray<A>>) => Optional<S, A>;
export declare const imap: <A, B>(f: (a: A) => B, g: (b: B) => A) => <E>(sa: Prism<E, A>) => Prism<E, B>;
export declare const PrismURI = "monocle/Prism";
export declare type PrismURI = typeof PrismURI;
declare module "@effect-ts/core/Prelude/HKT" {
    interface URItoKind<FC, TC, K, Q, W, X, I, S, R, E, A> {
        [PrismURI]: Prism<I, A>;
    }
}
export declare const Category: P.Category<[URI<"monocle/Prism", {}>], P.Auto>;
export declare const Invariant: P.Invariant<[URI<"monocle/Prism", {}>], P.Auto>;
export declare function newtype<T extends Newtype<any, any>>(getOption: (_: T["_A"]) => boolean): Prism<T["_A"], T>;
//# sourceMappingURL=index.d.ts.map