export declare const Class: new <A extends Record<string, any> = {}>(
  args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A]: A[P] }
) => Readonly<A>

import { Data, Equal } from "effect"

class Person extends Data.Class<{ readonly name: string }> {}

// Creating instances of Person
const mike1 = new Person({ name: "Mike" })
const mike2 = new Person({ name: "Mike" })
const john = new Person({ name: "John" })

// Checking equality
assert.deepStrictEqual(Equal.equals(mike1, mike2), true)
assert.deepStrictEqual(Equal.equals(mike1, john), false)

export declare const Error: new <A extends Record<string, any> = {}>(
  args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A]: A[P] }
) => Cause.YieldableError & Readonly<A>

export declare const Structural: new <A>(
  args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A]: A[P] }
) => {}

export declare const TaggedClass: <Tag extends string>(
  tag: Tag
) => new <A extends Record<string, any> = {}>(
  args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }
) => Readonly<A> & { readonly _tag: Tag }

import { Data, Equal } from "effect"

class Person extends Data.TaggedClass("Person")<{ readonly name: string }> {}

// Creating instances of Person
const mike1 = new Person({ name: "Mike" })
const mike2 = new Person({ name: "Mike" })
const john = new Person({ name: "John" })

// Checking equality
assert.deepStrictEqual(Equal.equals(mike1, mike2), true)
assert.deepStrictEqual(Equal.equals(mike1, john), false)

assert.deepStrictEqual(mike1._tag, "Person")

export declare const TaggedError: <Tag extends string>(
  tag: Tag
) => new <A extends Record<string, any> = {}>(
  args: Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }
) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A>

export declare const array: <As extends readonly any[]>(as: As) => Readonly<As>

import { Data, Equal } from "effect"

const alice = Data.struct({ name: "Alice", age: 30 })
const bob = Data.struct({ name: "Bob", age: 40 })

const persons = Data.array([alice, bob])

assert.deepStrictEqual(
  Equal.equals(persons, Data.array([Data.struct({ name: "Alice", age: 30 }), Data.struct({ name: "Bob", age: 40 })])),
  true
)

export declare const case: <A>() => Case.Constructor<A, never>

import { Data, Equal } from "effect"

interface Person {
  readonly name: string
}

// Creating a constructor for the specified Case
const Person = Data.case<Person>()

// Creating instances of Person
const mike1 = Person({ name: "Mike" })
const mike2 = Person({ name: "Mike" })
const john = Person({ name: "John" })

// Checking equality
assert.deepStrictEqual(Equal.equals(mike1, mike2), true)
assert.deepStrictEqual(Equal.equals(mike1, john), false)

export declare const struct: <A extends Record<string, any>>(a: A) => { readonly [P in keyof A]: A[P] }

import { Data, Equal } from "effect"

const alice = Data.struct({ name: "Alice", age: 30 })

const bob = Data.struct({ name: "Bob", age: 40 })

assert.deepStrictEqual(Equal.equals(alice, alice), true)
assert.deepStrictEqual(Equal.equals(alice, Data.struct({ name: "Alice", age: 30 })), true)

assert.deepStrictEqual(Equal.equals(alice, { name: "Alice", age: 30 }), false)
assert.deepStrictEqual(Equal.equals(alice, bob), false)

export declare const tagged: <A extends { readonly _tag: string }>(tag: A["_tag"]) => Case.Constructor<A, "_tag">

import { Data } from "effect"

interface Person {
  readonly _tag: "Person" // the tag
  readonly name: string
}

const Person = Data.tagged<Person>("Person")

const mike = Person({ name: "Mike" })

assert.deepEqual(mike, { _tag: "Person", name: "Mike" })

export declare const taggedEnum: {
  <Z extends TaggedEnum.WithGenerics<1>>(): Types.Simplify<
    {
      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A>(
        args: TaggedEnum.Args<
          TaggedEnum.Kind<Z, A, unknown, unknown, unknown>,
          Tag,
          Extract<TaggedEnum.Kind<Z, A, unknown, unknown, unknown>, { readonly _tag: Tag }>
        >
      ) => Extract<TaggedEnum.Kind<Z, A, unknown, unknown, unknown>, { readonly _tag: Tag }>
    } & TaggedEnum.GenericMatchers<Z>
  >
  <Z extends TaggedEnum.WithGenerics<2>>(): Types.Simplify<
    {
      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B>(
        args: TaggedEnum.Args<
          TaggedEnum.Kind<Z, A, B, unknown, unknown>,
          Tag,
          Extract<TaggedEnum.Kind<Z, A, B, unknown, unknown>, { readonly _tag: Tag }>
        >
      ) => Extract<TaggedEnum.Kind<Z, A, B, unknown, unknown>, { readonly _tag: Tag }>
    } & TaggedEnum.GenericMatchers<Z>
  >
  <Z extends TaggedEnum.WithGenerics<3>>(): Types.Simplify<
    {
      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C>(
        args: TaggedEnum.Args<
          TaggedEnum.Kind<Z, A, B, C, unknown>,
          Tag,
          Extract<TaggedEnum.Kind<Z, A, B, C, unknown>, { readonly _tag: Tag }>
        >
      ) => Extract<TaggedEnum.Kind<Z, A, B, C, unknown>, { readonly _tag: Tag }>
    } & TaggedEnum.GenericMatchers<Z>
  >
  <Z extends TaggedEnum.WithGenerics<4>>(): Types.Simplify<
    {
      readonly [Tag in Z["taggedEnum"]["_tag"]]: <A, B, C, D>(
        args: TaggedEnum.Args<
          TaggedEnum.Kind<Z, A, B, C, D>,
          Tag,
          Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
        >
      ) => Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
    } & TaggedEnum.GenericMatchers<Z>
  >
  <A extends { readonly _tag: string }>(): Types.Simplify<
    { readonly [Tag in A["_tag"]]: Case.Constructor<Extract<A, { readonly _tag: Tag }>, "_tag"> } & {
      readonly $is: <Tag>(tag: Tag) => (u: unknown) => u is Extract<A, { readonly _tag: Tag }>
      readonly $match: {
        <Cases>(cases: Cases): (value: A) => Unify<ReturnType<Cases[A["_tag"]]>>
        <Cases>(value: A, cases: Cases): Unify<ReturnType<Cases[A["_tag"]]>>
      }
    }
  >
}

import { Data } from "effect"

const { BadRequest, NotFound } = Data.taggedEnum<
  | { readonly _tag: "BadRequest"; readonly status: 400; readonly message: string }
  | { readonly _tag: "NotFound"; readonly status: 404; readonly message: string }
>()

const notFound = NotFound({ status: 404, message: "Not Found" })

import { Data } from "effect"

type MyResult<E, A> = Data.TaggedEnum<{
  Failure: { readonly error: E }
  Success: { readonly value: A }
}>
interface MyResultDefinition extends Data.TaggedEnum.WithGenerics<2> {
  readonly taggedEnum: MyResult<this["A"], this["B"]>
}
const { Failure, Success } = Data.taggedEnum<MyResultDefinition>()

const success = Success({ value: 1 })

export declare const tuple: <As extends readonly any[]>(...as: As) => Readonly<As>

import { Data, Equal } from "effect"

const alice = Data.tuple("Alice", 30)

const bob = Data.tuple("Bob", 40)

assert.deepStrictEqual(Equal.equals(alice, alice), true)
assert.deepStrictEqual(Equal.equals(alice, Data.tuple("Alice", 30)), true)

assert.deepStrictEqual(Equal.equals(alice, ["Alice", 30]), false)
assert.deepStrictEqual(Equal.equals(alice, bob), false)

export declare const unsafeArray: <As extends readonly any[]>(as: As) => Readonly<As>

export declare const unsafeStruct: <A extends Record<string, any>>(as: A) => { readonly [P in keyof A]: A[P] }

import { Data } from "effect"

type HttpError = Data.TaggedEnum<{
  BadRequest: { readonly status: 400; readonly message: string }
  NotFound: { readonly status: 404; readonly message: string }
}>

// Equivalent to:
type HttpErrorPlain =
  | {
      readonly _tag: "BadRequest"
      readonly status: 400
      readonly message: string
    }
  | {
      readonly _tag: "NotFound"
      readonly status: 404
      readonly message: string
    }

export type TaggedEnum<A extends Record<string, Record<string, any>> & UntaggedChildren<A>> = keyof A extends infer Tag
  ? Tag extends keyof A
    ? Types.Simplify<{ readonly _tag: Tag } & { readonly [K in keyof A[Tag]]: A[Tag][K] }>
    : never
  : never

export interface Constructor<A, Tag extends keyof A = never> {
  (
    args: Types.Equals<Omit<A, Tag>, {}> extends true
      ? void
      : { readonly [P in keyof A as P extends Tag ? never : P]: A[P] }
  ): A
}

export interface GenericMatchers<Z extends WithGenerics<number>> {
  readonly $is: <Tag extends Z["taggedEnum"]["_tag"]>(
    tag: Tag
  ) => {
    <T extends TaggedEnum.Kind<Z, any, any, any, any>>(u: T): u is T & { readonly _tag: Tag }
    (u: unknown): u is Extract<TaggedEnum.Kind<Z>, { readonly _tag: Tag }>
  }
  readonly $match: {
    <
      A,
      B,
      C,
      D,
      Cases extends {
        readonly [Tag in Z["taggedEnum"]["_tag"]]: (
          args: Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
        ) => any
      }
    >(
      cases: Cases
    ): (self: TaggedEnum.Kind<Z, A, B, C, D>) => Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
    <
      A,
      B,
      C,
      D,
      Cases extends {
        readonly [Tag in Z["taggedEnum"]["_tag"]]: (
          args: Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
        ) => any
      }
    >(
      self: TaggedEnum.Kind<Z, A, B, C, D>,
      cases: Cases
    ): Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
  }
}

export interface WithGenerics<Count extends number> {
  readonly taggedEnum: { readonly _tag: string }
  readonly numberOfGenerics: Count

  readonly A: unknown
  readonly B: unknown
  readonly C: unknown
  readonly D: unknown
}

export type Args<A extends { readonly _tag: string }, K extends A["_tag"], E = Extract<A, { readonly _tag: K }>> = {
  readonly [K in keyof E as K extends "_tag" ? never : K]: E[K]
} extends infer T
  ? {} extends T
    ? void
    : T
  : never

export type Constructor<A extends { readonly _tag: string }> = Types.Simplify<
  {
    readonly [Tag in A["_tag"]]: Case.Constructor<Extract<A, { readonly _tag: Tag }>, "_tag">
  } & {
    readonly $is: <Tag extends A["_tag"]>(tag: Tag) => (u: unknown) => u is Extract<A, { readonly _tag: Tag }>
    readonly $match: {
      <
        Cases extends {
          readonly [Tag in A["_tag"]]: (args: Extract<A, { readonly _tag: Tag }>) => any
        }
      >(
        cases: Cases
      ): (value: A) => Unify<ReturnType<Cases[A["_tag"]]>>
      <
        Cases extends {
          readonly [Tag in A["_tag"]]: (args: Extract<A, { readonly _tag: Tag }>) => any
        }
      >(
        value: A,
        cases: Cases
      ): Unify<ReturnType<Cases[A["_tag"]]>>
    }
  }
>

export 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"]

export type Value<A extends { readonly _tag: string }, K extends A["_tag"]> = Extract<A, { readonly _tag: K }>