the-moby-effect/dist/dts/internal/endpoints/system.d.ts

Moby/Docker API client built using effect-ts

import type * as HttpBody from "@effect/platform/HttpBody";
import type * as HttpClientError from "@effect/platform/HttpClientError";
import type * as Layer from "effect/Layer";
import type * as ParseResult from "effect/ParseResult";
import * as HttpClient from "@effect/platform/HttpClient";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import { RegistryAuthenticateOKBody as AuthResponse, DiskUsage, EventMessage, RegistryAuthConfig, SystemInfoResponse, SystemVersionResponse } from "../generated/index.js";
/**
 * @since 1.0.0
 * @category Errors
 */
export declare const SystemsErrorTypeId: unique symbol;
/**
 * @since 1.0.0
 * @category Errors
 */
export type SystemsErrorTypeId = typeof SystemsErrorTypeId;
/**
 * @since 1.0.0
 * @category Errors
 */
export declare const isSystemsError: (u: unknown) => u is SystemsError;
declare const SystemsError_base: new <A extends Record<string, any>>(args: import("effect/Types").Simplify<A>) => import("effect/Cause").YieldableError & Record<typeof SystemsErrorTypeId, typeof SystemsErrorTypeId> & {
    readonly _tag: "SystemsError";
} & Readonly<A>;
/**
 * @since 1.0.0
 * @category Errors
 */
export declare class SystemsError extends SystemsError_base<{
    method: string;
    cause: ParseResult.ParseError | HttpClientError.HttpClientError | HttpBody.HttpBodyError | unknown;
}> {
    get message(): string;
}
declare const Systems_base: Effect.Service.Class<Systems, "@the-moby-effect/endpoints/System", {
    readonly accessors: false;
    readonly dependencies: readonly [];
    readonly effect: Effect.Effect<{
        auth: (authConfig: typeof RegistryAuthConfig.Encoded) => Effect.Effect<Readonly<AuthResponse>, SystemsError, never>;
        info: () => Effect.Effect<Readonly<SystemInfoResponse>, SystemsError, never>;
        version: () => Effect.Effect<Readonly<SystemVersionResponse>, SystemsError, never>;
        ping: () => Effect.Effect<"OK", SystemsError, never>;
        pingHead: () => Effect.Effect<void, SystemsError, never>;
        events: (options?: {
            readonly since?: string;
            readonly until?: string;
            readonly filters?: {
                config?: string | undefined;
                container?: string | undefined;
                daemon?: string | undefined;
                event?: string | undefined;
                image?: string | undefined;
                label?: string | undefined;
                network?: string | undefined;
                node?: string | undefined;
                plugin?: string | undefined;
                scope?: string | undefined;
                secret?: string | undefined;
                service?: string | undefined;
                type?: string | undefined;
                volume?: string | undefined;
            };
        } | undefined) => Stream.Stream<EventMessage, SystemsError, never>;
        dataUsage: (options?: {
            readonly type?: Array<"container" | "image" | "volume" | "build-cache"> | undefined;
        } | undefined) => Effect.Effect<DiskUsage, SystemsError, never>;
    }, never, HttpClient.HttpClient>;
}>;
/**
 * @since 1.0.0
 * @category Tags
 * @see https://docs.docker.com/reference/api/engine/latest/#tag/System
 */
export declare class Systems extends Systems_base {
}
/**
 * @since 1.0.0
 * @category Layers
 * @see https://docs.docker.com/reference/api/engine/latest/#tag/System
 */
export declare const SystemsLayer: Layer.Layer<Systems, never, HttpClient.HttpClient>;
export {};
//# sourceMappingURL=system.d.ts.map