Console

declare const assert: (condition: boolean, ...args: ReadonlyArray<any>) => Effect<void>;

declare const clear: Effect<void>;

declare const consoleWith: <A, E, R>(f: (console: Console) => Effect<A, E, R>) => Effect<A, E, R>;

declare const count: (label?: string) => Effect<void>;

declare const countReset: (label?: string) => Effect<void>;

declare const debug: (...args: ReadonlyArray<any>) => Effect<void>;

declare const dir: (item: any, options?: any) => Effect<void>;

declare const dirxml: (...args: ReadonlyArray<any>) => Effect<void>;

declare const error: (...args: ReadonlyArray<any>) => Effect<void>;

declare const group: (options?: {
  collapsed?: boolean;
  label?: string;
}) => Effect<void, never, Scope>;

declare const info: (...args: ReadonlyArray<any>) => Effect<void>;

declare const log: (...args: ReadonlyArray<any>) => Effect<void>;

declare const table: (tabularData: any, properties?: ReadonlyArray<string>) => Effect<void>;

declare const time: (label?: string) => Effect<void, never, Scope>;

declare const timeLog: (label?: string, ...args: ReadonlyArray<any>) => Effect<void>;

declare const trace: (...args: ReadonlyArray<any>) => Effect<void>;

declare const warn: (...args: ReadonlyArray<any>) => Effect<void>;

declare const withGroup: {
  (options?: {
    readonly collapsed?: boolean;
    readonly label?: string;
  }): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
  <A, E, R>(
    self: Effect<A, E, R>,
    options?: {
      readonly collapsed?: boolean;
      readonly label?: string;
    },
  ): Effect<A, E, R>;
};

declare const withTime: {
  (label?: string): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>;
  <A, E, R>(self: Effect<A, E, R>, label?: string): Effect<A, E, R>;
};

declare const Console: Tag<Console, Console>;

declare const setConsole: <A extends Console>(console: A) => Layer.Layer<never>;

declare const withConsole: {
  <C extends Console>(console: C): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
  <A, E, R, C extends Console>(effect: Effect<A, E, R>, console: C): Effect<A, E, R>;
};

interface Console {
  readonly [TypeId]: typeof TypeId;
  readonly clear: Effect<void>;
  readonly groupEnd: Effect<void>;
  readonly unsafe: UnsafeConsole;
  assert(condition: boolean, ...args: readonly Array<any>): Effect<void>;
  count(label?: string): Effect<void>;
  countReset(label?: string): Effect<void>;
  debug(...args: readonly Array<any>): Effect<void>;
  dir(item: any, options?: any): Effect<void>;
  dirxml(...args: readonly Array<any>): Effect<void>;
  error(...args: readonly Array<any>): Effect<void>;
  group(options?: {
    readonly collapsed?: boolean;
    readonly label?: string;
  }): Effect<void>;
  info(...args: readonly Array<any>): Effect<void>;
  log(...args: readonly Array<any>): Effect<void>;
  table(tabularData: any, properties?: readonly Array<string>): Effect<void>;
  time(label?: string): Effect<void>;
  timeEnd(label?: string): Effect<void>;
  timeLog(label?: string, ...args: readonly Array<any>): Effect<void>;
  trace(...args: readonly Array<any>): Effect<void>;
  warn(...args: readonly Array<any>): Effect<void>;
}

interface UnsafeConsole {
  assert(condition: boolean, ...args: readonly Array<any>): void;
  clear(): void;
  count(label?: string): void;
  countReset(label?: string): void;
  debug(...args: readonly Array<any>): void;
  dir(item: any, options?: any): void;
  dirxml(...args: readonly Array<any>): void;
  error(...args: readonly Array<any>): void;
  group(...args: readonly Array<any>): void;
  groupCollapsed(...args: readonly Array<any>): void;
  groupEnd(): void;
  info(...args: readonly Array<any>): void;
  log(...args: readonly Array<any>): void;
  table(tabularData: any, properties?: readonly Array<string>): void;
  time(label?: string): void;
  timeEnd(label?: string): void;
  timeLog(label?: string, ...args: readonly Array<any>): void;
  trace(...args: readonly Array<any>): void;
  warn(...args: readonly Array<any>): void;
}

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;