export declare const defaultLogger: Logger<unknown, void>

export declare const logFmt: Layer.Layer<never, never, never>

export declare const logfmtLogger: Logger<unknown, string>

export declare const make: <Message, Output>(
  log: (options: {
    readonly fiberId: FiberId.FiberId
    readonly logLevel: LogLevel.LogLevel
    readonly message: Message
    readonly cause: Cause.Cause<unknown>
    readonly context: FiberRefs.FiberRefs
    readonly spans: List.List<LogSpan.LogSpan>
    readonly annotations: HashMap.HashMap<string, AnnotationValue>
    readonly date: Date
  }) => Output
) => Logger<Message, Output>

export declare const none: Logger<unknown, void>

export declare const simple: <A, B>(log: (a: A) => B) => Logger<A, B>

export declare const stringLogger: Logger<unknown, string>

export declare const succeed: <A>(value: A) => Logger<unknown, A>

export declare const sync: <A>(evaluate: LazyArg<A>) => Logger<unknown, A>

export declare const test: {
  <Message>(input: Message): <Output>(self: Logger<Message, Output>) => Output
  <Message, Output>(self: Logger<Message, Output>, input: Message): Output
}

export declare const tracerLogger: Logger<unknown, void>

export declare const add: <B>(logger: Logger<unknown, B>) => Layer.Layer<never, never, never>

export declare const addEffect: <R, E, A>(effect: Effect<R, E, Logger<unknown, A>>) => Layer.Layer<R, E, never>

export declare const addScoped: <R, E, A>(
  effect: Effect<R, E, Logger<unknown, A>>
) => Layer.Layer<Exclude<R, Scope>, E, never>

export declare const minimumLogLevel: (level: LogLevel.LogLevel) => Layer.Layer<never, never, never>

export declare const remove: <A>(logger: Logger<unknown, A>) => Layer.Layer<never, never, never>

export declare const replace: {
  <B>(that: Logger<unknown, B>): <A>(self: Logger<unknown, A>) => Layer.Layer<never, never, never>
  <A, B>(self: Logger<unknown, A>, that: Logger<unknown, B>): Layer.Layer<never, never, never>
}

export declare const replaceEffect: {
  <R, E, B>(that: Effect<R, E, Logger<unknown, B>>): <A>(self: Logger<unknown, A>) => Layer.Layer<R, E, never>
  <A, R, E, B>(self: Logger<unknown, A>, that: Effect<R, E, Logger<unknown, B>>): Layer.Layer<R, E, never>
}

export declare const replaceScoped: {
  <R, E, B>(that: Effect<R, E, Logger<unknown, B>>): <A>(
    self: Logger<unknown, A>
  ) => Layer.Layer<Exclude<R, Scope>, E, never>
  <A, R, E, B>(self: Logger<unknown, A>, that: Effect<R, E, Logger<unknown, B>>): Layer.Layer<
    Exclude<R, Scope>,
    E,
    never
  >
}

export declare const withMinimumLogLevel: {
  (level: LogLevel.LogLevel): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
  <R, E, A>(self: Effect<R, E, A>, level: LogLevel.LogLevel): Effect<R, E, A>
}

export declare const filterLogLevel: {
  (f: (logLevel: LogLevel.LogLevel) => boolean): <Message, Output>(
    self: Logger<Message, Output>
  ) => Logger<Message, Option.Option<Output>>
  <Message, Output>(self: Logger<Message, Output>, f: (logLevel: LogLevel.LogLevel) => boolean): Logger<
    Message,
    Option.Option<Output>
  >
}

export declare const map: {
  <Output, Output2>(f: (output: Output) => Output2): <Message>(
    self: Logger<Message, Output>
  ) => Logger<Message, Output2>
  <Message, Output, Output2>(self: Logger<Message, Output>, f: (output: Output) => Output2): Logger<Message, Output2>
}

export declare const mapInput: {
  <Message, Message2>(f: (message: Message2) => Message): <Output>(
    self: Logger<Message, Output>
  ) => Logger<Message2, Output>
  <Output, Message, Message2>(self: Logger<Message, Output>, f: (message: Message2) => Message): Logger<
    Message2,
    Output
  >
}

export type AnnotationValue = string | number | boolean

export interface Logger<Message, Output> extends Logger.Variance<Message, Output>, Pipeable {
  readonly log: (options: {
    readonly fiberId: FiberId.FiberId
    readonly logLevel: LogLevel.LogLevel
    readonly message: Message
    readonly cause: Cause.Cause<unknown>
    readonly context: FiberRefs.FiberRefs
    readonly spans: List.List<LogSpan.LogSpan>
    readonly annotations: HashMap.HashMap<string, AnnotationValue>
    readonly date: Date
  }) => Output
}

export declare const LoggerTypeId: typeof LoggerTypeId

export type LoggerTypeId = typeof LoggerTypeId

export interface Variance<Message, Output> {
  readonly [LoggerTypeId]: {
    readonly _Message: (_: Message) => void
    readonly _Output: (_: never) => Output
  }
}

export declare const zip: {
  <Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(
    self: Logger<Message, Output>
  ) => Logger<Message & Message2, readonly [Output, Output2]>
  <Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<
    Message & Message2,
    readonly [Output, Output2]
  >
}

export declare const zipLeft: {
  <Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(
    self: Logger<Message, Output>
  ) => Logger<Message & Message2, Output>
  <Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<
    Message & Message2,
    Output
  >
}

export declare const zipRight: {
  <Message2, Output2>(that: Logger<Message2, Output2>): <Message, Output>(
    self: Logger<Message, Output>
  ) => Logger<Message & Message2, Output2>
  <Message, Output, Message2, Output2>(self: Logger<Message, Output>, that: Logger<Message2, Output2>): Logger<
    Message & Message2,
    Output2
  >
}