Callbacks

declare const callbackClient: <E>(
  layer: Layer.Layer<
    Layer.Layer.Success<DockerEngine.DockerLayer>,
    Layer.Layer.Error<DockerEngine.DockerLayer> | E,
    Layer.Layer.Context<DockerEngine.DockerLayer>
  >
) => Promise<{
  pull: (a: {
    image: string
    auth?: string | undefined
    platform?: string | undefined
  }) => ReadableStream<MobySchemas.JSONMessage>
  build: <E1>(a: {
    tag: string
    auth?: string | undefined
    platform?: string | undefined
    dockerfile?: string | undefined
    context: Stream.Stream<Uint8Array, E1, never>
    buildArgs?: Record<string, string | undefined> | undefined
  }) => ReadableStream<MobySchemas.JSONMessage>
  stop: (z: string, callback: (exit: Exit.Exit<void, MobyEndpoints.ContainersError>) => void) => void
  start: (z: string, callback: (exit: Exit.Exit<void, MobyEndpoints.ContainersError>) => void) => void
  run: (
    z: string,
    callback: (exit: Exit.Exit<MobySchemas.ContainerInspectResponse, MobyEndpoints.ContainersError>) => void
  ) => void
  exec: (
    z: { containerId: string; command: string | Array<string> },
    callback: (
      exit: Exit.Exit<readonly [exitCode: number, output: string], ExecsError | SocketError | ParseError>
    ) => void
  ) => void
  execNonBlocking: <T extends boolean | undefined = undefined>(
    z: { detach?: T; containerId: string; command: string | Array<string> },
    callback: (
      exit: Exit.Exit<[socket: T extends true ? void : RawSocket | MultiplexedSocket, execId: string], ExecsError>
    ) => void
  ) => void
  execWebsockets: (
    z: { command: string | Array<string>; containerId: string },
    callback: (exit: Exit.Exit<readonly [stdout: string, stderr: string], any>) => void
  ) => void
  execWebsocketsNonBlocking: (a: {
    command: string | Array<string>
    containerId: string
    cwd?: string | undefined
  }) => ReadableStream<MultiplexedChannel<never, any, never>>
  ps: (
    z:
      | {
          readonly name?: ReadonlyArray<string> | undefined
          readonly ancestor?: ReadonlyArray<string> | undefined
          readonly before?: ReadonlyArray<string> | undefined
          readonly expose?: ReadonlyArray<string> | undefined
          readonly exited?: ReadonlyArray<number> | undefined
          readonly health?: ReadonlyArray<MobySchemas.HealthStatus> | undefined
          readonly id?: ReadonlyArray<string & Brand<"ContainerId">> | undefined
          readonly isolation?: ReadonlyArray<"" | "default" | "process" | "hyperv"> | undefined
          readonly volume?: boolean | undefined
          readonly "is-task"?: boolean | undefined
          readonly label?: ReadonlyArray<string> | undefined
          readonly network?: ReadonlyArray<string> | undefined
          readonly publish?: ReadonlyArray<string> | undefined
          readonly since?: ReadonlyArray<string> | undefined
          readonly status?:
            | ReadonlyArray<"exited" | "created" | "running" | "paused" | "restarting" | "removing" | "dead">
            | undefined
        }
      | undefined,
    callback: (
      exit: Exit.Exit<ReadonlyArray<MobySchemas.ContainerListResponseItem>, MobyEndpoints.ContainersError>
    ) => void
  ) => void
  push: (a: {
    readonly name: string
    readonly tag?: string
    readonly "X-Registry-Auth": string
  }) => ReadableStream<string>
  images: (
    z:
      | {
          readonly all?: boolean
          readonly filters?: string | undefined
          readonly "shared-size"?: boolean | undefined
          readonly digests?: boolean | undefined
        }
      | undefined,
    callback: (exit: Exit.Exit<ReadonlyArray<MobySchemas.ImageSummary>, ImagesError>) => void
  ) => void
  search: (
    z: {
      readonly term: string
      readonly limit?: number | undefined
      readonly stars?: number | undefined
      readonly "is-official"?: boolean | undefined
    },
    callback: (exit: Exit.Exit<ReadonlyArray<MobySchemas.RegistrySearchResponse>, ImagesError>) => void
  ) => void
  version: (callback: (exit: Exit.Exit<Readonly<MobySchemas.SystemVersionResponse>, SystemsError>) => void) => void
  info: (callback: (exit: Exit.Exit<Readonly<MobySchemas.SystemInfoResponse>, SystemsError>) => void) => void
  ping: (callback: (exit: Exit.Exit<"OK", SystemsError>) => void) => void
  pingHead: (callback: (exit: Exit.Exit<void, SystemsError>) => void) => void
  followProgressInConsole: (
    y: Function.LazyArg<ReadableStream<MobySchemas.JSONMessage>>,
    z: (error: unknown) => unknown,
    callback: (exit: Exit.Exit<ReadonlyArray<MobySchemas.JSONMessage>, unknown>) => void
  ) => void
  waitForProgressToComplete: (
    y: Function.LazyArg<ReadableStream<MobySchemas.JSONMessage>>,
    z: (error: unknown) => unknown,
    callback: (exit: Exit.Exit<ReadonlyArray<MobySchemas.JSONMessage>, unknown>) => void
  ) => void
}>

declare const runCallback: {
  <R = never>(
    runtime: Runtime.Runtime<R>,
    arity: 0
  ): <A = void, E = never>(
    function_: () => Effect.Effect<A, E, R>
  ) => (callback: (exit: Exit.Exit<A, E>) => void) => void
  <R = never>(
    runtime: Runtime.Runtime<R>,
    arity: 1
  ): <Z, A = void, E = never>(
    function_: (z: Z) => Effect.Effect<A, E, R>
  ) => (z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void
  <R = never>(
    runtime: Runtime.Runtime<R>,
    arity: 2
  ): <Y, Z, A = void, E = never>(
    function_: (y: Y, z: Z) => Effect.Effect<A, E, R>
  ) => (y: Y, z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void
  <R = never>(
    runtime: Runtime.Runtime<R>,
    arity: 3
  ): <X, Y, Z, A = void, E = never>(
    function_: (x: X, y: Y, z: Z) => Effect.Effect<A, E, R>
  ) => (x: X, y: Y, z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void
  <R = never>(
    runtime: Runtime.Runtime<R>,
    arity: 4
  ): <W, X, Y, Z, A = void, E = never>(
    function_: (w: W, x: X, y: Y, z: Z) => Effect.Effect<A, E, R>
  ) => (w: W, x: X, y: Y, z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void
  <R = never>(
    runtime: Runtime.Runtime<R>,
    arity: 5
  ): <V, W, X, Y, Z, A = void, E = never>(
    function_: (v: V, w: W, x: X, y: Y, z: Z) => Effect.Effect<A, E, R>
  ) => (v: V, w: W, x: X, y: Y, z: Z, callback: (exit: Exit.Exit<A, E>) => void) => void
}

declare const runCallbackForEffect: <R = never>(
  runtime: Runtime.Runtime<R>
) => <A = void, E = never>(
  effect: Effect.Effect<A, E, R>
) => (
  callback: (exit: Exit.Exit<A, E>) => void
) => (fiberId?: FiberId, options?: Runtime.RunCallbackOptions<A, E> | undefined) => void