@mindburn/helm-ai-kernel 0.5.1

package/dist/client.js

@@ -0,0 +1,371 @@
+// HELM SDK — TypeScript Client
+// Ergonomic wrapper over generated types. Uses native fetch. Zero deps.
+/** Thrown when the HELM API returns a non-2xx response. */
+export class HelmApiError extends Error {
+    status;
+    reasonCode;
+    details;
+    body;
+    constructor(status, body) {
+        const helmBody = isHelmError(body) ? body : undefined;
+        const message = helmBody?.error.message ?? `HELM API request failed with HTTP ${status}`;
+        super(message);
+        this.name = 'HelmApiError';
+        this.status = status;
+        this.reasonCode = helmBody?.error.reason_code ?? 'ERROR_INTERNAL';
+        this.details = helmBody?.error.details;
+        this.body = body;
+    }
+}
+function isHelmError(body) {
+    return typeof body === 'object'
+        && body !== null
+        && 'error' in body
+        && typeof body.error === 'object'
+        && body.error !== null
+        && 'message' in (body.error)
+        && 'reason_code' in (body.error);
+}
+export class HelmClient {
+    baseUrl;
+    headers;
+    timeout;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.timeout = config.timeout ?? 30_000;
+        this.headers = { 'Content-Type': 'application/json' };
+        if (config.apiKey) {
+            this.headers['Authorization'] = `Bearer ${config.apiKey}`;
+        }
+        if (config.tenantId) {
+            this.headers['X-Helm-Tenant-ID'] = config.tenantId;
+        }
+    }
+    // ── Internal ─────────────────────────────────────
+    async request(method, path, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const res = await fetch(`${this.baseUrl}${path}`, {
+                method,
+                headers: this.headers,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const err = (await res.json());
+                throw new HelmApiError(res.status, err);
+            }
+            return (await res.json());
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    // ── OpenAI Proxy ─────────────────────────────────
+    async chatCompletions(req) {
+        return this.request('POST', '/v1/chat/completions', req);
+    }
+    /**
+     * Send a chat completion request and extract kernel-issued governance metadata
+     * from X-Helm-* response headers. Use this instead of chatCompletions() when
+     * you need the kernel receipt.
+     */
+    async chatCompletionsWithReceipt(req) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+                method: 'POST',
+                headers: this.headers,
+                body: JSON.stringify(req),
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const err = (await res.json());
+                throw new HelmApiError(res.status, err);
+            }
+            const response = (await res.json());
+            const governance = {
+                receiptId: res.headers.get('X-Helm-Receipt-ID') ?? '',
+                status: res.headers.get('X-Helm-Status') ?? '',
+                outputHash: res.headers.get('X-Helm-Output-Hash') ?? '',
+                lamportClock: parseInt(res.headers.get('X-Helm-Lamport-Clock') ?? '0', 10),
+                reasonCode: res.headers.get('X-Helm-Reason-Code') ?? '',
+                decisionId: res.headers.get('X-Helm-Decision-ID') ?? '',
+                proofGraphNode: res.headers.get('X-Helm-ProofGraph-Node') ?? '',
+                signature: res.headers.get('X-Helm-Signature') ?? '',
+                toolCalls: parseInt(res.headers.get('X-Helm-Tool-Calls') ?? '0', 10),
+            };
+            return { response, governance };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    // ── Decision Evaluation ──────────────────────────
+    async evaluateDecision(req) {
+        return this.request('POST', '/api/v1/evaluate', req);
+    }
+    async runPublicDemo(actionId, args = {}) {
+        return this.request('POST', '/api/demo/run', {
+            action_id: actionId,
+            policy_id: 'agent_tool_call_boundary',
+            args,
+        });
+    }
+    async verifyPublicDemoReceipt(receipt, expectedReceiptHash) {
+        return this.request('POST', '/api/demo/verify', {
+            receipt,
+            expected_receipt_hash: expectedReceiptHash,
+        });
+    }
+    // ── Approval Ceremony ────────────────────────────
+    async approveIntent(req) {
+        return this.request('POST', '/api/v1/kernel/approve', req);
+    }
+    // ── ProofGraph ───────────────────────────────────
+    async listSessions(limit = 50, offset = 0) {
+        return this.request('GET', `/api/v1/proofgraph/sessions?limit=${limit}&offset=${offset}`);
+    }
+    async getReceipts(sessionId) {
+        return this.request('GET', `/api/v1/proofgraph/sessions/${sessionId}/receipts`);
+    }
+    async getReceipt(receiptHash) {
+        return this.request('GET', `/api/v1/proofgraph/receipts/${receiptHash}`);
+    }
+    // ── Evidence ─────────────────────────────────────
+    async exportEvidence(sessionId) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const res = await fetch(`${this.baseUrl}/api/v1/evidence/export`, {
+                method: 'POST',
+                headers: this.headers,
+                body: JSON.stringify({ session_id: sessionId, format: 'tar.gz' }),
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new HelmApiError(res.status, (await res.json()));
+            return res.blob();
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async verifyEvidence(bundle) {
+        const form = new FormData();
+        form.append('bundle', bundle);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const res = await fetch(`${this.baseUrl}/api/v1/evidence/verify`, {
+                method: 'POST',
+                body: form,
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new HelmApiError(res.status, (await res.json()));
+            return (await res.json());
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async replayVerify(bundle) {
+        const form = new FormData();
+        form.append('bundle', bundle);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const res = await fetch(`${this.baseUrl}/api/v1/replay/verify`, {
+                method: 'POST',
+                body: form,
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new HelmApiError(res.status, (await res.json()));
+            return (await res.json());
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async createEvidenceEnvelopeManifest(req) {
+        return this.request('POST', '/api/v1/evidence/envelopes', req);
+    }
+    async listEvidenceEnvelopeManifests() {
+        return this.request('GET', '/api/v1/evidence/envelopes');
+    }
+    async getEvidenceEnvelopeManifest(manifestId) {
+        return this.request('GET', `/api/v1/evidence/envelopes/${encodeURIComponent(manifestId)}`);
+    }
+    async verifyEvidenceEnvelopeManifest(manifestId) {
+        return this.request('POST', `/api/v1/evidence/envelopes/${encodeURIComponent(manifestId)}/verify`);
+    }
+    async getEvidenceEnvelopePayload(manifestId) {
+        return this.request('GET', `/api/v1/evidence/envelopes/${encodeURIComponent(manifestId)}/payload`);
+    }
+    // ── Execution Boundary ───────────────────────────
+    async getBoundaryStatus() {
+        return this.request('GET', '/api/v1/boundary/status');
+    }
+    async listBoundaryCapabilities() {
+        return this.request('GET', '/api/v1/boundary/capabilities');
+    }
+    async listBoundaryRecords(query) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query ?? {})) {
+            if (value !== undefined && value !== '')
+                params.set(key, String(value));
+        }
+        const qs = params.toString();
+        return this.request('GET', `/api/v1/boundary/records${qs ? `?${qs}` : ''}`);
+    }
+    async getBoundaryRecord(recordId) {
+        return this.request('GET', `/api/v1/boundary/records/${encodeURIComponent(recordId)}`);
+    }
+    async verifyBoundaryRecord(recordId) {
+        return this.request('POST', `/api/v1/boundary/records/${encodeURIComponent(recordId)}/verify`);
+    }
+    async listBoundaryCheckpoints() {
+        return this.request('GET', '/api/v1/boundary/checkpoints');
+    }
+    async createBoundaryCheckpoint() {
+        return this.request('POST', '/api/v1/boundary/checkpoints');
+    }
+    async verifyBoundaryCheckpoint(checkpointId) {
+        return this.request('POST', `/api/v1/boundary/checkpoints/${encodeURIComponent(checkpointId)}/verify`);
+    }
+    // ── Conformance ──────────────────────────────────
+    async conformanceRun(req) {
+        return this.request('POST', '/api/v1/conformance/run', req);
+    }
+    async getConformanceReport(reportId) {
+        return this.request('GET', `/api/v1/conformance/reports/${reportId}`);
+    }
+    async listConformanceReports() {
+        return this.request('GET', '/api/v1/conformance/reports');
+    }
+    async listConformanceVectors() {
+        return this.request('GET', '/api/v1/conformance/vectors');
+    }
+    async listNegativeConformanceVectors() {
+        return this.request('GET', '/api/v1/conformance/negative');
+    }
+    // ── MCP Registry ─────────────────────────────────
+    async listMcpRegistry() {
+        return this.request('GET', '/api/v1/mcp/registry');
+    }
+    async discoverMcpServer(req) {
+        return this.request('POST', '/api/v1/mcp/registry', req);
+    }
+    async approveMcpServer(req) {
+        return this.request('POST', '/api/v1/mcp/registry/approve', req);
+    }
+    async getMcpRegistryRecord(serverId) {
+        return this.request('GET', `/api/v1/mcp/registry/${encodeURIComponent(serverId)}`);
+    }
+    async approveMcpRegistryRecord(serverId, req) {
+        return this.request('POST', `/api/v1/mcp/registry/${encodeURIComponent(serverId)}/approve`, req);
+    }
+    async revokeMcpRegistryRecord(serverId, reason) {
+        return this.request('POST', `/api/v1/mcp/registry/${encodeURIComponent(serverId)}/revoke`, { reason });
+    }
+    async scanMcpServer(req) {
+        return this.request('POST', '/api/v1/mcp/scan', req);
+    }
+    async listMcpAuthProfiles() {
+        return this.request('GET', '/api/v1/mcp/auth-profiles');
+    }
+    async putMcpAuthProfile(profileId, profile) {
+        return this.request('PUT', `/api/v1/mcp/auth-profiles/${encodeURIComponent(profileId)}`, profile);
+    }
+    async authorizeMcpCall(req) {
+        return this.request('POST', '/api/v1/mcp/authorize-call', req);
+    }
+    async inspectSandboxGrants(runtime, profile, policyEpoch) {
+        const params = new URLSearchParams();
+        if (runtime)
+            params.set('runtime', runtime);
+        if (profile)
+            params.set('profile', profile);
+        if (policyEpoch)
+            params.set('policy_epoch', policyEpoch);
+        const query = params.toString();
+        return this.request('GET', `/api/v1/sandbox/grants/inspect${query ? `?${query}` : ''}`);
+    }
+    async listSandboxProfiles() {
+        return this.request('GET', '/api/v1/sandbox/profiles');
+    }
+    async listSandboxGrants() {
+        return this.request('GET', '/api/v1/sandbox/grants');
+    }
+    async createSandboxGrant(req) {
+        return this.request('POST', '/api/v1/sandbox/grants', req);
+    }
+    async getSandboxGrant(grantId) {
+        return this.request('GET', `/api/v1/sandbox/grants/${encodeURIComponent(grantId)}`);
+    }
+    async verifySandboxGrant(grantId) {
+        return this.request('POST', `/api/v1/sandbox/grants/${encodeURIComponent(grantId)}/verify`);
+    }
+    async preflightSandboxGrant(req) {
+        return this.request('POST', '/api/v1/sandbox/preflight', req);
+    }
+    // ── Identity, Authz, Approvals, Budgets ──────────
+    async listAgentIdentities() {
+        return this.request('GET', '/api/v1/identity/agents');
+    }
+    async getAuthzHealth() {
+        return this.request('GET', '/api/v1/authz/health');
+    }
+    async checkAuthz(req) {
+        return this.request('POST', '/api/v1/authz/check', req);
+    }
+    async listAuthzSnapshots() {
+        return this.request('GET', '/api/v1/authz/snapshots');
+    }
+    async getAuthzSnapshot(snapshotId) {
+        return this.request('GET', `/api/v1/authz/snapshots/${encodeURIComponent(snapshotId)}`);
+    }
+    async listApprovalCeremonies() {
+        return this.request('GET', '/api/v1/approvals');
+    }
+    async createApprovalCeremony(req) {
+        return this.request('POST', '/api/v1/approvals', req);
+    }
+    async transitionApprovalCeremony(approvalId, action, req = {}) {
+        return this.request('POST', `/api/v1/approvals/${encodeURIComponent(approvalId)}/${action}`, req);
+    }
+    async createApprovalWebAuthnChallenge(approvalId, req = {}) {
+        return this.request('POST', `/api/v1/approvals/${encodeURIComponent(approvalId)}/webauthn/challenge`, req);
+    }
+    async assertApprovalWebAuthnChallenge(approvalId, req) {
+        return this.request('POST', `/api/v1/approvals/${encodeURIComponent(approvalId)}/webauthn/assert`, req);
+    }
+    async listBudgetCeilings() {
+        return this.request('GET', '/api/v1/budgets');
+    }
+    async putBudgetCeiling(budgetId, req) {
+        return this.request('PUT', `/api/v1/budgets/${encodeURIComponent(budgetId)}`, req);
+    }
+    // ── Telemetry and Coexistence ────────────────────
+    async getCoexistenceCapabilities() {
+        return this.request('GET', '/api/v1/coexistence/capabilities');
+    }
+    async getTelemetryOTelConfig() {
+        return this.request('GET', '/api/v1/telemetry/otel/config');
+    }
+    async exportTelemetry(req) {
+        return this.request('POST', '/api/v1/telemetry/export', req);
+    }
+    // ── System ───────────────────────────────────────
+    async health() {
+        return this.request('GET', '/healthz');
+    }
+    async version() {
+        return this.request('GET', '/version');
+    }
+}
+export default HelmClient;

package/dist/generated/google/protobuf/duration.d.ts

@@ -0,0 +1,99 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "google.protobuf";
+/**
+ * A Duration represents a signed, fixed-length span of time represented
+ * as a count of seconds and fractions of seconds at nanosecond
+ * resolution. It is independent of any calendar and concepts like "day"
+ * or "month". It is related to Timestamp in that the difference between
+ * two Timestamp values is a Duration and it can be added or subtracted
+ * from a Timestamp. Range is approximately +-10,000 years.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Duration from two Timestamps in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Timestamp end = ...;
+ *     Duration duration = ...;
+ *
+ *     duration.seconds = end.seconds - start.seconds;
+ *     duration.nanos = end.nanos - start.nanos;
+ *
+ *     if (duration.seconds < 0 && duration.nanos > 0) {
+ *       duration.seconds += 1;
+ *       duration.nanos -= 1000000000;
+ *     } else if (duration.seconds > 0 && duration.nanos < 0) {
+ *       duration.seconds -= 1;
+ *       duration.nanos += 1000000000;
+ *     }
+ *
+ * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Duration duration = ...;
+ *     Timestamp end = ...;
+ *
+ *     end.seconds = start.seconds + duration.seconds;
+ *     end.nanos = start.nanos + duration.nanos;
+ *
+ *     if (end.nanos < 0) {
+ *       end.seconds -= 1;
+ *       end.nanos += 1000000000;
+ *     } else if (end.nanos >= 1000000000) {
+ *       end.seconds += 1;
+ *       end.nanos -= 1000000000;
+ *     }
+ *
+ * Example 3: Compute Duration from datetime.timedelta in Python.
+ *
+ *     td = datetime.timedelta(days=3, minutes=10)
+ *     duration = Duration()
+ *     duration.FromTimedelta(td)
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Duration type is encoded as a string rather than an
+ * object, where the string ends in the suffix "s" (indicating seconds) and
+ * is preceded by the number of seconds, with nanoseconds expressed as
+ * fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+ * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+ * be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+ * microsecond should be expressed in JSON format as "3.000001s".
+ */
+export interface Duration {
+    /**
+     * Signed seconds of the span of time. Must be from -315,576,000,000
+     * to +315,576,000,000 inclusive. Note: these bounds are computed from:
+     * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+     */
+    seconds: number;
+    /**
+     * Signed fractions of a second at nanosecond resolution of the span
+     * of time. Durations less than one second are represented with a 0
+     * `seconds` field and a positive or negative `nanos` field. For durations
+     * of one second or more, a non-zero value for the `nanos` field must be
+     * of the same sign as the `seconds` field. Must be from -999,999,999
+     * to +999,999,999 inclusive.
+     */
+    nanos: number;
+}
+export declare const Duration: MessageFns<Duration>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/generated/google/protobuf/duration.js

@@ -0,0 +1,89 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v7.34.1
+// source: google/protobuf/duration.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export const protobufPackage = "google.protobuf";
+function createBaseDuration() {
+    return { seconds: 0, nanos: 0 };
+}
+export const Duration = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.seconds !== 0) {
+            writer.uint32(8).int64(message.seconds);
+        }
+        if (message.nanos !== 0) {
+            writer.uint32(16).int32(message.nanos);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseDuration();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.seconds = longToNumber(reader.int64());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.nanos = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            seconds: isSet(object.seconds) ? globalThis.Number(object.seconds) : 0,
+            nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.seconds !== 0) {
+            obj.seconds = Math.round(message.seconds);
+        }
+        if (message.nanos !== 0) {
+            obj.nanos = Math.round(message.nanos);
+        }
+        return obj;
+    },
+    create(base) {
+        return Duration.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDuration();
+        message.seconds = object.seconds ?? 0;
+        message.nanos = object.nanos ?? 0;
+        return message;
+    },
+};
+function longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/generated/google/protobuf/timestamp.d.ts

@@ -0,0 +1,129 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "google.protobuf";
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A ProtoJSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a ProtoJSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ */
+export interface Timestamp {
+    /**
+     * Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must
+     * be between -62135596800 and 253402300799 inclusive (which corresponds to
+     * 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z).
+     */
+    seconds: number;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. This field is
+     * the nanosecond portion of the duration, not an alternative to seconds.
+     * Negative second values with fractions must still have non-negative nanos
+     * values that count forward in time. Must be between 0 and 999,999,999
+     * inclusive.
+     */
+    nanos: number;
+}
+export declare const Timestamp: MessageFns<Timestamp>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};