@kya-os/cli 2.0.0 → 2.0.3

package/node_modules/@kya-os/contracts/dist/proof/detached-proof.d.ts

@@ -0,0 +1,476 @@
+import { z } from "zod";
+/**
+ * Proof and signature schemas for MCP-I
+ *
+ * Note: The type name "DetachedProof" is maintained for backward compatibility,
+ * but the JWS format is actually FULL compact JWS (header.payload.signature),
+ * not detached format (header..signature).
+ *
+ * The JWS payload contains JWT standard claims (aud, sub, iss) plus custom
+ * proof claims (requestHash, responseHash, nonce, etc.).
+ */
+/**
+ * Outcome of the policy decision a proof attests to (ratified DIF decision).
+ *
+ * - `allowed`             — the call was authorized and produced a response; the
+ *                           proof carries a `responseHash` over that response.
+ * - `denied`              — the call was refused; no response was produced.
+ * - `step_up_required`    — a step-up (re-auth / higher assurance) is required
+ *                           before the call may proceed; no response yet.
+ * - `needs_authorization` — explicit user authorization is required first; no
+ *                           response yet.
+ *
+ * Denial and step-up outcomes authorize no response, so their proofs omit
+ * `responseHash`. The field is optional on {@link ProofMetaSchema}: proofs minted
+ * before it existed carry no `outcome` and are treated as `allowed`.
+ */
+export declare const ProofOutcomeSchema: z.ZodEnum<["allowed", "denied", "step_up_required", "needs_authorization"]>;
+export type ProofOutcome = z.infer<typeof ProofOutcomeSchema>;
+export declare const ProofMetaSchema: z.ZodObject<{
+    did: z.ZodString;
+    kid: z.ZodString;
+    ts: z.ZodNumber;
+    nonce: z.ZodString;
+    audience: z.ZodString;
+    sessionId: z.ZodString;
+    requestHash: z.ZodString;
+    responseHash: z.ZodString;
+    outcome: z.ZodOptional<z.ZodEnum<["allowed", "denied", "step_up_required", "needs_authorization"]>>;
+    scopeId: z.ZodOptional<z.ZodString>;
+    delegationRef: z.ZodOptional<z.ZodString>;
+    clientDid: z.ZodOptional<z.ZodString>;
+    toolName: z.ZodOptional<z.ZodString>;
+    submissionOutcome: z.ZodOptional<z.ZodEnum<["success", "failure", "denied"]>>;
+}, "strip", z.ZodTypeAny, {
+    did: string;
+    kid: string;
+    nonce: string;
+    audience: string;
+    sessionId: string;
+    ts: number;
+    requestHash: string;
+    responseHash: string;
+    clientDid?: string | undefined;
+    delegationRef?: string | undefined;
+    outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+    scopeId?: string | undefined;
+    toolName?: string | undefined;
+    submissionOutcome?: "success" | "denied" | "failure" | undefined;
+}, {
+    did: string;
+    kid: string;
+    nonce: string;
+    audience: string;
+    sessionId: string;
+    ts: number;
+    requestHash: string;
+    responseHash: string;
+    clientDid?: string | undefined;
+    delegationRef?: string | undefined;
+    outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+    scopeId?: string | undefined;
+    toolName?: string | undefined;
+    submissionOutcome?: "success" | "denied" | "failure" | undefined;
+}>;
+export declare const DetachedProofSchema: z.ZodObject<{
+    jws: z.ZodString;
+    meta: z.ZodObject<{
+        did: z.ZodString;
+        kid: z.ZodString;
+        ts: z.ZodNumber;
+        nonce: z.ZodString;
+        audience: z.ZodString;
+        sessionId: z.ZodString;
+        requestHash: z.ZodString;
+        responseHash: z.ZodString;
+        outcome: z.ZodOptional<z.ZodEnum<["allowed", "denied", "step_up_required", "needs_authorization"]>>;
+        scopeId: z.ZodOptional<z.ZodString>;
+        delegationRef: z.ZodOptional<z.ZodString>;
+        clientDid: z.ZodOptional<z.ZodString>;
+        toolName: z.ZodOptional<z.ZodString>;
+        submissionOutcome: z.ZodOptional<z.ZodEnum<["success", "failure", "denied"]>>;
+    }, "strip", z.ZodTypeAny, {
+        did: string;
+        kid: string;
+        nonce: string;
+        audience: string;
+        sessionId: string;
+        ts: number;
+        requestHash: string;
+        responseHash: string;
+        clientDid?: string | undefined;
+        delegationRef?: string | undefined;
+        outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+        scopeId?: string | undefined;
+        toolName?: string | undefined;
+        submissionOutcome?: "success" | "denied" | "failure" | undefined;
+    }, {
+        did: string;
+        kid: string;
+        nonce: string;
+        audience: string;
+        sessionId: string;
+        ts: number;
+        requestHash: string;
+        responseHash: string;
+        clientDid?: string | undefined;
+        delegationRef?: string | undefined;
+        outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+        scopeId?: string | undefined;
+        toolName?: string | undefined;
+        submissionOutcome?: "success" | "denied" | "failure" | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    jws: string;
+    meta: {
+        did: string;
+        kid: string;
+        nonce: string;
+        audience: string;
+        sessionId: string;
+        ts: number;
+        requestHash: string;
+        responseHash: string;
+        clientDid?: string | undefined;
+        delegationRef?: string | undefined;
+        outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+        scopeId?: string | undefined;
+        toolName?: string | undefined;
+        submissionOutcome?: "success" | "denied" | "failure" | undefined;
+    };
+}, {
+    jws: string;
+    meta: {
+        did: string;
+        kid: string;
+        nonce: string;
+        audience: string;
+        sessionId: string;
+        ts: number;
+        requestHash: string;
+        responseHash: string;
+        clientDid?: string | undefined;
+        delegationRef?: string | undefined;
+        outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+        scopeId?: string | undefined;
+        toolName?: string | undefined;
+        submissionOutcome?: "success" | "denied" | "failure" | undefined;
+    };
+}>;
+export declare const CanonicalHashesSchema: z.ZodObject<{
+    requestHash: z.ZodString;
+    responseHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    requestHash: string;
+    responseHash: string;
+}, {
+    requestHash: string;
+    responseHash: string;
+}>;
+export declare const AuditRecordSchema: z.ZodObject<{
+    version: z.ZodLiteral<"audit.v1">;
+    ts: z.ZodNumber;
+    session: z.ZodString;
+    audience: z.ZodString;
+    did: z.ZodString;
+    kid: z.ZodString;
+    reqHash: z.ZodString;
+    resHash: z.ZodString;
+    verified: z.ZodEnum<["yes", "no"]>;
+    scope: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: "audit.v1";
+    did: string;
+    kid: string;
+    audience: string;
+    ts: number;
+    session: string;
+    reqHash: string;
+    resHash: string;
+    verified: "yes" | "no";
+    scope: string;
+}, {
+    version: "audit.v1";
+    did: string;
+    kid: string;
+    audience: string;
+    ts: number;
+    session: string;
+    reqHash: string;
+    resHash: string;
+    verified: "yes" | "no";
+    scope: string;
+}>;
+export type ProofMeta = z.infer<typeof ProofMetaSchema>;
+export type DetachedProof = z.infer<typeof DetachedProofSchema>;
+export type CanonicalHashes = z.infer<typeof CanonicalHashesSchema>;
+export type AuditRecord = z.infer<typeof AuditRecordSchema>;
+export declare const JWS_ALGORITHM = "EdDSA";
+export declare const HASH_ALGORITHM = "sha256";
+export declare const AUDIT_VERSION = "audit.v1";
+/**
+ * Tool call context for AgentShield dashboard integration
+ * Provides plaintext tool execution data alongside cryptographic proofs
+ */
+export declare const ToolCallContextSchema: z.ZodObject<{
+    tool: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    scopeId: z.ZodString;
+    userId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    scopeId: string;
+    tool: string;
+    args: Record<string, unknown>;
+    userId?: string | undefined;
+    result?: unknown;
+}, {
+    scopeId: string;
+    tool: string;
+    args: Record<string, unknown>;
+    userId?: string | undefined;
+    result?: unknown;
+}>;
+/**
+ * Proof submission context for AgentShield API
+ * Includes tool calls and optional MCP server URL for tool discovery
+ */
+export declare const ProofSubmissionContextSchema: z.ZodObject<{
+    toolCalls: z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        scopeId: z.ZodString;
+        userId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        scopeId: string;
+        tool: string;
+        args: Record<string, unknown>;
+        userId?: string | undefined;
+        result?: unknown;
+    }, {
+        scopeId: string;
+        tool: string;
+        args: Record<string, unknown>;
+        userId?: string | undefined;
+        result?: unknown;
+    }>, "many">;
+    mcpServerUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    toolCalls: {
+        scopeId: string;
+        tool: string;
+        args: Record<string, unknown>;
+        userId?: string | undefined;
+        result?: unknown;
+    }[];
+    mcpServerUrl?: string | undefined;
+}, {
+    toolCalls: {
+        scopeId: string;
+        tool: string;
+        args: Record<string, unknown>;
+        userId?: string | undefined;
+        result?: unknown;
+    }[];
+    mcpServerUrl?: string | undefined;
+}>;
+/**
+ * Complete proof submission request to AgentShield
+ */
+export declare const ProofSubmissionRequestSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    delegation_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    proofs: z.ZodArray<z.ZodObject<{
+        jws: z.ZodString;
+        meta: z.ZodObject<{
+            did: z.ZodString;
+            kid: z.ZodString;
+            ts: z.ZodNumber;
+            nonce: z.ZodString;
+            audience: z.ZodString;
+            sessionId: z.ZodString;
+            requestHash: z.ZodString;
+            responseHash: z.ZodString;
+            outcome: z.ZodOptional<z.ZodEnum<["allowed", "denied", "step_up_required", "needs_authorization"]>>;
+            scopeId: z.ZodOptional<z.ZodString>;
+            delegationRef: z.ZodOptional<z.ZodString>;
+            clientDid: z.ZodOptional<z.ZodString>;
+            toolName: z.ZodOptional<z.ZodString>;
+            submissionOutcome: z.ZodOptional<z.ZodEnum<["success", "failure", "denied"]>>;
+        }, "strip", z.ZodTypeAny, {
+            did: string;
+            kid: string;
+            nonce: string;
+            audience: string;
+            sessionId: string;
+            ts: number;
+            requestHash: string;
+            responseHash: string;
+            clientDid?: string | undefined;
+            delegationRef?: string | undefined;
+            outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+            scopeId?: string | undefined;
+            toolName?: string | undefined;
+            submissionOutcome?: "success" | "denied" | "failure" | undefined;
+        }, {
+            did: string;
+            kid: string;
+            nonce: string;
+            audience: string;
+            sessionId: string;
+            ts: number;
+            requestHash: string;
+            responseHash: string;
+            clientDid?: string | undefined;
+            delegationRef?: string | undefined;
+            outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+            scopeId?: string | undefined;
+            toolName?: string | undefined;
+            submissionOutcome?: "success" | "denied" | "failure" | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        jws: string;
+        meta: {
+            did: string;
+            kid: string;
+            nonce: string;
+            audience: string;
+            sessionId: string;
+            ts: number;
+            requestHash: string;
+            responseHash: string;
+            clientDid?: string | undefined;
+            delegationRef?: string | undefined;
+            outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+            scopeId?: string | undefined;
+            toolName?: string | undefined;
+            submissionOutcome?: "success" | "denied" | "failure" | undefined;
+        };
+    }, {
+        jws: string;
+        meta: {
+            did: string;
+            kid: string;
+            nonce: string;
+            audience: string;
+            sessionId: string;
+            ts: number;
+            requestHash: string;
+            responseHash: string;
+            clientDid?: string | undefined;
+            delegationRef?: string | undefined;
+            outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+            scopeId?: string | undefined;
+            toolName?: string | undefined;
+            submissionOutcome?: "success" | "denied" | "failure" | undefined;
+        };
+    }>, "many">;
+    context: z.ZodOptional<z.ZodObject<{
+        toolCalls: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            scopeId: z.ZodString;
+            userId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            scopeId: string;
+            tool: string;
+            args: Record<string, unknown>;
+            userId?: string | undefined;
+            result?: unknown;
+        }, {
+            scopeId: string;
+            tool: string;
+            args: Record<string, unknown>;
+            userId?: string | undefined;
+            result?: unknown;
+        }>, "many">;
+        mcpServerUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        toolCalls: {
+            scopeId: string;
+            tool: string;
+            args: Record<string, unknown>;
+            userId?: string | undefined;
+            result?: unknown;
+        }[];
+        mcpServerUrl?: string | undefined;
+    }, {
+        toolCalls: {
+            scopeId: string;
+            tool: string;
+            args: Record<string, unknown>;
+            userId?: string | undefined;
+            result?: unknown;
+        }[];
+        mcpServerUrl?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    session_id: string;
+    proofs: {
+        jws: string;
+        meta: {
+            did: string;
+            kid: string;
+            nonce: string;
+            audience: string;
+            sessionId: string;
+            ts: number;
+            requestHash: string;
+            responseHash: string;
+            clientDid?: string | undefined;
+            delegationRef?: string | undefined;
+            outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+            scopeId?: string | undefined;
+            toolName?: string | undefined;
+            submissionOutcome?: "success" | "denied" | "failure" | undefined;
+        };
+    }[];
+    delegation_id?: string | null | undefined;
+    context?: {
+        toolCalls: {
+            scopeId: string;
+            tool: string;
+            args: Record<string, unknown>;
+            userId?: string | undefined;
+            result?: unknown;
+        }[];
+        mcpServerUrl?: string | undefined;
+    } | undefined;
+}, {
+    session_id: string;
+    proofs: {
+        jws: string;
+        meta: {
+            did: string;
+            kid: string;
+            nonce: string;
+            audience: string;
+            sessionId: string;
+            ts: number;
+            requestHash: string;
+            responseHash: string;
+            clientDid?: string | undefined;
+            delegationRef?: string | undefined;
+            outcome?: "allowed" | "denied" | "step_up_required" | "needs_authorization" | undefined;
+            scopeId?: string | undefined;
+            toolName?: string | undefined;
+            submissionOutcome?: "success" | "denied" | "failure" | undefined;
+        };
+    }[];
+    delegation_id?: string | null | undefined;
+    context?: {
+        toolCalls: {
+            scopeId: string;
+            tool: string;
+            args: Record<string, unknown>;
+            userId?: string | undefined;
+            result?: unknown;
+        }[];
+        mcpServerUrl?: string | undefined;
+    } | undefined;
+}>;
+export type ToolCallContext = z.infer<typeof ToolCallContextSchema>;
+export type ProofSubmissionContext = z.infer<typeof ProofSubmissionContextSchema>;
+export type ProofSubmissionRequest = z.infer<typeof ProofSubmissionRequestSchema>;

package/node_modules/@kya-os/contracts/dist/proof/detached-proof.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProofSubmissionRequestSchema = exports.ProofSubmissionContextSchema = exports.ToolCallContextSchema = exports.AUDIT_VERSION = exports.HASH_ALGORITHM = exports.JWS_ALGORITHM = exports.AuditRecordSchema = exports.CanonicalHashesSchema = exports.DetachedProofSchema = exports.ProofMetaSchema = exports.ProofOutcomeSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Proof and signature schemas for MCP-I
+ *
+ * Note: The type name "DetachedProof" is maintained for backward compatibility,
+ * but the JWS format is actually FULL compact JWS (header.payload.signature),
+ * not detached format (header..signature).
+ *
+ * The JWS payload contains JWT standard claims (aud, sub, iss) plus custom
+ * proof claims (requestHash, responseHash, nonce, etc.).
+ */
+/**
+ * Outcome of the policy decision a proof attests to (ratified DIF decision).
+ *
+ * - `allowed`             — the call was authorized and produced a response; the
+ *                           proof carries a `responseHash` over that response.
+ * - `denied`              — the call was refused; no response was produced.
+ * - `step_up_required`    — a step-up (re-auth / higher assurance) is required
+ *                           before the call may proceed; no response yet.
+ * - `needs_authorization` — explicit user authorization is required first; no
+ *                           response yet.
+ *
+ * Denial and step-up outcomes authorize no response, so their proofs omit
+ * `responseHash`. The field is optional on {@link ProofMetaSchema}: proofs minted
+ * before it existed carry no `outcome` and are treated as `allowed`.
+ */
+exports.ProofOutcomeSchema = zod_1.z.enum([
+    "allowed",
+    "denied",
+    "step_up_required",
+    "needs_authorization",
+]);
+exports.ProofMetaSchema = zod_1.z.object({
+    did: zod_1.z.string().min(1),
+    kid: zod_1.z.string().min(1),
+    ts: zod_1.z.number().int().positive(),
+    nonce: zod_1.z.string().min(1),
+    audience: zod_1.z.string().min(1),
+    sessionId: zod_1.z.string().min(1),
+    requestHash: zod_1.z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    responseHash: zod_1.z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    // Policy outcome this proof attests to (ratified DIF decision); absent on
+    // legacy proofs, which consumers treat as "allowed". Per the ratified schema
+    // `responseHash` is present only for the "allowed" outcome — the verifier
+    // enforces that outcome-conditionally. `responseHash` stays required-typed
+    // here to avoid a repo-wide `string | undefined` ripple; making it
+    // conditionally optional is a deferred schema refinement.
+    outcome: exports.ProofOutcomeSchema.optional(),
+    scopeId: zod_1.z.string().optional(),
+    delegationRef: zod_1.z.string().optional(),
+    clientDid: zod_1.z.string().optional(), // Optional for backward compatibility
+    toolName: zod_1.z.string().min(1).optional(),
+    // KTA's "did the tool call itself succeed" concept -- distinct from
+    // `outcome` above (the ratified DIF policy-decision field). Only at JWS
+    // payload serialization time does this get mapped onto the literal wire
+    // key `outcome`; the two never share a validation enum here.
+    submissionOutcome: zod_1.z.enum(["success", "failure", "denied"]).optional(),
+});
+exports.DetachedProofSchema = zod_1.z.object({
+    jws: zod_1.z.string().min(1), // Full compact JWS format (header.payload.signature)
+    meta: exports.ProofMetaSchema, // Convenience metadata (duplicates signed payload data)
+});
+exports.CanonicalHashesSchema = zod_1.z.object({
+    requestHash: zod_1.z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    responseHash: zod_1.z.string().regex(/^sha256:[a-f0-9]{64}$/),
+});
+exports.AuditRecordSchema = zod_1.z.object({
+    version: zod_1.z.literal("audit.v1"),
+    ts: zod_1.z.number().int().positive(),
+    session: zod_1.z.string().min(1),
+    audience: zod_1.z.string().min(1),
+    did: zod_1.z.string().min(1),
+    kid: zod_1.z.string().min(1),
+    reqHash: zod_1.z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    resHash: zod_1.z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    verified: zod_1.z.enum(["yes", "no"]),
+    scope: zod_1.z.string().min(1), // "-" for no scope
+});
+// Constants
+exports.JWS_ALGORITHM = "EdDSA";
+exports.HASH_ALGORITHM = "sha256";
+exports.AUDIT_VERSION = "audit.v1";
+/**
+ * Tool call context for AgentShield dashboard integration
+ * Provides plaintext tool execution data alongside cryptographic proofs
+ */
+exports.ToolCallContextSchema = zod_1.z.object({
+    tool: zod_1.z.string().min(1),
+    args: zod_1.z.record(zod_1.z.unknown()),
+    result: zod_1.z.unknown().optional(),
+    scopeId: zod_1.z.string(),
+    userId: zod_1.z.string().optional(),
+});
+/**
+ * Proof submission context for AgentShield API
+ * Includes tool calls and optional MCP server URL for tool discovery
+ */
+exports.ProofSubmissionContextSchema = zod_1.z.object({
+    toolCalls: zod_1.z.array(exports.ToolCallContextSchema),
+    mcpServerUrl: zod_1.z.string().url().optional(),
+});
+/**
+ * Complete proof submission request to AgentShield
+ */
+exports.ProofSubmissionRequestSchema = zod_1.z.object({
+    session_id: zod_1.z.string().min(1),
+    delegation_id: zod_1.z.string().nullable().optional(),
+    proofs: zod_1.z.array(zod_1.z.object({
+        jws: zod_1.z.string().min(1),
+        meta: exports.ProofMetaSchema,
+    })),
+    context: exports.ProofSubmissionContextSchema.optional(),
+});

package/node_modules/@kya-os/contracts/dist/proof/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Proof Module Exports
+ *
+ * This module exports all proof-related types including DetachedProof,
+ * proof records, and signing specs.
+ *
+ * `detached-proof.ts` is this subpath's own content (folded in from the
+ * former flat `src/proof.ts`, review-loop P20 phase 0 -- see that file's
+ * `@deprecated` shim for why). Import the specific submodule directly, as
+ * `handshake/github-credential-anchor.ts` already does for `signing-spec.ts`,
+ * rather than routing through this barrel or the flat shim.
+ */
+export * from "./detached-proof.js";
+export * from "./signing-spec.js";
+export * from "./proof-record.js";

package/node_modules/@kya-os/contracts/dist/proof/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Proof Module Exports
+ *
+ * This module exports all proof-related types including DetachedProof,
+ * proof records, and signing specs.
+ *
+ * `detached-proof.ts` is this subpath's own content (folded in from the
+ * former flat `src/proof.ts`, review-loop P20 phase 0 -- see that file's
+ * `@deprecated` shim for why). Import the specific submodule directly, as
+ * `handshake/github-credential-anchor.ts` already does for `signing-spec.ts`,
+ * rather than routing through this barrel or the flat shim.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./detached-proof.js"), exports);
+// Export proof record and signing spec types
+__exportStar(require("./signing-spec.js"), exports);
+__exportStar(require("./proof-record.js"), exports);