export * from "vitest"

export type API = V.TestAPI<{}>

export interface Test<R> {
  <A, E>(
    name: string,
    self: TestFunction<A, E, R, [V.TaskContext<V.Test<{}>> & V.TestContext]>,
    timeout?: number | V.TestOptions
  ): void
}

export interface TestFunction<A, E, R, TestArgs extends Array<any>> {
  (...args: TestArgs): Effect.Effect<A, E, R>
}

export interface Tester<R> extends Vitest.Test<R> {
  skip: Vitest.Test<R>
  skipIf: (condition: unknown) => Vitest.Test<R>
  only: Vitest.Test<R>
  each: <T>(
    cases: ReadonlyArray<T>
  ) => <A, E>(name: string, self: TestFunction<A, E, R, Array<T>>, timeout?: number | V.TestOptions) => void
}

export declare const addEqualityTesters: () => void

export declare const effect: Vitest.Tester<TestServices.TestServices>

export declare const flakyTest: <A, E, R>(self: Effect.Effect<A, E, R>, timeout?: any) => Effect.Effect<A, never, R>

export declare const it: TestCollectorCallable<{}> & {
  concurrent: b<
    "concurrent" | "sequential" | "only" | "skip" | "todo" | "fails",
    TestCollectorCallable<{}>,
    { each: TestEachFunction }
  >
  sequential: b<
    "concurrent" | "sequential" | "only" | "skip" | "todo" | "fails",
    TestCollectorCallable<{}>,
    { each: TestEachFunction }
  >
  only: b<
    "concurrent" | "sequential" | "only" | "skip" | "todo" | "fails",
    TestCollectorCallable<{}>,
    { each: TestEachFunction }
  >
  skip: b<
    "concurrent" | "sequential" | "only" | "skip" | "todo" | "fails",
    TestCollectorCallable<{}>,
    { each: TestEachFunction }
  >
  todo: b<
    "concurrent" | "sequential" | "only" | "skip" | "todo" | "fails",
    TestCollectorCallable<{}>,
    { each: TestEachFunction }
  >
  fails: b<
    "concurrent" | "sequential" | "only" | "skip" | "todo" | "fails",
    TestCollectorCallable<{}>,
    { each: TestEachFunction }
  >
} & {
  fn: (
    this: Record<"concurrent" | "sequential" | "only" | "skip" | "todo" | "fails", any>,
    name: string | Function,
    options?: V.TestOptions | undefined,
    fn?: V.TestFunction<{}> | undefined
  ) => void
} & { each: TestEachFunction } & ExtendedAPI<{}> & {
    extend: <T>(
      fixtures: u<T, {}>
    ) => V.TestAPI<{ [K in keyof T]: K extends keyof T ? T[K] : K extends never ? {}[K] : never }>
  } & {
    readonly effect: Vitest.Tester<TestServices.TestServices>
    readonly live: Vitest.Tester<never>
    readonly flakyTest: <A, E, R>(self: Effect.Effect<A, E, R>, timeout?: any) => Effect.Effect<A, never, R>
    readonly scoped: Vitest.Tester<any>
    readonly scopedLive: Vitest.Tester<Scope.Scope>
  }

export declare const live: Vitest.Tester<never>

export declare const scoped: Vitest.Tester<any>

export declare const scopedLive: Vitest.Tester<Scope.Scope>