/**
 * @since 1.0.0
 */
import * as Equal from "@effect/data/Equal";
import * as Hash from "@effect/data/Hash";
import type * as Types from "@effect/data/Types";
/**
 * @category models
 * @since 1.0.0
 */
export type Data<A extends Readonly<Record<string, any>> | ReadonlyArray<any>> = Readonly<A> & Equal.Equal;
/**
 * `Case` represents a datatype similar to a case class in Scala. Namely, a
 * datatype created using `Case` will, by default, provide an implementation
 * for a constructor, `Hash`, and `Equal`.
 *
 * @since 1.0.0
 * @category models
 */
export interface Case extends Equal.Equal {
}
/**
 * @since 1.0.0
 */
export declare namespace Case {
    /**
     * @since 1.0.0
     * @category models
     */
    interface Constructor<A extends Case, T extends keyof A = never> {
        (args: Omit<A, T | keyof Equal.Equal> extends Record<PropertyKey, never> ? void : Omit<A, T | keyof Equal.Equal>): A;
    }
}
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const struct: <As extends Readonly<Record<string, any>>>(as: As) => Data<As>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const unsafeStruct: <As extends Readonly<Record<string, any>>>(as: As) => Data<As>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const tuple: <As extends readonly any[]>(...as: As) => Data<As>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const array: <As extends readonly any[]>(as: As) => Data<As>;
/**
 * @category constructors
 * @since 1.0.0
 */
export declare const unsafeArray: <As extends readonly any[]>(as: As) => Data<As>;
declare const _case: <A extends Case>() => Case.Constructor<A, never>;
export { 
/**
 * Provides a constructor for the specified `Case`.
 *
 * @since 1.0.0
 * @category constructors
 */
_case as case };
/**
 * Provides a tagged constructor for the specified `Case`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const tagged: <A extends Case & {
    _tag: string;
}>(tag: A["_tag"]) => Case.Constructor<A, "_tag">;
/**
 * Provides a Tagged constructor for a Case Class.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const TaggedClass: <Key extends string>(tag: Key) => new <A extends Record<string, any>>(args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>) => Data<A & {
    _tag: Key;
}>;
/**
 * @since 1.0.0
 * @category constructors
 */
export declare class Structural<A> {
    constructor(args: Omit<A, keyof Equal.Equal>);
    /**
     * @since 1.0.0
     */
    [Hash.symbol](this: Equal.Equal): number;
    /**
     * @since 1.0.0
     */
    [Equal.symbol](this: Equal.Equal, that: Equal.Equal): boolean;
}
/**
 * Provides a constructor for a Case Class.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const Class: new <A extends Record<string, any>>(args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void : Omit<A, keyof Equal.Equal>) => Data<A>;
/**
 * Create a tagged enum data type, which is a union of `Data` structs.
 *
 * ```ts
 * import * as Data from "@effect/data/Data"
 *
 * type HttpError = Data.TaggedEnum<{
 *   BadRequest: { status: 400, message: string }
 *   NotFound: { status: 404, message: string }
 * }>
 *
 * // Equivalent to:
 * type HttpErrorPlain =
 *   | Data.Data<{
 *     readonly _tag: "BadRequest"
 *     readonly status: 400
 *     readonly message: string
 *   }>
 *   | Data.Data<{
 *     readonly _tag: "NotFound"
 *     readonly status: 404
 *     readonly message: string
 *   }>
 * ```
 *
 * @since 1.0.0
 * @category models
 */
export type TaggedEnum<A extends Record<string, Record<string, any>>> = {
    readonly [Tag in keyof A]: Data<Readonly<Types.Simplify<A[Tag] & {
        _tag: Tag;
    }>>>;
}[keyof A];
/**
 * @since 1.0.0
 */
export declare namespace TaggedEnum {
    /**
     * @since 1.0.0
     * @category models
     */
    interface WithGenerics<Count extends number> {
        readonly taggedEnum: Data<{
            readonly _tag: string;
        }>;
        readonly numberOfGenerics: Count;
        readonly A: unknown;
        readonly B: unknown;
        readonly C: unknown;
        readonly D: unknown;
    }
    /**
     * @since 1.0.0
     * @category models
     */
    type Kind<Z extends WithGenerics<number>, A = unknown, B = unknown, C = unknown, D = unknown> = (Z & {
        readonly A: A;
        readonly B: B;
        readonly C: C;
        readonly D: D;
    })["taggedEnum"];
    /**
     * @since 1.0.0
     */
    type Args<A extends Data<{
        readonly _tag: string;
    }>, K extends A["_tag"]> = Omit<Extract<A, {
        readonly _tag: K;
    }>, "_tag" | keyof Case> extends infer T ? {} extends T ? void : T : never;
    /**
     * @since 1.0.0
     */
    type Value<A extends Data<{
        readonly _tag: string;
    }>, K extends A["_tag"]> = Extract<A, {
        readonly _tag: K;
    }>;
}
/**
 * Create a constructor for a tagged union of `Data` structs.
 *
 * You can also pass a `TaggedEnum.WithGenerics` if you want to add generics to
 * the constructor.
 *
 * @example
 * import * as Data from "@effect/data/Data"
 *
 * const HttpError = Data.taggedEnum<
 *   | Data.Data<{ _tag: "BadRequest"; status: 400; message: string }>
 *   | Data.Data<{ _tag: "NotFound"; status: 404; message: string }>
 * >()
 *
 * const notFound = HttpError("NotFound")({ status: 404, message: "Not Found" })
 *
 * @example
 * import * as Data from "@effect/data/Data"
 *
 * type MyResult<E, A> = Data.TaggedEnum<{
 *   Failure: { error: E }
 *   Success: { value: A }
 * }>
 * interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> {
 *   readonly taggedEnum: MyResult<this["A"], this["B"]>
 * }
 * const MyResult = Data.taggedEnum<MyResultDefinition>()
 *
 * const success = MyResult("Success")({ value: 1 })
 *
 * @category constructors
 * @since 1.0.0
 */
export declare const taggedEnum: {
    <Z extends TaggedEnum.WithGenerics<1>>(): <K extends Z["taggedEnum"]["_tag"]>(tag: K) => <A>(args: TaggedEnum.Args<TaggedEnum.Kind<Z, A>, K>) => TaggedEnum.Value<TaggedEnum.Kind<Z, A>, K>;
    <Z extends TaggedEnum.WithGenerics<2>>(): <K extends Z["taggedEnum"]["_tag"]>(tag: K) => <A, B>(args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, B>, K>) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B>, K>;
    <Z extends TaggedEnum.WithGenerics<3>>(): <K extends Z["taggedEnum"]["_tag"]>(tag: K) => <A, B, C>(args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, B, C>, K>) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C>, K>;
    <Z extends TaggedEnum.WithGenerics<4>>(): <K extends Z["taggedEnum"]["_tag"]>(tag: K) => <A, B, C, D>(args: TaggedEnum.Args<TaggedEnum.Kind<Z, A, B, C, D>, K>) => TaggedEnum.Value<TaggedEnum.Kind<Z, A, B, C, D>, K>;
    <A extends Data<{
        readonly _tag: string;
    }>>(): <K extends A["_tag"]>(tag: K) => Case.Constructor<Extract<A, {
        readonly _tag: K;
    }>, "_tag">;
};
//# sourceMappingURL=Data.d.ts.map