@lakutata/containerd 0.0.0-stage → 3.0.0-beta.0

package/dist/types/client/ContainerdClient.d.ts

@@ -0,0 +1,244 @@
+import { GRPCConnection, GRPCError, type CallOptions, type Message, type Schema } from '@lakutata/grpc';
+/**
+ * A descriptor of content (OCI)
+ */
+export type ContentDescriptor = {
+    mediaType: string;
+    digest: string;
+    size: number;
+    annotations?: Record<string, string>;
+    platform?: {
+        os: string;
+        architecture: string;
+        variant?: string;
+    };
+};
+/**
+ * A mount of a snapshot
+ */
+export type SnapshotMount = {
+    type: string;
+    source: string;
+    target?: string;
+    options: string[];
+};
+/**
+ * An event of containerd, as {@link Containerd.events} streams it: its topic (`/tasks/exit`), its type
+ * (`containerd.events.TaskExit`) and its decoded fields.
+ */
+export type ContainerdEvent = {
+    /**
+     * When containerd published the event.
+     */
+    timestamp: Date;
+    /**
+     * The namespace the event happened in (the component's).
+     */
+    namespace: string;
+    /**
+     * The event's topic: `/tasks/create`, `/tasks/start`, `/tasks/exit`, `/tasks/delete`, `/tasks/oom`,
+     * `/tasks/paused`, `/tasks/resumed`, `/tasks/exec-added`, `/tasks/exec-started`, `/containers/create`,
+     * `/containers/update`, `/containers/delete`, `/images/create`, `/images/update`, `/images/delete`,
+     * `/snapshot/prepare`, `/snapshot/commit`, `/snapshot/remove`…
+     */
+    topic: string;
+    /**
+     * The type of the event's payload (`containerd.events.TaskExit`).
+     */
+    type: string;
+    /**
+     * The event's fields, decoded for the task, container, image and snapshot events (`{containerId, pid, exitStatus,
+     * exitedAt}` for `/tasks/exit`, `{name}` for `/images/delete`); an empty object for the other events.
+     */
+    event: Message;
+};
+/**
+ * The type URL of the specifications of the containers and of their processes (OCI runtime spec, JSON)
+ */
+export declare const SPEC_TYPE_URL: string;
+export declare const PROCESS_TYPE_URL: string;
+export declare const RESOURCES_TYPE_URL: string;
+/**
+ * A date of a Timestamp
+ * @param timestamp
+ */
+export declare function timestampDate(timestamp: Message | undefined): Date | undefined;
+/**
+ * Whether an error is the one of a call of a code
+ * @param error
+ * @param code
+ */
+export declare function isGRPCError(error: unknown, code: number): error is GRPCError;
+/**
+ * The client of the API of containerd (its services of the version 1), in a namespace: its calls are the ones of
+ * ctr and nerdctl
+ */
+export declare class ContainerdClient {
+    readonly namespace: string;
+    readonly grpc: GRPCConnection;
+    constructor(socketPath: string, namespace: string);
+    /**
+     * The options of a call: its namespace, its lease (the content and the snapshots it creates are kept by it until
+     * they are referenced)
+     * @param lease
+     * @param signal
+     */
+    protected options(lease?: string, signal?: AbortSignal): CallOptions;
+    /**
+     * Call a method of a service
+     * @param service its name and its version (images.v1.Images)
+     * @param method
+     * @param requestSchema
+     * @param request
+     * @param responseSchema
+     * @param lease
+     * @param signal
+     */
+    protected call(service: string, method: string, requestSchema: Schema, request: Message, responseSchema?: Schema, lease?: string, signal?: AbortSignal): Promise<Message>;
+    /**
+     * Call a method, undefined when what it reads does not exist
+     * @param promise
+     */
+    protected orUndefined<T>(promise: Promise<T>): Promise<T | undefined>;
+    version(): Promise<{
+        version: string;
+        revision: string;
+    }>;
+    /**
+     * Create the namespace of the client, when it does not exist
+     */
+    ensureNamespace(): Promise<void>;
+    /**
+     * Create a lease, which keeps what is created under it until it is deleted (or expired)
+     * @param expireSeconds
+     */
+    createLease(expireSeconds?: number): Promise<string>;
+    deleteLease(id: string): Promise<void>;
+    getImage(name: string): Promise<Message | undefined>;
+    listImages(filters?: string[]): Promise<Message[]>;
+    /**
+     * Create an image, or update it when it exists (its target and its labels)
+     * @param image
+     * @param lease
+     */
+    putImage(image: Message, lease?: string): Promise<Message>;
+    deleteImage(name: string, sync?: boolean): Promise<void>;
+    contentInfo(digest: string): Promise<Message | undefined>;
+    /**
+     * Set labels of a content
+     * @param digest
+     * @param labels
+     */
+    labelContent(digest: string, labels: Record<string, string>): Promise<void>;
+    /**
+     * Read a content, by its chunks
+     * @param digest
+     * @param signal
+     */
+    readContent(digest: string, signal?: AbortSignal): AsyncGenerator<Buffer>;
+    /**
+     * Read a content whole
+     * @param digest
+     */
+    readAll(digest: string): Promise<Buffer>;
+    /**
+     * Write a content, checked by its digest (a content which exists is kept), its labels set
+     * @param descriptor its digest and its size
+     * @param data its bytes, or their chunks
+     * @param lease
+     * @param labels
+     * @param signal
+     */
+    writeContent(descriptor: {
+        digest: string;
+        size: number;
+    }, data: Uint8Array | AsyncIterable<Uint8Array>, lease: string, labels?: Record<string, string>, signal?: AbortSignal): Promise<void>;
+    deleteContent(digest: string): Promise<void>;
+    prepareSnapshot(snapshotter: string, key: string, parent: string, labels?: Record<string, string>, lease?: string): Promise<SnapshotMount[]>;
+    snapshotMounts(snapshotter: string, key: string): Promise<SnapshotMount[]>;
+    commitSnapshot(snapshotter: string, name: string, key: string, labels?: Record<string, string>, lease?: string): Promise<void>;
+    viewSnapshot(snapshotter: string, key: string, parent: string, lease?: string): Promise<SnapshotMount[]>;
+    /**
+     * The layer of the changes of a snapshot from another one (tar+gzip), written into the content store
+     * @param left the older one
+     * @param right the newer one
+     * @param lease
+     */
+    diff(left: SnapshotMount[], right: SnapshotMount[], lease?: string): Promise<ContentDescriptor>;
+    /**
+     * The metrics of the cgroup of a task: their type (io.containerd.cgroups.v1.Metrics, …v2.Metrics) and their bytes
+     * @param containerId
+     */
+    metrics(containerId: string): Promise<Message | undefined>;
+    removeSnapshot(snapshotter: string, key: string): Promise<void>;
+    statSnapshot(snapshotter: string, key: string): Promise<Message | undefined>;
+    snapshotUsage(snapshotter: string, key: string): Promise<{
+        size: number;
+        inodes: number;
+    }>;
+    /**
+     * Apply a layer (its content) to the mounts of a snapshot
+     * @param layer
+     * @param mounts
+     * @param lease
+     */
+    applyLayer(layer: ContentDescriptor, mounts: SnapshotMount[], lease?: string): Promise<ContentDescriptor>;
+    getContainer(id: string): Promise<Message | undefined>;
+    listContainers(filters?: string[]): Promise<Message[]>;
+    createContainer(container: Message, lease?: string): Promise<Message>;
+    updateContainer(container: Message, paths: string[]): Promise<Message>;
+    deleteContainer(id: string): Promise<void>;
+    createTask(request: Message): Promise<number>;
+    startTask(containerId: string, execId?: string): Promise<number>;
+    deleteTask(containerId: string): Promise<Message | undefined>;
+    deleteProcess(containerId: string, execId: string): Promise<Message | undefined>;
+    getTask(containerId: string, execId?: string): Promise<Message | undefined>;
+    listTasks(): Promise<Message[]>;
+    kill(containerId: string, signal: number, options?: {
+        execId?: string;
+        all?: boolean;
+    }): Promise<void>;
+    exec(request: Message): Promise<void>;
+    resizePty(containerId: string, execId: string, width: number, height: number): Promise<void>;
+    closeIO(containerId: string, execId: string): Promise<void>;
+    pause(containerId: string): Promise<void>;
+    resume(containerId: string): Promise<void>;
+    listPids(containerId: string): Promise<number[]>;
+    /**
+     * Wait for a process to exit (the task, an exec)
+     * @param containerId
+     * @param execId
+     * @param signal
+     */
+    wait(containerId: string, execId?: string, signal?: AbortSignal): Promise<{
+        exitStatus: number;
+        exitedAt?: Date;
+    }>;
+    /**
+     * Update the resources of a task (OCI LinuxResources)
+     * @param containerId
+     * @param resources
+     */
+    updateTask(containerId: string, resources: object): Promise<void>;
+    /**
+     * The events of containerd, their fields decoded (the ones of the tasks, the containers and the images)
+     * @param filters the filters of containerd (topic~="/tasks/", namespace==default)
+     * @param signal its end
+     */
+    subscribe(filters?: string[], signal?: AbortSignal): AsyncGenerator<ContainerdEvent>;
+    /**
+     * An Any of JSON (the specifications of OCI)
+     * @param typeUrl
+     * @param value
+     */
+    static Json(typeUrl: string, value: object): Message;
+    /**
+     * The value of an Any of JSON
+     * @param any
+     */
+    static FromJson<T = any>(any: Message | undefined): T | undefined;
+    /**
+     * Close the connection
+     */
+    close(): void;
+}

package/dist/types/client/DockerIgnore.d.ts

@@ -0,0 +1,44 @@
+type DockerIgnoreRule = {
+    pattern: string;
+    directories: string[];
+    negative: boolean;
+    expression?: RegExp;
+};
+/**
+ * The rules of a .dockerignore file: the files of a build context they exclude
+ */
+export declare class DockerIgnore {
+    #private;
+    protected readonly ignoreCase: boolean;
+    /**
+     * @param content the content of a .dockerignore file
+     * @param ignoreCase match the case-insensitively, as Docker does not (false by default)
+     */
+    constructor(content?: string, ignoreCase?: boolean);
+    /**
+     * Add the rules of a content
+     * @param content
+     */
+    add(content: string): this;
+    /**
+     * A rule of a line (moby/moby builder/dockerignore/dockerignore.go and pkg/fileutils/fileutils.go)
+     * @param line
+     */
+    protected rule(line: string): DockerIgnoreRule | undefined;
+    /**
+     * The regular expression of a rule (fileutils.go regexpMatch)
+     * @param rule
+     */
+    protected expression(rule: DockerIgnoreRule): RegExp;
+    /**
+     * Whether a file of the context is excluded by the rules (its path relative to the context, "/" separated)
+     * @param file
+     */
+    ignores(file: string): boolean;
+    /**
+     * Whether a file is excluded: the last rule matching it or one of its parent directories decides
+     * @param file
+     */
+    protected test(file: string): boolean;
+}
+export {};

package/dist/types/client/Fifo.d.ts

@@ -0,0 +1,31 @@
+import net from 'node:net';
+/**
+ * The FIFOs of the standard streams of a process of containerd (the ones of its cio): created by mkfifo, the shim
+ * writing (or reading) them, read (or written) from the event loop
+ */
+export declare class ProcessFifo {
+    #private;
+    readonly path: string;
+    protected readonly direction: 'read' | 'write';
+    protected constructor(path: string, direction: 'read' | 'write');
+    /**
+     * Whether the FIFOs can be created (mkfifo of the system: coreutils, busybox)
+     */
+    static Supported(): boolean;
+    /**
+     * Create a FIFO, kept open (read and write) for the shim to open its end without waiting
+     * @param path
+     * @param direction read: the shim writes it (stdout, stderr), write: the shim reads it (stdin)
+     */
+    static Create(path: string, direction: 'read' | 'write'): ProcessFifo;
+    /**
+     * Its end opened, once the shim has opened its own one (after the creation of the process): the one kept closed,
+     * the end of the stream is the one of the shim
+     */
+    open(): net.Socket;
+    protected releaseKeeper(): void;
+    /**
+     * Close it
+     */
+    close(): void;
+}

package/dist/types/client/ImageStore.d.ts

@@ -0,0 +1,258 @@
+import { ContainerdClient, type ContentDescriptor } from './ContainerdClient.js';
+import { type Message } from '@lakutata/grpc';
+import { type Platform } from './Platforms.js';
+import { type RegistryOptions } from './Registry.js';
+/**
+ * A manifest of an image (OCI, Docker)
+ */
+export type ImageManifest = {
+    schemaVersion: number;
+    mediaType?: string;
+    config: ContentDescriptor;
+    layers: ContentDescriptor[];
+    annotations?: Record<string, string>;
+};
+/**
+ * An index of the manifests of the platforms of an image
+ */
+export type ImageIndex = {
+    schemaVersion: number;
+    mediaType?: string;
+    manifests: ContentDescriptor[];
+    annotations?: Record<string, string>;
+};
+/**
+ * The configuration of an image (OCI): its platform, the configuration of its containers, its layers
+ */
+export type ImageConfigFile = {
+    architecture: string;
+    os: string;
+    variant?: string;
+    created?: string;
+    config?: {
+        Env?: string[];
+        Cmd?: string[];
+        Entrypoint?: string[];
+        WorkingDir?: string;
+        User?: string;
+        ExposedPorts?: Record<string, object>;
+        Volumes?: Record<string, object>;
+        Labels?: Record<string, string>;
+        StopSignal?: string;
+    };
+    rootfs: {
+        type: string;
+        diff_ids: string[];
+    };
+};
+/**
+ * The changes of the configuration of an image committed
+ */
+export type ImageConfigChanges = {
+    cmd?: string[];
+    entrypoint?: string[];
+    /**
+     * Its environment variables added or replaced (KEY=value)
+     */
+    env?: string[];
+    workingDir?: string;
+    user?: string;
+    labels?: Record<string, string>;
+    /**
+     * Its ports exposed (80, 53/udp)
+     */
+    exposedPorts?: string[];
+};
+/**
+ * An image of a platform, resolved: its manifest and its configuration
+ */
+export type ResolvedImage = {
+    image: Message;
+    name: string;
+    target: ContentDescriptor;
+    manifestDescriptor: ContentDescriptor;
+    manifest: ImageManifest;
+    config: ImageConfigFile;
+    platform: Platform;
+};
+/**
+ * The progress of the transfer of a blob
+ */
+export type TransferProgress = {
+    digest: string;
+    mediaType: string;
+    current: number;
+    total: number;
+};
+/**
+ * The options of a pull
+ */
+export type PullOptions = {
+    /**
+     * The platforms pulled: the one of the machine by default, all with "all"
+     */
+    platforms?: Platform[] | 'all';
+    registry?: RegistryOptions;
+    /**
+     * Unpack the layers of the platforms the machine runs (the ones of the store) into its snapshots, true by default
+     */
+    unpack?: boolean;
+    progress?: (progress: TransferProgress) => void;
+};
+/**
+ * The identifiers of the chain of layers (OCI): the ones of the snapshots of their unpacking
+ * @param diffIds
+ */
+export declare function chainIds(diffIds: string[]): string[];
+/**
+ * The images of containerd: pulled from the registries, unpacked into the snapshots, pushed, imported and exported
+ * (OCI image layouts, the archives of docker save), as ctr and nerdctl do: their content bound by the labels of the
+ * garbage collection of containerd, under a lease until the image references it
+ */
+export declare class ImageStore {
+    protected readonly client: ContainerdClient;
+    readonly snapshotter: string;
+    readonly temporary: string;
+    readonly runnablePlatforms: () => Platform[];
+    /**
+     * @param client
+     * @param snapshotter
+     * @param temporary the directory of the archives extracted (a disk of the machine, not a small tmpfs)
+     * @param runnablePlatforms the platforms the machine runs, unpacked by the pulls and the imports (the one of the
+     * machine by default)
+     */
+    constructor(client: ContainerdClient, snapshotter: string, temporary?: string, runnablePlatforms?: () => Platform[]);
+    /**
+     * The JSON of a content
+     * @param digest
+     */
+    protected readJson<T>(digest: string): Promise<T>;
+    /**
+     * The best manifest of an index for a platform, among the ones the content store has (or all)
+     * @param index
+     * @param platform
+     * @param local
+     */
+    protected chooseManifest(index: ImageIndex, platform: Platform, local: boolean): Promise<ContentDescriptor | undefined>;
+    /**
+     * The image of a name (the reference given or its normalized name), undefined when it does not exist
+     * @param name
+     */
+    get(name: string): Promise<Message | undefined>;
+    /**
+     * Resolve an image for a platform: its manifest and its configuration (the manifest of the platform of its index)
+     * @param name
+     * @param platform the one of the machine by default
+     */
+    resolve(name: string, platform?: Platform): Promise<ResolvedImage>;
+    /**
+     * The platforms of an image the content store has (the ones pulled)
+     * @param name
+     */
+    platforms(name: string): Promise<Platform[]>;
+    /**
+     * Unpack the layers of an image into the snapshots of the snapshotter (named by the chain of their identifiers), the
+     * configuration bound to the last one
+     * @param manifest
+     * @param lease
+     */
+    unpack(manifest: ImageManifest, lease: string): Promise<string>;
+    /**
+     * Write a manifest, its configuration and its layers (the blobs given by a source), bound by the labels of the
+     * garbage collection
+     * @param manifest
+     * @param blob the bytes of a blob (its stream)
+     * @param lease
+     * @param labels the labels of all the content (its source)
+     * @param progress
+     */
+    protected writeImage(manifest: ImageManifest, blob: (descriptor: ContentDescriptor) => Promise<Uint8Array | AsyncIterable<Uint8Array>>, lease: string, labels: Record<string, string>, progress?: (progress: TransferProgress) => void): Promise<void>;
+    /**
+     * The labels of a manifest binding its configuration and its layers
+     * @param manifest
+     */
+    protected manifestLabels(manifest: ImageManifest): Record<string, string>;
+    /**
+     * Pull an image from its registry: the manifests of the platforms asked (of its index), their configurations and
+     * their layers; the image named by its reference (docker.io/library/busybox:latest), unpacked for the machine
+     * @param reference
+     * @param options
+     */
+    pull(reference: string, options?: PullOptions): Promise<string>;
+    /**
+     * Unpack an image for the platforms the machine runs, among the ones the content store has (its manifests pulled):
+     * not the other platforms, nor the attestations (unknown/unknown)
+     * @param name
+     * @param lease
+     */
+    protected unpackFor(name: string, lease: string): Promise<void>;
+    /**
+     * Push an image to a registry (as another reference): the manifest of the platform asked; without it, the manifests
+     * of all the platforms and the index when the content store has all of them, the manifest of the machine's platform
+     * otherwise
+     * @param name
+     * @param options
+     */
+    push(name: string, options?: {
+        reference?: string;
+        platform?: Platform;
+        registry?: RegistryOptions;
+        progress?: (progress: TransferProgress) => void;
+    }): Promise<void>;
+    /**
+     * Commit the changes of a snapshot (the one of a container) on its image: a layer of their diff, the configuration
+     * of the image with its changes, a manifest of the platform, the image named (and unpacked)
+     * @param options
+     */
+    commit(options: {
+        image: string;
+        platform: Platform;
+        snapshotKey: string;
+        name: string;
+        changes?: ImageConfigChanges;
+        comment?: string;
+        author?: string;
+    }): Promise<string>;
+    /**
+     * Name an image again (a tag), its target the same
+     * @param name
+     * @param reference
+     */
+    tag(name: string, reference: string): Promise<string>;
+    /**
+     * Remove an image (its content and its snapshots are collected by containerd once nothing references them)
+     * @param name
+     */
+    remove(name: string): Promise<void>;
+    /**
+     * Import an archive of images: an OCI image layout (nerdctl save, docker save of Docker 25+), or an archive of
+     * docker save; the images named by the archive (or by a name given, to an archive of one image), unpacked for the
+     * platforms the machine runs
+     * @param source a file, or its stream
+     * @param options
+     */
+    import(source: string | NodeJS.ReadableStream, options?: {
+        name?: string;
+        unpack?: boolean;
+    }): Promise<string[]>;
+    /**
+     * Write a manifest or an index of an archive, and what it references (the manifests the archive has)
+     * @param descriptor
+     * @param blob
+     * @param lease
+     */
+    protected writeTree(descriptor: ContentDescriptor, blob: (descriptor: ContentDescriptor) => Promise<AsyncIterable<Uint8Array>>, lease: string): Promise<void>;
+    /**
+     * Extract an archive into a directory
+     * @param source
+     * @param directory
+     */
+    protected extract(source: NodeJS.ReadableStream, directory: string): Promise<void>;
+    /**
+     * Export images into an archive: an OCI image layout (named by io.containerd.image.name), with the manifest.json of
+     * docker load (the manifest of the platform of the machine, or the first one)
+     * @param names
+     * @param destination a file, or its stream
+     */
+    export(names: string[], destination: string | NodeJS.WritableStream): Promise<void>;
+}

package/dist/types/client/Messages.d.ts

@@ -0,0 +1,103 @@
+import { type Schema } from '@lakutata/grpc';
+export declare const Empty: Schema;
+export declare const Timestamp: Schema;
+export declare const Any: Schema;
+export declare const FieldMask: Schema;
+export declare const Descriptor: Schema;
+export declare const Mount: Schema;
+export declare const VersionResponse: Schema;
+export declare const Namespace: Schema;
+export declare const CreateNamespaceRequest: Schema;
+export declare const ListNamespacesResponse: Schema;
+export declare const Image: Schema;
+export declare const GetImageRequest: Schema;
+export declare const ImageResponse: Schema;
+export declare const CreateImageRequest: Schema;
+export declare const UpdateImageRequest: Schema;
+export declare const ListImagesRequest: Schema;
+export declare const ListImagesResponse: Schema;
+export declare const DeleteImageRequest: Schema;
+export declare const ContentInfo: Schema;
+export declare const InfoRequest: Schema;
+export declare const InfoResponse: Schema;
+export declare const UpdateContentRequest: Schema;
+export declare const DeleteContentRequest: Schema;
+export declare const ReadContentRequest: Schema;
+export declare const ReadContentResponse: Schema;
+/**
+ * The actions of the writes of content
+ */
+export declare enum WriteAction {
+    STAT = 0,
+    WRITE = 1,
+    COMMIT = 2
+}
+export declare const WriteContentRequest: Schema;
+export declare const WriteContentResponse: Schema;
+export declare const AbortRequest: Schema;
+export declare const Lease: Schema;
+export declare const CreateLeaseRequest: Schema;
+export declare const CreateLeaseResponse: Schema;
+export declare const DeleteLeaseRequest: Schema;
+export declare const PrepareSnapshotRequest: Schema;
+export declare const MountsResponse: Schema;
+export declare const MountsRequest: Schema;
+export declare const CommitSnapshotRequest: Schema;
+export declare const SnapshotKeyRequest: Schema;
+export declare const SnapshotInfo: Schema;
+export declare const StatSnapshotResponse: Schema;
+export declare const UsageResponse: Schema;
+export declare const ApplyRequest: Schema;
+export declare const ApplyResponse: Schema;
+export declare const ContainerRuntime: Schema;
+export declare const Container: Schema;
+export declare const GetContainerRequest: Schema;
+export declare const ContainerResponse: Schema;
+export declare const CreateContainerRequest: Schema;
+export declare const UpdateContainerRequest: Schema;
+export declare const ListContainersRequest: Schema;
+export declare const ListContainersResponse: Schema;
+export declare const DeleteContainerRequest: Schema;
+/**
+ * The states of the processes of the tasks
+ */
+export declare enum ProcessStatus {
+    UNKNOWN = 0,
+    CREATED = 1,
+    RUNNING = 2,
+    STOPPED = 3,
+    PAUSED = 4,
+    PAUSING = 5
+}
+export declare const Process: Schema;
+export declare const CreateTaskRequest: Schema;
+export declare const CreateTaskResponse: Schema;
+export declare const ProcessRequest: Schema;
+export declare const StartResponse: Schema;
+export declare const DeleteTaskRequest: Schema;
+export declare const DeleteTaskResponse: Schema;
+export declare const GetTaskResponse: Schema;
+export declare const ListTasksRequest: Schema;
+export declare const ListTasksResponse: Schema;
+export declare const KillRequest: Schema;
+export declare const ExecProcessRequest: Schema;
+export declare const ResizePtyRequest: Schema;
+export declare const CloseIORequest: Schema;
+export declare const ContainerIdRequest: Schema;
+export declare const ListPidsResponse: Schema;
+export declare const WaitResponse: Schema;
+export declare const UpdateTaskRequest: Schema;
+export declare const SubscribeRequest: Schema;
+export declare const Envelope: Schema;
+/**
+ * The events of containerd decoded, by their type (the type URL of their Any)
+ */
+export declare const EVENTS: Readonly<Record<string, Schema>>;
+export declare const RuncOptions: Schema;
+export declare const MetricsRequest: Schema;
+export declare const Metric: Schema;
+export declare const MetricsResponse: Schema;
+export declare const CgroupV2Metrics: Schema;
+export declare const CgroupV1Metrics: Schema;
+export declare const DiffRequest: Schema;
+export declare const DiffResponse: Schema;