export declare const make: (options: Omit<Tracer, typeof TracerTypeId>) => Tracer

export declare const tracerWith: <R, E, A>(f: (tracer: Tracer) => Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>

export type AttributeValue = string | boolean | number

export interface ExternalSpan {
  readonly _tag: 'ExternalSpan'
  readonly spanId: string
  readonly traceId: string
  readonly context: Context.Context<never>
}

export type ParentSpan = Span | ExternalSpan

export interface Span {
  readonly _tag: 'Span'
  readonly name: string
  readonly spanId: string
  readonly traceId: string
  readonly parent: Option.Option<ParentSpan>
  readonly context: Context.Context<never>
  readonly status: SpanStatus
  readonly attributes: ReadonlyMap<string, AttributeValue>
  readonly links: ReadonlyArray<SpanLink>
  readonly end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void
  readonly attribute: (key: string, value: AttributeValue) => void
  readonly event: (name: string, startTime: bigint, attributes?: Record<string, AttributeValue>) => void
}

export interface SpanLink {
  readonly _tag: 'SpanLink'
  readonly span: ParentSpan
  readonly attributes: Readonly<Record<string, AttributeValue>>
}

export type SpanStatus =
  | {
      _tag: 'Started'
      startTime: bigint
    }
  | {
      _tag: 'Ended'
      startTime: bigint
      endTime: bigint
      exit: Exit.Exit<unknown, unknown>
    }

export declare const Tracer: Context.Tag<Tracer, Tracer>

export interface Tracer {
  readonly [TracerTypeId]: TracerTypeId
  readonly span: (
    name: string,
    parent: Option.Option<ParentSpan>,
    context: Context.Context<never>,
    links: ReadonlyArray<SpanLink>,
    startTime: bigint
  ) => Span
  readonly context: <X>(f: () => X, fiber: Fiber.RuntimeFiber<any, any>) => X
}

export declare const TracerTypeId: typeof TracerTypeId

export type TracerTypeId = typeof TracerTypeId