export declare class DockerComposeError

export declare const isDockerComposeError: (u: unknown) => u is DockerComposeError

export declare const layerAgnostic: (
  connectionOptions: HttpConnectionOptionsTagged | HttpsConnectionOptionsTagged
) => Layer.Layer<DockerCompose, SystemsError | ContainersError, HttpClient.HttpClient | Socket.WebSocketConstructor>

export declare const layerBun: (
  connectionOptions: MobyConnectionOptions
) => Layer.Layer<DockerCompose, SystemsError | ContainersError, never>

export declare const layerDeno: (
  connectionOptions: MobyConnectionOptions
) => Layer.Layer<DockerCompose, SystemsError | ContainersError, never>

export declare const layerNodeJS: (
  connectionOptions: MobyConnectionOptions
) => Layer.Layer<DockerCompose, SystemsError | ContainersError, never>

export declare const layerProject: <E1>(
  project: Stream.Stream<Uint8Array, E1, never>,
  tagIdentifier: string
) => {
  readonly tag: Context.Tag<DockerComposeProject, DockerComposeProject>
  readonly layer: Layer.Layer<DockerComposeProject, E1 | DockerComposeError, DockerCompose>
}

export declare const layerUndici: (
  connectionOptions: MobyConnectionOptions
) => Layer.Layer<DockerCompose, SystemsError | ContainersError, never>

export declare const layerWeb: (
  connectionOptions: HttpConnectionOptionsTagged | HttpsConnectionOptionsTagged
) => Layer.Layer<DockerCompose, SystemsError | ContainersError, never>

export interface DockerCompose {
  readonly [TypeId]: TypeId

  readonly build: <E1>(
    project: Stream.Stream<Uint8Array, E1, never>,
    options: {}
  ) => Effect.Effect<void, E1 | DockerComposeError, never>

  readonly pull: <E1>(
    project: Stream.Stream<Uint8Array, E1, never>,
    options: {}
  ) => Effect.Effect<void, E1 | DockerComposeError, never>

  readonly up: <E1>(
    project: Stream.Stream<Uint8Array, E1, never>,
    options: {}
  ) => Effect.Effect<void, E1 | DockerComposeError, never>

  readonly down: <E1>(
    project: Stream.Stream<Uint8Array, E1, never>,
    options: {}
  ) => Effect.Effect<void, E1 | DockerComposeError, never>

  readonly rm: <E1>(
    project: Stream.Stream<Uint8Array, E1, never>,
    options: {}
  ) => Effect.Effect<void, E1 | DockerComposeError, never>

  readonly kill: <E1>(
    project: Stream.Stream<Uint8Array, E1, never>,
    options: {}
  ) => Effect.Effect<void, E1 | DockerComposeError, never>

  readonly forProject: <E1>(
    project: Stream.Stream<Uint8Array, E1, never>
  ) => Effect.Effect<DockerComposeProject, E1 | DockerComposeError, never>
}

export interface DockerComposeProject {
  readonly [DockerComposeProjectTypeId]: DockerComposeProjectTypeId
  readonly build: (options: {}) => Effect.Effect<void, DockerComposeError, never>
  readonly pull: (options: {}) => Effect.Effect<void, DockerComposeError, never>
  readonly up: (options: {}) => Effect.Effect<void, DockerComposeError, never>
  readonly down: (options: {}) => Effect.Effect<void, DockerComposeError, never>
  readonly rm: (options: {}) => Effect.Effect<void, DockerComposeError, never>
  readonly kill: (options: {}) => Effect.Effect<void, DockerComposeError, never>
}

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

export declare const DockerComposeProjectTypeId: typeof DockerComposeProjectTypeId

export type DockerComposeProjectTypeId = typeof DockerComposeProjectTypeId

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId