@metalabel/dfos-protocol 0.7.1 → 0.8.0

package/dist/credentials/index.d.ts

@@ -1,15 +1,33 @@
 import { z } from 'zod';
+import { V as VerifiedIdentity } from '../schemas-BEl38wrI.js';
 
-/** VC type for authorizing content chain writes (delegated operations) */
-declare const VC_TYPE_CONTENT_WRITE = "DFOSContentWrite";
-/** VC type for authorizing content plane reads (relay access) */
-declare const VC_TYPE_CONTENT_READ = "DFOSContentRead";
-/** All known DFOS VC types */
-declare const DFOSCredentialType: z.ZodEnum<{
-    DFOSContentWrite: "DFOSContentWrite";
-    DFOSContentRead: "DFOSContentRead";
-}>;
-type DFOSCredentialType = z.infer<typeof DFOSCredentialType>;
+/** Single attenuation entry — resource + action pair */
+declare const Attenuation: z.ZodObject<{
+    resource: z.ZodString;
+    action: z.ZodString;
+}, z.core.$strict>;
+type Attenuation = z.infer<typeof Attenuation>;
+/** DFOS credential payload — UCAN-style authorization token */
+declare const DFOSCredentialPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"DFOSCredential">;
+    /** Issuer DID */
+    iss: z.ZodString;
+    /** Audience DID or "*" for public credentials */
+    aud: z.ZodString;
+    /** Attenuations — resource + action pairs */
+    att: z.ZodArray<z.ZodObject<{
+        resource: z.ZodString;
+        action: z.ZodString;
+    }, z.core.$strict>>;
+    /** Parent credential JWS tokens (for delegation chains) */
+    prf: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    /** Expiration — unix seconds */
+    exp: z.ZodNumber;
+    /** Issued at — unix seconds */
+    iat: z.ZodNumber;
+}, z.core.$strict>;
+type DFOSCredentialPayload = z.infer<typeof DFOSCredentialPayload>;
 /** Claims for a DID-signed auth token (relay AuthN) */
 declare const AuthTokenClaims: z.ZodObject<{
     /** Issuer — the DID proving identity */
@@ -24,61 +42,6 @@ declare const AuthTokenClaims: z.ZodObject<{
     iat: z.ZodNumber;
 }, z.core.$strict>;
 type AuthTokenClaims = z.infer<typeof AuthTokenClaims>;
-/** Credential subject for content write authorization */
-declare const ContentWriteSubject: z.ZodObject<{
-    /** Optional content chain narrowing — if absent, grants broad write access */
-    contentId: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-type ContentWriteSubject = z.infer<typeof ContentWriteSubject>;
-/** Credential subject for content read authorization */
-declare const ContentReadSubject: z.ZodObject<{
-    /** Optional content chain narrowing — if absent, grants broad read access */
-    contentId: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-type ContentReadSubject = z.infer<typeof ContentReadSubject>;
-/** The `vc` claim in a VC-JWT payload */
-declare const VCClaim: z.ZodObject<{
-    '@context': z.ZodTuple<[z.ZodLiteral<"https://www.w3.org/ns/credentials/v2">], null>;
-    type: z.ZodPipe<z.ZodTuple<[z.ZodLiteral<"VerifiableCredential">, z.ZodEnum<{
-        DFOSContentWrite: "DFOSContentWrite";
-        DFOSContentRead: "DFOSContentRead";
-    }>], null>, z.ZodTransform<[string, "DFOSContentWrite" | "DFOSContentRead"], ["VerifiableCredential", "DFOSContentWrite" | "DFOSContentRead"]>>;
-    credentialSubject: z.ZodUnion<readonly [z.ZodObject<{
-        /** Optional content chain narrowing — if absent, grants broad write access */
-        contentId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        /** Optional content chain narrowing — if absent, grants broad read access */
-        contentId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>]>;
-}, z.core.$strict>;
-type VCClaim = z.infer<typeof VCClaim>;
-/** Full VC-JWT payload claims */
-declare const CredentialClaims: z.ZodObject<{
-    /** Issuer — the DID granting the credential */
-    iss: z.ZodString;
-    /** Subject — the DID receiving the credential */
-    sub: z.ZodString;
-    /** Expiration — unix seconds */
-    exp: z.ZodNumber;
-    /** Issued at — unix seconds */
-    iat: z.ZodNumber;
-    /** Verifiable credential claim */
-    vc: z.ZodObject<{
-        '@context': z.ZodTuple<[z.ZodLiteral<"https://www.w3.org/ns/credentials/v2">], null>;
-        type: z.ZodPipe<z.ZodTuple<[z.ZodLiteral<"VerifiableCredential">, z.ZodEnum<{
-            DFOSContentWrite: "DFOSContentWrite";
-            DFOSContentRead: "DFOSContentRead";
-        }>], null>, z.ZodTransform<[string, "DFOSContentWrite" | "DFOSContentRead"], ["VerifiableCredential", "DFOSContentWrite" | "DFOSContentRead"]>>;
-        credentialSubject: z.ZodUnion<readonly [z.ZodObject<{
-            /** Optional content chain narrowing — if absent, grants broad write access */
-            contentId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>, z.ZodObject<{
-            /** Optional content chain narrowing — if absent, grants broad read access */
-            contentId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>]>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-type CredentialClaims = z.infer<typeof CredentialClaims>;
 
 interface AuthTokenCreateOptions {
     /** The DID proving identity */
@@ -128,79 +91,132 @@ declare class AuthTokenVerificationError extends Error {
     constructor(message: string);
 }
 
-interface CredentialCreateOptions {
-    /** The DID granting the credential (content creator/controller) */
+interface VerifiedDFOSCredential {
+    /** Issuer DID */
     iss: string;
-    /** The DID receiving the credential (collaborator/reader) */
-    sub: string;
-    /** Expiration — unix seconds */
+    /** Audience DID or "*" for public */
+    aud: string;
+    /** Attenuations — resource + action pairs */
+    att: Attenuation[];
+    /** Parent credential JWS tokens */
+    prf: string[];
+    /** Expiry (unix seconds) */
     exp: number;
-    /** kid — DID URL of the issuer: "did:dfos:xxx#key_yyy" */
-    kid: string;
-    /** Credential type */
-    type: DFOSCredentialType;
-    /** Optional content chain narrowing */
-    contentId?: string;
-    /** Issued-at override — unix seconds (defaults to Date.now()) */
-    iat?: number;
-    /** Signer function */
-    sign: (message: Uint8Array) => Promise<Uint8Array>;
+    /** Issued at (unix seconds) */
+    iat: number;
+    /** CID of the credential payload (for revocation references) */
+    credentialCID: string;
+    /** kid from the JWS header */
+    signerKeyId: string;
 }
-interface CredentialVerifyOptions {
-    /** The VC-JWT token string */
-    token: string;
-    /** Raw Ed25519 public key bytes (32 bytes) of the issuer */
-    publicKey: Uint8Array;
-    /** Expected subject DID (optional — if provided, sub must match) */
-    subject?: string;
-    /** Expected credential type (optional — if provided, type must match) */
-    expectedType?: DFOSCredentialType;
-    /** Current time in seconds (defaults to Date.now() / 1000) */
-    currentTime?: number;
+interface VerifiedDelegationChain {
+    /** The leaf credential */
+    credential: VerifiedDFOSCredential;
+    /** All credentials in the chain, from leaf to root */
+    chain: VerifiedDFOSCredential[];
+    /** The root DID that ultimately authorized the chain */
+    rootDID: string;
 }
-interface VerifiedCredential {
-    /** The DID that issued the credential */
-    iss: string;
-    /** The DID the credential was issued to */
-    sub: string;
-    /** Credential expiration (unix seconds) */
+/**
+ * Create a signed DFOS credential
+ *
+ * The credential is a JWS with `typ: "did:dfos:credential"` and a CID in the
+ * protected header for revocation addressability.
+ */
+declare const createDFOSCredential: (options: {
+    issuerDID: string;
+    /** Audience DID, or "*" for public credentials */
+    audienceDID: string;
+    att: Attenuation[];
+    /** Parent credential JWS tokens (for delegation chains) */
+    prf?: string[];
+    /** Expiry — unix seconds */
     exp: number;
-    /** The DFOS credential type */
-    type: DFOSCredentialType;
-    /** kid from the JWT header */
-    kid: string;
-    /** Optional content chain narrowing */
-    contentId?: string;
-}
+    /** Signer function */
+    signer: (message: Uint8Array) => Promise<Uint8Array>;
+    /** Key ID (without DID prefix — just the key_xxx part) */
+    keyId: string;
+    /** Issued-at override — unix seconds (defaults to Date.now()) */
+    iat?: number;
+}) => Promise<string>;
+/**
+ * Verify a DFOS credential — signature, schema, expiry, CID integrity
+ *
+ * Does NOT verify the delegation chain. Use `verifyDelegationChain` for full
+ * chain verification including attenuation enforcement.
+ */
+declare const verifyDFOSCredential: (jwsToken: string, options: {
+    resolveIdentity: (did: string) => Promise<VerifiedIdentity | undefined>;
+    /** Current time in seconds (defaults to Date.now() / 1000) */
+    now?: number;
+}) => Promise<VerifiedDFOSCredential>;
+/**
+ * Verify a full delegation chain — walk `prf`, confirm monotonic attenuation,
+ * verify each credential's signature, and confirm the chain roots at `rootDID`.
+ *
+ * The chain is walked from the leaf credential upward through each parent in
+ * `prf`. At each hop: the child's `iss` must match a parent's `aud` (or the
+ * parent's `aud` must be `"*"`), the child's `att` must be attenuated from the
+ * parent's `att`, and the child's `exp` must not exceed the parent's `exp`.
+ *
+ * The chain terminates when a credential has `prf: []` (root credential). The
+ * root credential's `iss` must equal `rootDID`.
+ */
+declare const verifyDelegationChain: (credential: VerifiedDFOSCredential, options: {
+    resolveIdentity: (did: string) => Promise<VerifiedIdentity | undefined>;
+    /** The expected root authority DID (e.g., content chain creator) */
+    rootDID: string;
+    /** Current time in seconds (defaults to Date.now() / 1000) */
+    now?: number;
+    /** Check if a credential has been revoked (checked at every level of the chain) */
+    isRevoked?: (issuerDID: string, credentialCID: string) => Promise<boolean>;
+}) => Promise<VerifiedDelegationChain>;
 /**
- * Create a VC-JWT credential
+ * Check if `childAtt` is a valid attenuation of `parentAtt`
+ *
+ * Every entry in `childAtt` must be covered by at least one entry in
+ * `parentAtt`. Coverage rules:
  *
- * The credential is a JWT with `typ: "vc+jwt"` in the header and a `vc`
- * claim in the payload following W3C VC Data Model v2.
+ * - `chain:X` covered by `chain:X` (exact match)
+ * - `chain:X` covered by `chain:*` (narrowing from wildcard — valid)
+ * - `chain:X` covered by `manifest:M` (narrowing from manifest — valid structurally)
+ * - `manifest:M` covered by `chain:*` (narrowing from wildcard — valid)
+ * - `manifest:M` covered by `manifest:M` (exact match)
+ * - `manifest:M` NOT covered by `chain:X` (widening — invalid)
+ * - `chain:*` covered by `chain:*` (exact match)
+ * - `chain:*` NOT covered by `chain:X` or `manifest:M` (widening — invalid)
+ * - Actions: child action set must be a subset of parent action set
  */
-declare const createCredential: (options: CredentialCreateOptions) => Promise<string>;
+declare const isAttenuated: (parentAtt: Attenuation[], childAtt: Attenuation[]) => boolean;
 /**
- * Verify a VC-JWT credential
+ * Check if an `att` array covers a requested resource
+ *
+ * Used at the relay to determine if a credential authorizes access to a
+ * specific content chain.
  *
- * Checks signature, expiration, payload structure, and optionally subject
- * and credential type.
+ * For `manifest:` resources, requires a `manifestLookup` callback to resolve
+ * which contentIds the manifest indexes. Without the callback, `manifest:`
+ * resources can only match exact `manifest:` requests, not `chain:` requests.
  */
-declare const verifyCredential: (options: CredentialVerifyOptions) => VerifiedCredential;
+declare const matchesResource: (att: Attenuation[], resource: string, action: string, options?: {
+    manifestLookup?: (manifestContentId: string) => Promise<string[]>;
+}) => Promise<boolean>;
 /**
- * Decode a VC-JWT credential without verifying the signature
+ * Decode a DFOS credential JWS without verifying the signature
  *
- * Returns null if the token is malformed or claims are invalid.
+ * Returns null if the token is malformed or payload is invalid.
  */
-declare const decodeCredentialUnsafe: (token: string) => {
+declare const decodeDFOSCredentialUnsafe: (jwsToken: string) => {
     header: {
         alg: string;
         typ: string;
         kid: string;
+        cid: string;
     };
-    claims: CredentialClaims;
+    payload: DFOSCredentialPayload;
 } | null;
 declare class CredentialVerificationError extends Error {
     constructor(message: string);
 }
 
-export { AuthTokenClaims, type AuthTokenCreateOptions, AuthTokenVerificationError, type AuthTokenVerifyOptions, ContentReadSubject, ContentWriteSubject, CredentialClaims, type CredentialCreateOptions, CredentialVerificationError, type CredentialVerifyOptions, DFOSCredentialType, VCClaim, VC_TYPE_CONTENT_READ, VC_TYPE_CONTENT_WRITE, type VerifiedAuthToken, type VerifiedCredential, createAuthToken, createCredential, decodeCredentialUnsafe, verifyAuthToken, verifyCredential };
+export { Attenuation, AuthTokenClaims, type AuthTokenCreateOptions, AuthTokenVerificationError, type AuthTokenVerifyOptions, CredentialVerificationError, DFOSCredentialPayload, type VerifiedAuthToken, type VerifiedDFOSCredential, type VerifiedDelegationChain, createAuthToken, createDFOSCredential, decodeDFOSCredentialUnsafe, isAttenuated, matchesResource, verifyAuthToken, verifyDFOSCredential, verifyDelegationChain };

package/dist/credentials/index.js

@@ -1,35 +1,31 @@
 import {
+  Attenuation,
   AuthTokenClaims,
   AuthTokenVerificationError,
-  ContentReadSubject,
-  ContentWriteSubject,
-  CredentialClaims,
   CredentialVerificationError,
-  DFOSCredentialType,
-  VCClaim,
-  VC_TYPE_CONTENT_READ,
-  VC_TYPE_CONTENT_WRITE,
+  DFOSCredentialPayload,
   createAuthToken,
-  createCredential,
-  decodeCredentialUnsafe,
+  createDFOSCredential,
+  decodeDFOSCredentialUnsafe,
+  isAttenuated,
+  matchesResource,
   verifyAuthToken,
-  verifyCredential
-} from "../chunk-CZSEEZLL.js";
+  verifyDFOSCredential,
+  verifyDelegationChain
+} from "../chunk-MEV6QVLC.js";
 import "../chunk-ZXXP5W5N.js";
 export {
+  Attenuation,
   AuthTokenClaims,
   AuthTokenVerificationError,
-  ContentReadSubject,
-  ContentWriteSubject,
-  CredentialClaims,
   CredentialVerificationError,
-  DFOSCredentialType,
-  VCClaim,
-  VC_TYPE_CONTENT_READ,
-  VC_TYPE_CONTENT_WRITE,
+  DFOSCredentialPayload,
   createAuthToken,
-  createCredential,
-  decodeCredentialUnsafe,
+  createDFOSCredential,
+  decodeDFOSCredentialUnsafe,
+  isAttenuated,
+  matchesResource,
   verifyAuthToken,
-  verifyCredential
+  verifyDFOSCredential,
+  verifyDelegationChain
 };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 export { JwsHeader, JwsVerificationError, JwtClaims, JwtCreateOptions, JwtHeader, JwtVerificationError, JwtVerifyOptions, PrefixedID, base64urlDecode, base64urlEncode, createJws, createJwt, createNewEd25519Keypair, dagCborCanonicalEncode, decodeJwsUnsafe, decodeJwtUnsafe, generateId, generateIdNoPrefix, importEd25519Keypair, isCanonicallyEqual, isValidEd25519Signature, isValidId, normalizedId, parseDagCborCID, signPayloadEd25519, verifyJws, verifyJwt } from './crypto/index.js';
-export { ArtifactPayload, BeaconPayload, ContentOperation, CountersignPayload, ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, IdentityOperation, MAX_ARTIFACT_PAYLOAD_SIZE, MultikeyPublicKey, Signer, VerifiedArtifact, VerifiedBeacon, VerifiedContentChain, VerifiedCountersignature, VerifiedIdentity, decodeMultikey, deriveChainIdentifier, deriveContentId, encodeEd25519Multikey, signArtifact, signBeacon, signContentOperation, signCountersignature, signIdentityOperation, verifyArtifact, verifyBeacon, verifyContentChain, verifyContentExtensionFromTrustedState, verifyCountersignature, verifyIdentityChain, verifyIdentityExtensionFromTrustedState } from './chain/index.js';
+export { A as ArtifactPayload, B as BeaconPayload, C as ContentOperation, a as CountersignPayload, I as IdentityOperation, M as MAX_ARTIFACT_PAYLOAD_SIZE, b as MultikeyPublicKey, R as RevocationPayload, S as Signer, V as VerifiedIdentity } from './schemas-BEl38wrI.js';
+export { ED25519_PRIV_MULTICODEC, ED25519_PUB_MULTICODEC, VerifiedArtifact, VerifiedBeacon, VerifiedContentChain, VerifiedCountersignature, VerifiedRevocation, decodeMultikey, deriveChainIdentifier, deriveContentId, encodeEd25519Multikey, signArtifact, signBeacon, signContentOperation, signCountersignature, signIdentityOperation, signRevocation, verifyArtifact, verifyBeacon, verifyContentChain, verifyContentExtensionFromTrustedState, verifyCountersignature, verifyIdentityChain, verifyIdentityExtensionFromTrustedState, verifyRevocation } from './chain/index.js';
 export { MerkleProof, buildMerkleTree, generateMerkleProof, hashLeaf, hexToBytes, verifyMerkleProof } from './merkle/index.js';
-export { AuthTokenClaims, AuthTokenCreateOptions, AuthTokenVerificationError, AuthTokenVerifyOptions, ContentReadSubject, ContentWriteSubject, CredentialClaims, CredentialCreateOptions, CredentialVerificationError, CredentialVerifyOptions, DFOSCredentialType, VCClaim, VC_TYPE_CONTENT_READ, VC_TYPE_CONTENT_WRITE, VerifiedAuthToken, VerifiedCredential, createAuthToken, createCredential, decodeCredentialUnsafe, verifyAuthToken, verifyCredential } from './credentials/index.js';
+export { Attenuation, AuthTokenClaims, AuthTokenCreateOptions, AuthTokenVerificationError, AuthTokenVerifyOptions, CredentialVerificationError, DFOSCredentialPayload, VerifiedAuthToken, VerifiedDFOSCredential, VerifiedDelegationChain, createAuthToken, createDFOSCredential, decodeDFOSCredentialUnsafe, isAttenuated, matchesResource, verifyAuthToken, verifyDFOSCredential, verifyDelegationChain } from './credentials/index.js';
 import 'multiformats';
 import 'multiformats/cid';
 import 'zod';

package/dist/index.js

@@ -3,29 +3,28 @@ import {
   BeaconPayload,
   ContentOperation,
   CountersignPayload,
-  ED25519_PRIV_MULTICODEC,
-  ED25519_PUB_MULTICODEC,
   IdentityOperation,
   MAX_ARTIFACT_PAYLOAD_SIZE,
   MultikeyPublicKey,
+  RevocationPayload,
   VerifiedIdentity,
-  decodeMultikey,
   deriveChainIdentifier,
   deriveContentId,
-  encodeEd25519Multikey,
   signArtifact,
   signBeacon,
   signContentOperation,
   signCountersignature,
   signIdentityOperation,
+  signRevocation,
   verifyArtifact,
   verifyBeacon,
   verifyContentChain,
   verifyContentExtensionFromTrustedState,
   verifyCountersignature,
   verifyIdentityChain,
-  verifyIdentityExtensionFromTrustedState
-} from "./chunk-QKHP7UVL.js";
+  verifyIdentityExtensionFromTrustedState,
+  verifyRevocation
+} from "./chunk-LQ56P4SU.js";
 import {
   buildMerkleTree,
   generateMerkleProof,
@@ -34,22 +33,24 @@ import {
   verifyMerkleProof
 } from "./chunk-E5CFQG2B.js";
 import {
+  Attenuation,
   AuthTokenClaims,
   AuthTokenVerificationError,
-  ContentReadSubject,
-  ContentWriteSubject,
-  CredentialClaims,
   CredentialVerificationError,
-  DFOSCredentialType,
-  VCClaim,
-  VC_TYPE_CONTENT_READ,
-  VC_TYPE_CONTENT_WRITE,
+  DFOSCredentialPayload,
+  ED25519_PRIV_MULTICODEC,
+  ED25519_PUB_MULTICODEC,
   createAuthToken,
-  createCredential,
-  decodeCredentialUnsafe,
+  createDFOSCredential,
+  decodeDFOSCredentialUnsafe,
+  decodeMultikey,
+  encodeEd25519Multikey,
+  isAttenuated,
+  matchesResource,
   verifyAuthToken,
-  verifyCredential
-} from "./chunk-CZSEEZLL.js";
+  verifyDFOSCredential,
+  verifyDelegationChain
+} from "./chunk-MEV6QVLC.js";
 import {
   JwsVerificationError,
   JwtVerificationError,
@@ -75,16 +76,14 @@ import {
 } from "./chunk-ZXXP5W5N.js";
 export {
   ArtifactPayload,
+  Attenuation,
   AuthTokenClaims,
   AuthTokenVerificationError,
   BeaconPayload,
   ContentOperation,
-  ContentReadSubject,
-  ContentWriteSubject,
   CountersignPayload,
-  CredentialClaims,
   CredentialVerificationError,
-  DFOSCredentialType,
+  DFOSCredentialPayload,
   ED25519_PRIV_MULTICODEC,
   ED25519_PUB_MULTICODEC,
   IdentityOperation,
@@ -92,20 +91,18 @@ export {
   JwtVerificationError,
   MAX_ARTIFACT_PAYLOAD_SIZE,
   MultikeyPublicKey,
-  VCClaim,
-  VC_TYPE_CONTENT_READ,
-  VC_TYPE_CONTENT_WRITE,
+  RevocationPayload,
   VerifiedIdentity,
   base64urlDecode,
   base64urlEncode,
   buildMerkleTree,
   createAuthToken,
-  createCredential,
+  createDFOSCredential,
   createJws,
   createJwt,
   createNewEd25519Keypair,
   dagCborCanonicalEncode,
-  decodeCredentialUnsafe,
+  decodeDFOSCredentialUnsafe,
   decodeJwsUnsafe,
   decodeJwtUnsafe,
   decodeMultikey,
@@ -118,9 +115,11 @@ export {
   hashLeaf,
   hexToBytes,
   importEd25519Keypair,
+  isAttenuated,
   isCanonicallyEqual,
   isValidEd25519Signature,
   isValidId,
+  matchesResource,
   normalizedId,
   parseDagCborCID,
   signArtifact,
@@ -129,16 +128,19 @@ export {
   signCountersignature,
   signIdentityOperation,
   signPayloadEd25519,
+  signRevocation,
   verifyArtifact,
   verifyAuthToken,
   verifyBeacon,
   verifyContentChain,
   verifyContentExtensionFromTrustedState,
   verifyCountersignature,
-  verifyCredential,
+  verifyDFOSCredential,
+  verifyDelegationChain,
   verifyIdentityChain,
   verifyIdentityExtensionFromTrustedState,
   verifyJws,
   verifyJwt,
-  verifyMerkleProof
+  verifyMerkleProof,
+  verifyRevocation
 };

package/dist/schemas-BEl38wrI.d.ts

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+
+/** Function that signs a byte array and returns a signature */
+type Signer = (message: Uint8Array) => Promise<Uint8Array>;
+declare const MultikeyPublicKey: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"Multikey">;
+    publicKeyMultibase: z.ZodString;
+}, z.core.$strict>;
+type MultikeyPublicKey = z.infer<typeof MultikeyPublicKey>;
+declare const IdentityOperation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"create">;
+    authKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$strict>>;
+    assertKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$strict>>;
+    controllerKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$strict>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"update">;
+    previousOperationCID: z.ZodString;
+    authKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$strict>>;
+    assertKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$strict>>;
+    controllerKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$strict>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"delete">;
+    previousOperationCID: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>], "type">;
+type IdentityOperation = z.infer<typeof IdentityOperation>;
+declare const VerifiedIdentity: z.ZodObject<{
+    did: z.ZodString;
+    isDeleted: z.ZodBoolean;
+    authKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$strict>>;
+    assertKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$strict>>;
+    controllerKeys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"Multikey">;
+        publicKeyMultibase: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type VerifiedIdentity = z.infer<typeof VerifiedIdentity>;
+declare const ContentOperation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"create">;
+    did: z.ZodString;
+    documentCID: z.ZodString;
+    baseDocumentCID: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"update">;
+    did: z.ZodString;
+    previousOperationCID: z.ZodString;
+    documentCID: z.ZodNullable<z.ZodString>;
+    baseDocumentCID: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    note: z.ZodNullable<z.ZodString>;
+    /** DFOS credential authorizing this operation when signer is not the chain creator */
+    authorization: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"delete">;
+    did: z.ZodString;
+    previousOperationCID: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    note: z.ZodNullable<z.ZodString>;
+    /** DFOS credential authorizing this operation when signer is not the chain creator */
+    authorization: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "type">;
+type ContentOperation = z.infer<typeof ContentOperation>;
+/** Beacon: floating signed manifest pointer announcement */
+declare const BeaconPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"beacon">;
+    did: z.ZodString;
+    manifestContentId: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type BeaconPayload = z.infer<typeof BeaconPayload>;
+/** Max CBOR-encoded payload size for artifacts (bytes) — protocol constant */
+declare const MAX_ARTIFACT_PAYLOAD_SIZE = 16384;
+/** Artifact: standalone signed inline document, immutable, CID-addressable */
+declare const ArtifactPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"artifact">;
+    did: z.ZodString;
+    content: z.ZodObject<{
+        $schema: z.ZodString;
+    }, z.core.$catchall<z.ZodUnknown>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type ArtifactPayload = z.infer<typeof ArtifactPayload>;
+/** Countersign: standalone witness attestation referencing a target operation by CID */
+declare const CountersignPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"countersign">;
+    did: z.ZodString;
+    targetCID: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type CountersignPayload = z.infer<typeof CountersignPayload>;
+/** Revocation: signed credential revocation artifact, gossiped like beacons */
+declare const RevocationPayload: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"revocation">;
+    did: z.ZodString;
+    credentialCID: z.ZodString;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type RevocationPayload = z.infer<typeof RevocationPayload>;
+
+export { ArtifactPayload as A, BeaconPayload as B, ContentOperation as C, IdentityOperation as I, MAX_ARTIFACT_PAYLOAD_SIZE as M, RevocationPayload as R, type Signer as S, VerifiedIdentity as V, CountersignPayload as a, MultikeyPublicKey as b };