@t-0/provider-sdk 1.1.28 → 1.1.30

package/lib/cjs/service/validate_response.js

@@ -1,38 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createResponseValidation = void 0;
-exports.createValidationInterceptor = createValidationInterceptor;
-const connect_1 = require("@connectrpc/connect");
-const protovalidate_1 = require("@bufbuild/protovalidate");
-const validate_1 = require("@connectrpc/validate");
-const validator = (0, protovalidate_1.createValidator)();
+exports.createResponseValidation = exports.networkRegistry = exports.createValidationInterceptor = void 0;
+exports.createNetworkValidationInterceptor = createNetworkValidationInterceptor;
+const protobuf_1 = require("@bufbuild/protobuf");
+const provider_pb_js_1 = require("../common/gen/tzero/v1/payment/provider_pb.js");
+const network_pb_js_1 = require("../common/gen/tzero/v1/payment/network_pb.js");
+const validation_js_1 = require("../common/validation.js");
+// Re-export everything from the common layer for backward compatibility.
+var validation_js_2 = require("../common/validation.js");
+Object.defineProperty(exports, "createValidationInterceptor", { enumerable: true, get: function () { return validation_js_2.createValidationInterceptor; } });
 /**
- * Creates a ConnectRPC interceptor that validates provider responses against
- * buf.validate proto annotations before they are serialized and sent.
- * Also validates incoming requests using the official @connectrpc/validate interceptor.
- *
- * Invalid requests return Code.InvalidArgument; invalid responses return Code.Internal.
+ * Registry covering the t-0 network provider contract protos. Leaf file
+ * descriptors pull in their full dependency graph, so adding new messages
+ * or fields to existing protos requires only `buf:generate`.
  */
-function createValidationInterceptor() {
-    const requestInterceptor = (0, validate_1.createValidateInterceptor)();
-    return (next) => async (req) => {
-        // Validate request (delegates to official interceptor which throws on invalid)
-        const resp = await requestInterceptor(next)(req);
-        // Validate response
-        const schema = req.method.output;
-        const msg = resp.message;
-        const result = validator.validate(schema, msg);
-        if (result.kind === "invalid") {
-            const details = result.violations.map(v => `${v.field?.toString() ?? ""}: ${v.message}`).join("; ");
-            throw new connect_1.ConnectError(`response validation failed: ${details}`, connect_1.Code.Internal);
-        }
-        if (result.kind === "error") {
-            throw new connect_1.ConnectError(`response validation error: ${result.error.message}`, connect_1.Code.Internal);
-        }
-        return resp;
-    };
+exports.networkRegistry = (0, protobuf_1.createRegistry)(provider_pb_js_1.file_tzero_v1_payment_provider, network_pb_js_1.file_tzero_v1_payment_network);
+/**
+ * Validation interceptor pre-configured for the t-0 network provider contract.
+ */
+function createNetworkValidationInterceptor(logger) {
+    return (0, validation_js_1.createValidationInterceptor)({ logger, registry: exports.networkRegistry });
 }
 /**
  * @deprecated Use createValidationInterceptor instead.
  */
-exports.createResponseValidation = createValidationInterceptor;
+exports.createResponseValidation = validation_js_1.createValidationInterceptor;

package/lib/cjs/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "1.1.28";
+export declare const SDK_VERSION = "1.1.30";

package/lib/cjs/version.js

@@ -3,4 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
 // SDK semantic version. Bumped in lockstep with all other SDKs by the
 // release.yaml workflow.
-exports.SDK_VERSION = "1.1.28";
+exports.SDK_VERSION = "1.1.30";

package/lib/esm/client/client.d.ts

@@ -1,16 +1,6 @@
-import { DescService } from "@bufbuild/protobuf";
+import { type Signature } from "../common/client/client.js";
+import type { DescService } from "@bufbuild/protobuf";
 export declare const DEFAULT_ENDPOINT = "https://api.t-0.network";
 export declare function createClient<T extends DescService>(signer: string | Buffer | ((data: Buffer) => Promise<Signature>) | Buffer<ArrayBufferLike>, endpoint: string | undefined, svc: T): import("@connectrpc/connect").Client<T>;
-/**
- * Signature with metadata for particular request
- */
-export interface Signature {
-    signature: Buffer;
-    publicKey: Buffer;
-}
-/**
- * Signature function for signing requests to T-0 API. Accepts any data in string format and return signature
- * with metadata
- */
-export type SignerFunction = (data: Buffer) => Promise<Signature>;
+export type { Signature, SignerFunction } from "../common/client/client.js";
 export default createClient;

package/lib/esm/client/client.js

@@ -1,39 +1,6 @@
-import { createClient as createConnectClient } from "@connectrpc/connect";
-import { createConnectTransport } from "@connectrpc/connect-web";
-import { keccak_256 } from "@noble/hashes/sha3.js";
-import CreateSigner from "./signer.js";
-import NetworkHeaders from "../common/headers.js";
+import { createClient as createClientCommon } from "../common/client/client.js";
 export const DEFAULT_ENDPOINT = "https://api.t-0.network";
 export function createClient(signer, endpoint, svc) {
-    let customFetch;
-    endpoint = endpoint || DEFAULT_ENDPOINT;
-    if (typeof signer === "string" || Buffer.isBuffer(signer)) {
-        signer = CreateSigner(signer);
-    }
-    customFetch = async (r, init) => {
-        if (!init?.body || !((init.body) instanceof Uint8Array)) {
-            throw "unsupported body type";
-        }
-        const ts = Date.now();
-        // 64‑bit little‑endian timestamp
-        const tsBuf = Buffer.alloc(8);
-        tsBuf.writeBigUInt64LE(BigInt(ts));
-        const hash = keccak_256.create()
-            .update(init.body)
-            .update(tsBuf);
-        const hashHex = Buffer.from(hash.digest());
-        const sig = await signer(hashHex);
-        const headers = new Headers(init?.headers);
-        headers.append(NetworkHeaders.Signature, "0x" + sig.signature.toString('hex'));
-        headers.append(NetworkHeaders.PublicKey, "0x" + sig.publicKey.toString('hex'));
-        headers.append(NetworkHeaders.SignatureTimestamp, ts.toString());
-        const modifiedInit = { ...init, headers };
-        return fetch(r, modifiedInit);
-    };
-    const transport = createConnectTransport({
-        baseUrl: endpoint || DEFAULT_ENDPOINT,
-        fetch: customFetch,
-    });
-    return createConnectClient(svc, transport);
+    return createClientCommon(signer, endpoint || DEFAULT_ENDPOINT, svc);
 }
 export default createClient;

package/lib/esm/client/signer.d.ts

@@ -1,3 +1 @@
-import { Signature } from "./client.js";
-export declare const CreateSigner: (privateKey: string | Buffer) => (data: Buffer) => Promise<Signature>;
-export default CreateSigner;
+export { CreateSigner, default } from "../common/client/signer.js";

package/lib/esm/client/signer.js

@@ -1,32 +1 @@
-import { secp256k1 } from '@noble/curves/secp256k1.js';
-export const CreateSigner = (privateKey) => {
-    privateKey = parsePrivateKey(privateKey);
-    const publicKey = Buffer.from(secp256k1.getPublicKey(privateKey, false));
-    return async (data) => {
-        // Ensure hash is 32 bytes
-        if (data.length !== 32) {
-            throw new Error('Message hash must be 32 bytes');
-        }
-        // Sign the hash
-        const signature = secp256k1.sign(data, privateKey, { prehash: false });
-        return {
-            signature: Buffer.from(signature),
-            publicKey: publicKey,
-        };
-    };
-};
-const parsePrivateKey = (privateKey) => {
-    if (typeof privateKey == 'string') {
-        privateKey = privateKey.replace(/^0x/, '');
-        if (!/^[0-9a-fA-F]{64}$/.test(privateKey)) {
-            throw new Error('Private key must be 64 hex characters');
-        }
-        privateKey = Buffer.from(privateKey, 'hex');
-    }
-    // Validate private key
-    if (!secp256k1.utils.isValidSecretKey(privateKey)) {
-        throw new Error('Invalid private key');
-    }
-    return privateKey;
-};
-export default CreateSigner;
+export { CreateSigner, default } from "../common/client/signer.js";

package/lib/esm/common/client/client.d.ts

@@ -0,0 +1,14 @@
+import { DescService } from "@bufbuild/protobuf";
+export declare function createClient<T extends DescService>(signer: string | Buffer | ((data: Buffer) => Promise<Signature>) | Buffer<ArrayBufferLike>, endpoint: string, svc: T): import("@connectrpc/connect").Client<T>;
+/**
+ * Signature with metadata for particular request
+ */
+export interface Signature {
+    signature: Buffer;
+    publicKey: Buffer;
+}
+/**
+ * Signature function for signing requests to T-0 API. Accepts any data in string format and return signature
+ * with metadata
+ */
+export type SignerFunction = (data: Buffer) => Promise<Signature>;

package/lib/esm/common/client/client.js

@@ -0,0 +1,36 @@
+import { createClient as createConnectClient } from "@connectrpc/connect";
+import { createConnectTransport } from "@connectrpc/connect-web";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import CreateSigner from "./signer.js";
+import NetworkHeaders from "../headers.js";
+export function createClient(signer, endpoint, svc) {
+    let customFetch;
+    if (typeof signer === "string" || Buffer.isBuffer(signer)) {
+        signer = CreateSigner(signer);
+    }
+    customFetch = async (r, init) => {
+        if (!init?.body || !((init.body) instanceof Uint8Array)) {
+            throw "unsupported body type";
+        }
+        const ts = Date.now();
+        // 64‑bit little‑endian timestamp
+        const tsBuf = Buffer.alloc(8);
+        tsBuf.writeBigUInt64LE(BigInt(ts));
+        const hash = keccak_256.create()
+            .update(init.body)
+            .update(tsBuf);
+        const hashHex = Buffer.from(hash.digest());
+        const sig = await signer(hashHex);
+        const headers = new Headers(init?.headers);
+        headers.append(NetworkHeaders.Signature, "0x" + sig.signature.toString('hex'));
+        headers.append(NetworkHeaders.PublicKey, "0x" + sig.publicKey.toString('hex'));
+        headers.append(NetworkHeaders.SignatureTimestamp, ts.toString());
+        const modifiedInit = { ...init, headers };
+        return fetch(r, modifiedInit);
+    };
+    const transport = createConnectTransport({
+        baseUrl: endpoint,
+        fetch: customFetch,
+    });
+    return createConnectClient(svc, transport);
+}

package/lib/esm/common/client/signer.d.ts

@@ -0,0 +1,3 @@
+import type { Signature } from "./client.js";
+export declare const CreateSigner: (privateKey: string | Buffer) => (data: Buffer) => Promise<Signature>;
+export default CreateSigner;

package/lib/esm/common/client/signer.js

@@ -0,0 +1,32 @@
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+export const CreateSigner = (privateKey) => {
+    privateKey = parsePrivateKey(privateKey);
+    const publicKey = Buffer.from(secp256k1.getPublicKey(privateKey, false));
+    return async (data) => {
+        // Ensure hash is 32 bytes
+        if (data.length !== 32) {
+            throw new Error('Message hash must be 32 bytes');
+        }
+        // Sign the hash
+        const signature = secp256k1.sign(data, privateKey, { prehash: false });
+        return {
+            signature: Buffer.from(signature),
+            publicKey: publicKey,
+        };
+    };
+};
+const parsePrivateKey = (privateKey) => {
+    if (typeof privateKey == 'string') {
+        privateKey = privateKey.replace(/^0x/, '');
+        if (!/^[0-9a-fA-F]{64}$/.test(privateKey)) {
+            throw new Error('Private key must be 64 hex characters');
+        }
+        privateKey = Buffer.from(privateKey, 'hex');
+    }
+    // Validate private key
+    if (!secp256k1.utils.isValidSecretKey(privateKey)) {
+        throw new Error('Invalid private key');
+    }
+    return privateKey;
+};
+export default CreateSigner;

package/lib/esm/common/crypto/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function keccak256(...inputs: Uint8Array[]): Buffer;
+export declare function computeDigest(body: Uint8Array, timestampMs: number): Buffer;

package/lib/esm/common/crypto/hash.js

@@ -0,0 +1,13 @@
+import { keccak_256 } from '@noble/hashes/sha3.js';
+export function keccak256(...inputs) {
+    const h = keccak_256.create();
+    for (const input of inputs) {
+        h.update(input);
+    }
+    return Buffer.from(h.digest());
+}
+export function computeDigest(body, timestampMs) {
+    const tsBuf = Buffer.alloc(8);
+    tsBuf.writeBigUInt64LE(BigInt(timestampMs));
+    return keccak256(body, tsBuf);
+}

package/lib/esm/common/crypto/index.d.ts

@@ -0,0 +1,5 @@
+export { verifySignature } from './verify.js';
+export { keccak256, computeDigest } from './hash.js';
+export { parsePublicKey, publicKeysEqual } from './keys.js';
+export { createRequestVerifier, DEFAULT_TOLERANCE_MS } from './request.js';
+export type { CreateVerifierOptions, VerifyRequest, VerifyRequestResult, VerifyRequestFailure, RequestVerifier } from './request.js';

package/lib/esm/common/crypto/index.js

@@ -0,0 +1,4 @@
+export { verifySignature } from './verify.js';
+export { keccak256, computeDigest } from './hash.js';
+export { parsePublicKey, publicKeysEqual } from './keys.js';
+export { createRequestVerifier, DEFAULT_TOLERANCE_MS } from './request.js';

package/lib/esm/common/crypto/keys.d.ts

@@ -0,0 +1,2 @@
+export declare function parsePublicKey(key: string | Buffer): Buffer;
+export declare function publicKeysEqual(a: Uint8Array, b: Uint8Array): boolean;

package/lib/esm/common/crypto/keys.js

@@ -0,0 +1,19 @@
+export function parsePublicKey(key) {
+    if (typeof key === 'string') {
+        const hex = key.startsWith('0x') ? key.slice(2) : key;
+        if (!/^[0-9a-fA-F]*$/.test(hex) || hex.length % 2 !== 0) {
+            throw new Error('Public key contains invalid hex characters');
+        }
+        key = Buffer.from(hex, 'hex');
+    }
+    if (key.length !== 65 || key[0] !== 0x04) {
+        throw new Error('Public key must be 65 bytes in uncompressed format (0x04 prefix)');
+    }
+    return Buffer.from(key);
+}
+export function publicKeysEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return Buffer.from(a).compare(Buffer.from(b)) === 0;
+}

package/lib/esm/common/crypto/request.d.ts

@@ -0,0 +1,20 @@
+export declare const DEFAULT_TOLERANCE_MS = 60000;
+export interface CreateVerifierOptions {
+    networkPublicKey: string | Buffer;
+    toleranceMs?: number;
+}
+export interface VerifyRequest {
+    body: Uint8Array | ArrayBufferView | ArrayBufferLike;
+    signatureHeader: string;
+    publicKeyHeader: string;
+    timestampHeader: string;
+}
+export type VerifyRequestFailure = 'invalid_timestamp' | 'timestamp_out_of_range' | 'invalid_public_key' | 'unknown_public_key' | 'invalid_signature_format' | 'signature_failed';
+export type VerifyRequestResult = {
+    valid: true;
+} | {
+    valid: false;
+    reason: VerifyRequestFailure;
+};
+export type RequestVerifier = (req: VerifyRequest) => VerifyRequestResult;
+export declare function createRequestVerifier(opts: CreateVerifierOptions): RequestVerifier;

package/lib/esm/common/crypto/request.js

@@ -0,0 +1,47 @@
+import { verifySignature } from './verify.js';
+import { computeDigest } from './hash.js';
+import { parsePublicKey, publicKeysEqual } from './keys.js';
+export const DEFAULT_TOLERANCE_MS = 60000;
+export function createRequestVerifier(opts) {
+    const networkKey = parsePublicKey(opts.networkPublicKey);
+    const tolerance = opts.toleranceMs ?? DEFAULT_TOLERANCE_MS;
+    return (req) => {
+        const ts = parseInt(req.timestampHeader, 10);
+        if (!Number.isFinite(ts) || ts < 0) {
+            return { valid: false, reason: 'invalid_timestamp' };
+        }
+        if (Math.abs(Date.now() - ts) > tolerance) {
+            return { valid: false, reason: 'timestamp_out_of_range' };
+        }
+        let publicKey;
+        try {
+            publicKey = parsePublicKey(req.publicKeyHeader);
+        }
+        catch {
+            return { valid: false, reason: 'invalid_public_key' };
+        }
+        if (!publicKeysEqual(publicKey, networkKey)) {
+            return { valid: false, reason: 'unknown_public_key' };
+        }
+        const sigHex = req.signatureHeader.startsWith('0x')
+            ? req.signatureHeader.slice(2)
+            : req.signatureHeader;
+        if (!/^[0-9a-fA-F]*$/.test(sigHex) || sigHex.length % 2 !== 0) {
+            return { valid: false, reason: 'invalid_signature_format' };
+        }
+        const signature = Buffer.from(sigHex, 'hex');
+        if (signature.length !== 64 && signature.length !== 65) {
+            return { valid: false, reason: 'invalid_signature_format' };
+        }
+        const body = req.body instanceof Uint8Array
+            ? req.body
+            : ArrayBuffer.isView(req.body)
+                ? new Uint8Array(req.body.buffer, req.body.byteOffset, req.body.byteLength)
+                : new Uint8Array(req.body);
+        const digest = computeDigest(body, ts);
+        if (!verifySignature(publicKey, digest, signature)) {
+            return { valid: false, reason: 'signature_failed' };
+        }
+        return { valid: true };
+    };
+}

package/lib/esm/common/crypto/verify.d.ts

@@ -0,0 +1 @@
+export declare function verifySignature(publicKey: Uint8Array, digest: Uint8Array, signature: Uint8Array): boolean;

package/lib/esm/common/crypto/verify.js

@@ -0,0 +1,16 @@
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+export function verifySignature(publicKey, digest, signature) {
+    if (digest.length !== 32) {
+        return false;
+    }
+    if (signature.length !== 64 && signature.length !== 65) {
+        return false;
+    }
+    const sig64 = signature.length === 65 ? signature.subarray(0, 64) : signature;
+    try {
+        return secp256k1.verify(sig64, digest, publicKey, { prehash: false });
+    }
+    catch {
+        return false;
+    }
+}

package/lib/esm/common/health.d.ts

@@ -0,0 +1,21 @@
+import { type ServiceImpl } from "@connectrpc/connect";
+import { Health } from "./health_pb.js";
+/**
+ * Headers carrying the identity of the SDK answering the probe. They ride on
+ * the health response and nowhere else: `HealthCheckResponse` has a single
+ * status field and `check` names its service in the request, so the contract
+ * itself has no room for this — and taxing every callback with headers only the
+ * probe reads would be worse.
+ */
+export declare const SDK_ECOSYSTEM_HEADER = "T0-Sdk-Ecosystem";
+export declare const SDK_VERSION_HEADER = "T0-Sdk-Version";
+/**
+ * Reports SERVING for the services registered on this server and NOT_FOUND for
+ * anything else. The set is frozen at registration; nothing is computed per
+ * request.
+ *
+ * `watch` is absent on purpose: it is server-streaming, and the body-hash
+ * signature scheme these servers run behind has no story for streams. Omitting
+ * it from a partial `ServiceImpl` makes connect-es answer UNIMPLEMENTED.
+ */
+export declare const createHealthServiceImpl: (services: string[], version?: string) => Partial<ServiceImpl<typeof Health>>;

package/lib/esm/common/health.js

@@ -0,0 +1,41 @@
+import { create } from "@bufbuild/protobuf";
+import { Code, ConnectError } from "@connectrpc/connect";
+import { HealthCheckResponse_ServingStatus, HealthCheckResponseSchema, } from "./health_pb.js";
+/**
+ * Headers carrying the identity of the SDK answering the probe. They ride on
+ * the health response and nowhere else: `HealthCheckResponse` has a single
+ * status field and `check` names its service in the request, so the contract
+ * itself has no room for this — and taxing every callback with headers only the
+ * probe reads would be worse.
+ */
+export const SDK_ECOSYSTEM_HEADER = "T0-Sdk-Ecosystem";
+export const SDK_VERSION_HEADER = "T0-Sdk-Version";
+const SDK_ECOSYSTEM = "node";
+/**
+ * Reports SERVING for the services registered on this server and NOT_FOUND for
+ * anything else. The set is frozen at registration; nothing is computed per
+ * request.
+ *
+ * `watch` is absent on purpose: it is server-streaming, and the body-hash
+ * signature scheme these servers run behind has no story for streams. Omitting
+ * it from a partial `ServiceImpl` makes connect-es answer UNIMPLEMENTED.
+ */
+export const createHealthServiceImpl = (services, version) => {
+    const registered = new Set(services);
+    const serving = create(HealthCheckResponseSchema, {
+        status: HealthCheckResponse_ServingStatus.SERVING,
+    });
+    return {
+        check(req, ctx) {
+            ctx.responseHeader.set(SDK_ECOSYSTEM_HEADER, SDK_ECOSYSTEM);
+            if (version) {
+                ctx.responseHeader.set(SDK_VERSION_HEADER, version);
+            }
+            const { service } = req;
+            if (service !== "" && !registered.has(service)) {
+                throw new ConnectError(`unknown service '${service}'`, Code.NotFound);
+            }
+            return serving;
+        },
+    };
+};

package/lib/esm/common/health_pb.d.ts

@@ -0,0 +1,157 @@
+import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file grpc/health/v1/health.proto.
+ */
+export declare const file_grpc_health_v1_health: GenFile;
+/**
+ * @generated from message grpc.health.v1.HealthCheckRequest
+ */
+export type HealthCheckRequest = Message<"grpc.health.v1.HealthCheckRequest"> & {
+    /**
+     * @generated from field: string service = 1;
+     */
+    service: string;
+};
+/**
+ * Describes the message grpc.health.v1.HealthCheckRequest.
+ * Use `create(HealthCheckRequestSchema)` to create a new message.
+ */
+export declare const HealthCheckRequestSchema: GenMessage<HealthCheckRequest>;
+/**
+ * @generated from message grpc.health.v1.HealthCheckResponse
+ */
+export type HealthCheckResponse = Message<"grpc.health.v1.HealthCheckResponse"> & {
+    /**
+     * @generated from field: grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;
+     */
+    status: HealthCheckResponse_ServingStatus;
+};
+/**
+ * Describes the message grpc.health.v1.HealthCheckResponse.
+ * Use `create(HealthCheckResponseSchema)` to create a new message.
+ */
+export declare const HealthCheckResponseSchema: GenMessage<HealthCheckResponse>;
+/**
+ * @generated from enum grpc.health.v1.HealthCheckResponse.ServingStatus
+ */
+export declare enum HealthCheckResponse_ServingStatus {
+    /**
+     * @generated from enum value: UNKNOWN = 0;
+     */
+    UNKNOWN = 0,
+    /**
+     * @generated from enum value: SERVING = 1;
+     */
+    SERVING = 1,
+    /**
+     * @generated from enum value: NOT_SERVING = 2;
+     */
+    NOT_SERVING = 2,
+    /**
+     * Used only by the Watch method.
+     *
+     * @generated from enum value: SERVICE_UNKNOWN = 3;
+     */
+    SERVICE_UNKNOWN = 3
+}
+/**
+ * Describes the enum grpc.health.v1.HealthCheckResponse.ServingStatus.
+ */
+export declare const HealthCheckResponse_ServingStatusSchema: GenEnum<HealthCheckResponse_ServingStatus>;
+/**
+ * @generated from message grpc.health.v1.HealthListRequest
+ */
+export type HealthListRequest = Message<"grpc.health.v1.HealthListRequest"> & {};
+/**
+ * Describes the message grpc.health.v1.HealthListRequest.
+ * Use `create(HealthListRequestSchema)` to create a new message.
+ */
+export declare const HealthListRequestSchema: GenMessage<HealthListRequest>;
+/**
+ * @generated from message grpc.health.v1.HealthListResponse
+ */
+export type HealthListResponse = Message<"grpc.health.v1.HealthListResponse"> & {
+    /**
+     * statuses contains all the services and their respective status.
+     *
+     * @generated from field: map<string, grpc.health.v1.HealthCheckResponse> statuses = 1;
+     */
+    statuses: {
+        [key: string]: HealthCheckResponse;
+    };
+};
+/**
+ * Describes the message grpc.health.v1.HealthListResponse.
+ * Use `create(HealthListResponseSchema)` to create a new message.
+ */
+export declare const HealthListResponseSchema: GenMessage<HealthListResponse>;
+/**
+ * Health is gRPC's mechanism for checking whether a server is able to handle
+ * RPCs. Its semantics are documented in
+ * https://github.com/grpc/grpc/blob/master/doc/health-checking.md.
+ *
+ * @generated from service grpc.health.v1.Health
+ */
+export declare const Health: GenService<{
+    /**
+     * Check gets the health of the specified service. If the requested service
+     * is unknown, the call will fail with status NOT_FOUND. If the caller does
+     * not specify a service name, the server should respond with its overall
+     * health status.
+     *
+     * Clients should set a deadline when calling Check, and can declare the
+     * server unhealthy if they do not receive a timely response.
+     *
+     * @generated from rpc grpc.health.v1.Health.Check
+     */
+    check: {
+        methodKind: "unary";
+        input: typeof HealthCheckRequestSchema;
+        output: typeof HealthCheckResponseSchema;
+    };
+    /**
+     * List provides a non-atomic snapshot of the health of all the available
+     * services.
+     *
+     * The server may respond with a RESOURCE_EXHAUSTED error if too many services
+     * exist.
+     *
+     * Clients should set a deadline when calling List, and can declare the server
+     * unhealthy if they do not receive a timely response.
+     *
+     * Clients should keep in mind that the list of health services exposed by an
+     * application can change over the lifetime of the process.
+     *
+     * @generated from rpc grpc.health.v1.Health.List
+     */
+    list: {
+        methodKind: "unary";
+        input: typeof HealthListRequestSchema;
+        output: typeof HealthListResponseSchema;
+    };
+    /**
+     * Performs a watch for the serving status of the requested service.
+     * The server will immediately send back a message indicating the current
+     * serving status.  It will then subsequently send a new message whenever
+     * the service's serving status changes.
+     *
+     * If the requested service is unknown when the call is received, the
+     * server will send a message setting the serving status to
+     * SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+     * future point, the serving status of the service becomes known, the
+     * server will send a new message with the service's serving status.
+     *
+     * If the call terminates with status UNIMPLEMENTED, then clients
+     * should assume this method is not supported and should not retry the
+     * call.  If the call terminates with any other status (including OK),
+     * clients should retry the call with appropriate exponential backoff.
+     *
+     * @generated from rpc grpc.health.v1.Health.Watch
+     */
+    watch: {
+        methodKind: "server_streaming";
+        input: typeof HealthCheckRequestSchema;
+        output: typeof HealthCheckResponseSchema;
+    };
+}>;