@tinycloud/share-sdk 0.2.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,1147 @@
+import { ShareEnvelopeV2, ShareEnvelope, ShareAction, ContentSource } from '@tinycloud/share-envelope';
+export { CheckBearerDelegationOptions, DelegationCheckResult, canonicalize, checkBearerDelegation, fromBase64Url, requiredResourceUri, resourceUriCovers, toBase64Url } from '@tinycloud/share-envelope';
+
+/** The only interactive boundary exposed by the headless SDK. */
+type ShareAuthorizationMethod = "openkey-device" | "email-claim" | "email-otp";
+interface ShareAuthorizationRequired {
+    readonly state: "authorization-required";
+    readonly method: ShareAuthorizationMethod;
+    /** A browser-safe continuation location. It must never contain a claim secret. */
+    readonly continueUrl?: string;
+    /** An opaque, short-lived, nonce-bound handle. It is not a bearer credential. */
+    readonly resumeToken?: string;
+}
+interface ShareAuthorizationDenied {
+    readonly state: "denied";
+    readonly reason: "rejected" | "expired" | "revoked" | "unsupported";
+}
+interface ShareAuthorizationReady<T> {
+    readonly state: "ready";
+    readonly value: T;
+}
+type ShareAuthorizationResult<T> = ShareAuthorizationReady<T> | ShareAuthorizationRequired | ShareAuthorizationDenied;
+interface ShareAuthorizationAdapter<T> {
+    begin(input: {
+        readonly envelope: ShareEnvelopeV2;
+        readonly method: ShareAuthorizationMethod;
+    }): Promise<ShareAuthorizationResult<T>>;
+    resume(input: {
+        readonly envelope: ShareEnvelopeV2;
+        readonly method: ShareAuthorizationMethod;
+        readonly resumeToken: string;
+        readonly proof?: unknown;
+    }): Promise<ShareAuthorizationResult<T>>;
+    /** Verify the detached node proof against a pinned authority trust bundle. */
+    readonly verifyResult?: (input: {
+        readonly envelope: ShareEnvelopeV2;
+        readonly value: T;
+        readonly proof: unknown;
+    }) => Promise<boolean>;
+}
+/**
+ * A node-authorized addressed read.  Returning plaintext alone is not an
+ * authorization result: the caller must also return the signed response
+ * binding and digest that the node produced for that exact share.
+ */
+interface ShareAuthorizedContent {
+    readonly bytes: Uint8Array;
+    readonly bodyDigest: string;
+    readonly contentSourceDigest: string;
+    readonly binding: {
+        readonly shareId: string;
+        readonly delegationCid: string;
+        readonly authorityMaterialHandle: string;
+        readonly authorityMaterialDigest: string;
+        readonly resource: {
+            readonly kind: "exact" | "prefix";
+            readonly path: string;
+        };
+        readonly action?: string;
+    };
+    /** A detached node proof; self-reported bytes and digests are not authorization. */
+    readonly proof: unknown;
+}
+/**
+ * Start or continue a target authorization without ever guessing a device,
+ * claim, or delegation secret. Adapters own their protocol and are expected
+ * to bind their resume token to a server challenge and expiry.
+ */
+declare function authorizeShare<T>(input: {
+    readonly envelope: ShareEnvelopeV2;
+    readonly method: ShareAuthorizationMethod;
+    readonly adapter: ShareAuthorizationAdapter<T>;
+    readonly resumeToken?: string;
+    readonly proof?: unknown;
+}): Promise<ShareAuthorizationResult<T>>;
+declare function authorizationMethodForTarget(target: {
+    readonly kind: string;
+}): ShareAuthorizationMethod | undefined;
+
+type ShareErrorCode = "invalid-link" | "fetch-failed" | "max-bytes-exceeded" | "cid-mismatch" | "decrypt-failed" | "envelope-invalid" | "origin-mismatch" | "signature-invalid" | "capability-invalid" | "expired" | "unsupported-target" | "authorization-denied" | "content-integrity-failed";
+declare const SHARE_RESULT_VERSION: 1;
+/** Maximum stored-block size accepted by the headless verifier by default. */
+declare const DEFAULT_MAX_SEALED_BLOB_BYTES: number;
+/** Content metadata permits at most 100 MiB of plaintext plus sealed overhead. */
+declare const DEFAULT_MAX_CONTENT_BLOB_BYTES: number;
+declare class ShareReceiveError extends Error {
+    readonly code: ShareErrorCode;
+    readonly details: {
+        readonly expiresAt?: string;
+        readonly stage?: "envelope" | "content";
+        readonly reason?: "policy-target" | "recipient-did-target" | "prefix-resource";
+    } | undefined;
+    constructor(code: ShareErrorCode, message: string, details?: {
+        readonly expiresAt?: string;
+        readonly stage?: "envelope" | "content";
+        readonly reason?: "policy-target" | "recipient-did-target" | "prefix-resource";
+    });
+    /** Machine output is deliberately code-only; diagnostics belong on stderr. */
+    toJSON(): ShareErrorInfo;
+}
+interface ShareErrorInfo {
+    readonly protocol: "tinycloud-share";
+    readonly version: typeof SHARE_RESULT_VERSION;
+    readonly error: {
+        readonly code: ShareErrorCode;
+    };
+}
+/** Convert unknown failures to the redacted public error schema. */
+declare function toShareErrorInfo(error: unknown): ShareErrorInfo;
+interface ShareFetchOptions {
+    readonly registryBaseUrl?: string;
+    readonly fetchBlob?: (input: {
+        readonly origin: string;
+        readonly cid: string;
+    }) => Promise<Uint8Array>;
+    readonly fetchFn?: typeof globalThis.fetch;
+    readonly expectedOrigin?: string;
+    /** Out-of-band signer trust root for addressed envelopes. */
+    readonly trustedSignerDid?: string;
+    /**
+     * Out-of-band policy authority.  The policy bytes carried by an envelope
+     * are only a CID-addressed integrity witness; they are never a trust root.
+     */
+    readonly trustedPolicyAuthority?: SharePolicyAuthority;
+    readonly now?: () => number;
+    readonly maxSealedBlobBytes?: number;
+    readonly maxContentBlobBytes?: number;
+    /** Observability-only hook; the SDK zeroes this authority-bearing buffer. */
+    readonly onKeyParsed?: (key32: Uint8Array) => void;
+    /** Optional node/OpenKey/email adapter for addressed v2 shares. */
+    readonly authorization?: ShareAuthorizationAdapter<ShareAuthorizedContent>;
+    readonly authorizationResumeToken?: string;
+    readonly authorizationProof?: unknown;
+    /** Addressed-only presentation hook. Bearer envelopes and their keys never cross this boundary. */
+    readonly onResolvedAddressedEnvelope?: (envelope: ShareEnvelope | ShareEnvelopeV2, cid: string) => void;
+}
+interface SharePolicyEvidence {
+    readonly policyCid: string;
+    readonly signerDid: string;
+    readonly registrationCid: string;
+    readonly shareId: string;
+    readonly recipientMatcher: unknown;
+    readonly target: {
+        readonly origin: string;
+        readonly nodeAudience: string;
+        readonly spaceId: string;
+    };
+    readonly resource: {
+        readonly kind: "exact" | "prefix";
+        readonly path: string;
+    };
+    readonly actions: readonly string[];
+    readonly contentSource: unknown;
+    readonly contentSourceDigest: string;
+    readonly delegationCid: string;
+    readonly authorityMaterialHandle: string;
+    readonly authorityMaterialDigest: string;
+    readonly expiresAt: string;
+}
+interface SharePolicyAuthority {
+    resolve(input: {
+        readonly policyCid: string;
+        readonly envelope: ShareEnvelopeV2;
+    }): Promise<SharePolicyEvidence | undefined>;
+}
+interface VerifyBearerEnvelopeOptions {
+    readonly expectedOrigin?: string;
+    readonly now?: () => number;
+}
+/** Redacted metadata; link keys, delegations, policy bytes, and claims never appear here. */
+interface ShareMetadata {
+    readonly protocol: "tinycloud-share";
+    readonly version: 1;
+    readonly shareId: string;
+    readonly origin: string;
+    readonly target: {
+        readonly kind: "bearer" | "recipientDid" | "email" | "emailDomain";
+        readonly origin: string;
+        readonly nodeAudience: string;
+        readonly spaceId: string;
+    };
+    readonly resource: {
+        readonly kind: "exact" | "prefix";
+        readonly path: string;
+    };
+    readonly actions: readonly string[];
+    readonly expiresAt: string;
+    readonly display: {
+        readonly senderName?: string;
+        readonly filename?: string;
+        readonly mode?: string;
+    };
+    readonly content?: {
+        readonly cid: string;
+    };
+}
+interface ShareInspection {
+    readonly metadata: ShareMetadata;
+    readonly link: {
+        readonly origin: string;
+        readonly cid: string;
+        readonly kind: "compact" | "inline";
+    };
+}
+interface ShareReceiveAuthorizationRequired {
+    readonly state: "authorization-required";
+    readonly method: ShareAuthorizationMethod;
+    readonly continueUrl?: string;
+    readonly resumeToken?: string;
+}
+interface ShareReceiveResult extends ShareInspection {
+    readonly bytes: Uint8Array;
+    readonly text?: string;
+}
+type ShareReceiveOutcome = ShareReceiveResult | ShareReceiveAuthorizationRequired;
+/** Verify a decrypted bearer envelope for browser adapters that own transport. */
+declare function verifyBearerEnvelope(envelope: ShareEnvelope, linkOrigin: string, options?: VerifyBearerEnvelopeOptions): Promise<void>;
+declare function inspectShare(link: string, options?: ShareFetchOptions): Promise<ShareInspection>;
+declare function receiveShare(link: string, options?: ShareFetchOptions): Promise<ShareReceiveOutcome>;
+
+declare const SHARE_CONTENT_LIMIT: number;
+declare const SHARE_SEALED_OVERHEAD: number;
+declare const SHARE_PUBLISH_RESULT_VERSION: 1;
+declare const DEFAULT_SHARE_LIFETIME_MS: number;
+type SharePublishTarget = {
+    readonly kind: "bearer";
+} | {
+    readonly kind: "recipientDid";
+    readonly did: string;
+} | {
+    readonly kind: "email";
+    readonly address: string;
+} | {
+    readonly kind: "emailDomain";
+    readonly domain: string;
+};
+interface ShareUploadInput {
+    readonly blob: Uint8Array;
+    readonly cid: string;
+    readonly deleteAfter: string;
+    readonly contentLength: number;
+}
+interface ShareUploadResult {
+    readonly cid: string;
+    readonly deleteAfter: string;
+}
+type ShareUpload = (input: ShareUploadInput) => Promise<ShareUploadResult>;
+type ShareUploadAuthorization = string | HeadersInit;
+interface SharePublishOptions {
+    readonly source: Uint8Array | AsyncIterable<Uint8Array>;
+    readonly filename: string;
+    readonly mediaType?: string;
+    /** Browser Share also publishes binary files; the CLI leaves this false. */
+    readonly allowBinary?: boolean;
+    readonly target?: SharePublishTarget;
+    readonly expiresAt?: Date;
+    readonly origin: string;
+    readonly nodeAudience?: string;
+    readonly spaceId?: string;
+    readonly inline?: boolean;
+    readonly maxBytes?: number;
+    readonly now?: () => number;
+    readonly registryBaseUrl?: string;
+    readonly fetchFn?: typeof globalThis.fetch;
+    /**
+     * Signs the complete upload request, including its digest, size, expiry,
+     * and session binding. Production callers must provide this or explicitly
+     * opt into browser cookie credentials; an unsigned public upload is never
+     * attempted.
+     */
+    readonly authorizeUpload?: (input: ShareUploadInput) => Promise<ShareUploadAuthorization>;
+    /** Origin to which any cookie-bearing upload authorization is scoped. */
+    readonly authorizationOrigin?: string;
+    readonly credentials?: RequestCredentials;
+    /** Test/dev-only escape hatch for a local HTTP registry. */
+    readonly allowInsecureRegistry?: boolean;
+    /** A hermetic or service-specific uploader can own transport completely. */
+    readonly uploadBlob?: ShareUpload;
+}
+interface PublishedShareMetadata {
+    readonly protocol: "tinycloud-share";
+    readonly version: 1;
+    readonly shareId: string;
+    readonly origin: string;
+    readonly target: {
+        readonly kind: "bearer" | "recipientDid" | "email" | "emailDomain";
+        readonly origin: string;
+        readonly nodeAudience: string;
+        readonly spaceId: string;
+    };
+    readonly resource: {
+        readonly kind: "exact" | "prefix";
+        readonly path: string;
+    };
+    readonly actions: readonly string[];
+    readonly expiresAt: string;
+    readonly display: {
+        readonly filename?: string;
+        readonly senderName?: string;
+    };
+    readonly content?: {
+        readonly cid: string;
+    };
+    /** Addressed publication receipts are copied into encrypted history only. */
+    readonly recipientMatcher?: {
+        readonly kind: "bearer" | "recipientDid" | "exactEmail" | "emailDomain";
+        readonly value?: string;
+    };
+    readonly registrationCid?: string;
+    readonly policyCid?: string;
+    readonly ownerDelegationCid?: string;
+    readonly enforcementDelegationCid?: string;
+    readonly ownerDid?: string;
+    readonly shareKeyDid?: string;
+    readonly enforcerDid?: string;
+    readonly envelopeCid?: string;
+    readonly shareCid?: string;
+}
+interface PublishedShare {
+    readonly protocol: "tinycloud-share";
+    readonly version: typeof SHARE_PUBLISH_RESULT_VERSION;
+    /** The only authority-bearing value returned by publish. */
+    readonly url: string;
+    readonly link: {
+        readonly kind: "compact" | "inline";
+        readonly cid: string;
+    };
+    readonly metadata: PublishedShareMetadata;
+    readonly registryDeleteAfter: string;
+}
+/** Machine-readable output omits the complete bearer capability. */
+declare function redactPublishedShare(result: PublishedShare): Omit<PublishedShare, "url">;
+type SharePublishErrorCode = "invalid-argument" | "unsupported-target" | "upload-auth-required" | "upload-failed" | "max-bytes-exceeded" | "inline-too-large";
+declare class SharePublishError extends Error {
+    readonly code: SharePublishErrorCode;
+    constructor(code: SharePublishErrorCode, message: string);
+}
+/** Publish a bounded bearer Markdown artifact using the canonical envelope. */
+declare function publishShare(options: SharePublishOptions): Promise<PublishedShare>;
+
+interface ParsedAddressedEnvelope {
+    readonly envelope: ShareEnvelopeV2;
+    readonly policy: Record<string, unknown>;
+    readonly policyCid: string;
+}
+/** Parse and bind the signed policy bytes before any holder or node effect. */
+declare function parseAddressedEnvelope(value: unknown): Promise<ParsedAddressedEnvelope>;
+
+interface OwnerDelegationReceipt {
+    readonly delegationCid: string;
+    readonly signedDagCbor: Uint8Array;
+    readonly delegation: {
+        readonly delegateDID: string;
+        readonly spaceId: string;
+        readonly path: string;
+        readonly actions: readonly string[];
+        readonly expiry: Date;
+    };
+    /** Exact service-scoped capabilities encoded in the signed owner delegation. */
+    readonly permissions?: readonly OwnerDelegationPermission[];
+}
+interface OwnerDelegationPermission {
+    readonly service: string;
+    readonly path: string;
+    readonly actions: readonly string[];
+}
+interface CreateOwnerDelegationBase {
+    readonly delegateDid: string;
+    readonly spaceId: string;
+    readonly expiresAt: Date;
+}
+type CreateOwnerDelegationParams = CreateOwnerDelegationBase & ({
+    readonly path: string;
+    readonly actions: readonly string[];
+    readonly permissions?: never;
+} | {
+    readonly permissions: readonly OwnerDelegationPermission[];
+    readonly path?: never;
+    readonly actions?: never;
+});
+declare const MAX_CONTENT_BYTES: number;
+declare const OWNER_SHARE_REGISTRATION_DOMAIN = "xyz.tinycloud.share/policy-registration/v2\0";
+type OwnerShareAction = "tinycloud.kv/get" | "tinycloud.kv/list" | "tinycloud.kv/metadata" | "tinycloud.kv/put";
+interface OwnerShareDecryption {
+    readonly networkId: string;
+    readonly action: "tinycloud.encryption/decrypt";
+}
+type OwnerShareMatcher = {
+    readonly kind: "exactEmail";
+    readonly value: string;
+} | {
+    readonly kind: "emailDomain";
+    readonly value: string;
+} | {
+    readonly kind: "recipientDid";
+    readonly value: string;
+} | {
+    readonly kind: "bearer";
+};
+interface OwnerSharePolicyV2 {
+    readonly type: "TinyCloudSharePolicy";
+    readonly version: 2;
+    readonly shareId: string;
+    readonly ownerDid: string;
+    readonly shareKeyDid: string;
+    readonly recipientMatcher: OwnerShareMatcher;
+    readonly target: {
+        readonly origin: string;
+        readonly nodeAudience: string;
+        readonly enforcerDid: string;
+        readonly spaceId: string;
+    };
+    readonly resource: {
+        readonly kind: "exact" | "prefix";
+        readonly path: string;
+    };
+    readonly actions: readonly OwnerShareAction[];
+    readonly decryption?: OwnerShareDecryption;
+    readonly contentSource: {
+        readonly kind: "kv";
+        readonly space: string;
+        readonly path: string;
+        readonly action: "tinycloud.kv/get";
+    };
+    readonly contentSourceDigest: string;
+    readonly ownerDelegationCid: string;
+    readonly expiresAt: string;
+}
+interface DelegatedShareKey {
+    readonly did: string;
+    readonly publicKey: Uint8Array;
+    readonly extractable: boolean;
+    /** The underlying WebCrypto private key handle; private JWK material is never returned. */
+    readonly cryptoKey: CryptoKey;
+    sign(bytes: Uint8Array): Promise<Uint8Array>;
+    clear(): void;
+}
+interface SignedDelegation {
+    readonly cid: string;
+    readonly dagCbor: string;
+    readonly issuerDid: string;
+    readonly audienceDid: string;
+    readonly facts: Record<string, string | readonly string[]>;
+    readonly signature: string;
+}
+interface RegisterOwnerSharePolicyParams {
+    readonly policy: {
+        readonly bytes: Uint8Array;
+        readonly cid: string;
+        readonly proof: string;
+    };
+    readonly ownerDelegation: OwnerDelegationReceipt;
+    readonly enforcementDelegation: SignedDelegation;
+    readonly contentSourceDigest: string;
+    /** The enrolled receipt key from the node trust bundle. */
+    readonly nodeProof?: {
+        readonly kid: string;
+        readonly publicKey: Uint8Array;
+    };
+}
+interface OwnerSharePolicyRegistration {
+    readonly registrationCid: string;
+    readonly policyCid: string;
+    readonly ownerDelegationCid: string;
+    readonly enforcementDelegationCid: string;
+    readonly ownerDid: string;
+    readonly shareKeyDid: string;
+    readonly enforcerDid: string;
+    readonly shareId: string;
+    readonly recipientMatcher: OwnerShareMatcher;
+    readonly target: {
+        readonly origin: string;
+        readonly nodeAudience: string;
+        readonly spaceId: string;
+    };
+    readonly resource: {
+        readonly kind: "exact" | "prefix";
+        readonly path: string;
+    };
+    readonly actions: readonly OwnerShareAction[];
+    readonly contentSource: {
+        readonly kind: "kv";
+        readonly space: string;
+        readonly path: string;
+        readonly action: "tinycloud.kv/get";
+    };
+    readonly contentSourceDigest: string;
+    readonly registeredAt: string;
+    readonly expiresAt: string;
+}
+interface OwnerSharePolicyRegistrationReceipt {
+    readonly registration: OwnerSharePolicyRegistration;
+    readonly proof: {
+        readonly alg: "EdDSA";
+        readonly kid: string;
+        readonly signature: string;
+    };
+}
+declare function createDelegatedShareKey(options: {
+    readonly extractable: boolean;
+}): Promise<DelegatedShareKey>;
+/**
+ * Rehydrate a signer wrapper around a `DelegatedShareKey`'s private
+ * `CryptoKey` handle that was persisted (e.g. via IndexedDB structured
+ * clone) and recovered after a reload. `privateKey` must be the same
+ * non-extractable Ed25519 `CryptoKey` originally produced by
+ * {@link createDelegatedShareKey}.
+ */
+declare function restoreDelegatedShareKey(input: {
+    readonly privateKey: CryptoKey;
+    readonly publicKey: Uint8Array;
+    readonly extractable: boolean;
+}): DelegatedShareKey;
+declare function createPolicyEnforcementDelegation(input: {
+    readonly ownerDelegation: OwnerDelegationReceipt;
+    readonly shareKey: DelegatedShareKey;
+    readonly enforcerDid: string;
+    readonly policyCid: string;
+    readonly shareId: string;
+    readonly spaceId: string;
+    readonly nodeAudience: string;
+    readonly path: string;
+    readonly actions: readonly OwnerShareAction[];
+    readonly contentSourceDigest: string;
+    readonly expiresAt: string;
+}): Promise<SignedDelegation>;
+declare function canonicalOwnerSharePolicy(policy: OwnerSharePolicyV2): Promise<{
+    readonly bytes: Uint8Array;
+    readonly cid: string;
+    readonly digest: string;
+}>;
+declare function computeOwnerShareRegistrationCid(registration: Omit<OwnerSharePolicyRegistration, "registrationCid">): string;
+declare function validateOwnerSharePolicyRegistration(value: unknown, expected: RegisterOwnerSharePolicyParams): OwnerSharePolicyRegistrationReceipt;
+/** Validate the exact UTF-8 response bytes emitted by the registration route. */
+declare function validateOwnerSharePolicyRegistrationBytes(bytesValue: Uint8Array, expected: RegisterOwnerSharePolicyParams): OwnerSharePolicyRegistrationReceipt;
+
+type ShareTarget = SharePublishTarget;
+interface TargetPublishInput {
+    readonly source: Uint8Array;
+    readonly filename: string;
+    /** Additional files for a prefix resource; source remains the first file for compatibility. */
+    readonly files?: readonly {
+        readonly bytes: Uint8Array;
+        readonly filename: string;
+        readonly mediaType?: string;
+    }[];
+    readonly target: Exclude<ShareTarget, {
+        readonly kind: "bearer";
+    }>;
+    readonly expiresAt: Date;
+    readonly origin: string;
+    readonly mediaType?: string;
+    readonly resourceKind?: "exact" | "prefix";
+    readonly actions?: readonly ("read" | "list" | "edit")[];
+    readonly inline?: boolean;
+    readonly upload?: AddressedSharePublishOptions["upload"];
+    readonly notify?: boolean;
+}
+type TargetPublishOutcome = PublishedShare | ShareAuthorizationRequired;
+interface TargetPublishAdapter {
+    publish(input: TargetPublishInput): Promise<TargetPublishOutcome>;
+}
+declare function normalizeShareTarget(target: ShareTarget): ShareTarget;
+declare function targetAuthorizationMethod(target: ShareTarget): ShareAuthorizationMethod | undefined;
+/** Publish bearer shares locally, and route addressed shares to an authority adapter. */
+declare function publishTargetShare(input: SharePublishOptions & {
+    readonly target: ShareTarget;
+    readonly notify?: boolean;
+    readonly targetAdapter?: TargetPublishAdapter;
+    readonly files?: readonly {
+        readonly bytes: Uint8Array;
+        readonly filename: string;
+        readonly mediaType?: string;
+    }[];
+    readonly resourceKind?: "exact" | "prefix";
+    readonly actions?: readonly ("read" | "list" | "edit")[];
+}): Promise<TargetPublishOutcome>;
+
+interface AddressedPublishAuthority {
+    readonly ownerDid: string;
+    createOwnerDelegation(input: CreateOwnerDelegationParams): Promise<OwnerDelegationReceipt>;
+    registerOwnerSharePolicy(input: RegisterOwnerSharePolicyParams): Promise<OwnerSharePolicyRegistrationReceipt>;
+}
+interface AddressedSharePublishOptions {
+    readonly shareId: string;
+    readonly shareOrigin: string;
+    readonly nodeOrigin: string;
+    readonly nodeAudience: string;
+    readonly enforcerDid: string;
+    readonly spaceId: string;
+    readonly target: Exclude<ShareTarget, {
+        readonly kind: "bearer";
+    }>;
+    readonly resource: {
+        readonly kind: "exact" | "prefix";
+        readonly path: string;
+    };
+    readonly actions: readonly ShareAction[];
+    readonly policyActions: readonly OwnerShareAction[];
+    readonly contentSource: ContentSource;
+    readonly contentSourceDigest?: string;
+    readonly filename: string;
+    readonly mediaType: string;
+    readonly byteLength: number;
+    readonly artifact?: "html";
+    readonly deliveryEmail?: string;
+    readonly expiresAt: Date;
+    readonly decryption?: OwnerShareDecryption;
+    readonly inline?: boolean;
+    readonly authority: AddressedPublishAuthority;
+    readonly upload: Pick<SharePublishOptions, "registryBaseUrl" | "fetchFn" | "authorizeUpload" | "authorizationOrigin" | "credentials" | "allowInsecureRegistry" | "uploadBlob">;
+}
+/**
+ * Canonical addressed publisher shared by browser and CLI.
+ *
+ * Callers own authenticated KV writes and transport. This function alone owns
+ * the policy, delegation, outer-authority, signed-envelope, encryption, and
+ * link bytes.
+ */
+declare function publishAddressedShare(options: AddressedSharePublishOptions): Promise<PublishedShare>;
+
+interface RegisteredPolicyAuthorityOptions {
+    readonly nodeProof: {
+        readonly kid: string;
+        readonly publicKey: Uint8Array;
+    };
+    readonly expectedTarget: {
+        readonly origin: string;
+        readonly nodeAudience: string;
+        readonly enforcerDid: string;
+    };
+}
+/**
+ * Build a policy authority from an enrolled node receipt key. The encrypted
+ * envelope carries the receipt as evidence, but only the separately pinned
+ * key can make that evidence authoritative.
+ */
+declare function createRegisteredPolicyAuthority(options: RegisteredPolicyAuthorityOptions): SharePolicyAuthority;
+
+interface ShareCacheKey {
+    readonly cid: string;
+    readonly expiresAt: string;
+}
+interface ShareCacheMetadata {
+    readonly contentType: string;
+    readonly size: number;
+    readonly encrypted: boolean;
+}
+interface ShareCacheEntry {
+    readonly key: ShareCacheKey;
+    readonly bytes: Uint8Array;
+    readonly digest: Uint8Array;
+    readonly metadata: ShareCacheMetadata;
+}
+interface ShareCache {
+    get(key: ShareCacheKey, now?: Date): Promise<Uint8Array | undefined>;
+    /** Retrieve a valid entry without a process-local expiry index. */
+    getByCid?(cid: string, now?: Date): Promise<ShareCacheEntry | undefined>;
+    set(key: ShareCacheKey, bytes: Uint8Array, metadata: ShareCacheMetadata): Promise<void>;
+    delete(key: ShareCacheKey): Promise<void>;
+    clear(): Promise<void>;
+}
+/**
+ * A deliberately memory-only cache. It stores verified artifact bytes and
+ * non-secret metadata only; fragment keys, presentations, sessions, and
+ * decrypted content never cross this boundary.
+ */
+declare class MemoryShareCache implements ShareCache {
+    private readonly now;
+    private readonly entries;
+    constructor(now?: () => Date);
+    get(key: ShareCacheKey, now?: Date): Promise<Uint8Array | undefined>;
+    getByCid(cid: string, now?: Date): Promise<ShareCacheEntry | undefined>;
+    set(key: ShareCacheKey, bytes: Uint8Array, metadata: ShareCacheMetadata): Promise<void>;
+    delete(key: ShareCacheKey): Promise<void>;
+    clear(): Promise<void>;
+}
+
+/** Matches V2_DELIVERY_DOMAIN in tinycloud-node-server/src/share_v2.rs. */
+declare const SHARE_DELIVERY_AUTHORIZATION_DOMAIN = "xyz.tinycloud.share/delivery-authorization/v2\0";
+/** Exact camelCase mirror of the Rust `V2DeliveryRequest` wire struct. */
+interface ShareDeliveryAuthorizationRequest {
+    readonly envelopeCid: string;
+    readonly shareCid: string;
+    readonly shareId: string;
+    readonly registrationCid: string;
+    readonly policyCid: string;
+    readonly delegationCid: string;
+    readonly enforcementDelegationCid: string;
+    readonly recipientEmail: string;
+    readonly shareUrl: string;
+    readonly documentName: string;
+    readonly jti: string;
+    readonly idempotencyKey: string;
+    readonly expiresAt: string;
+    readonly requestBodyDigest: string;
+}
+/** Exact mirror of the `authorization` object the Node route signs and returns. */
+interface ShareDeliveryAuthorization {
+    readonly type: "TinyCloudShareDeliveryAuthorization";
+    readonly version: 2;
+    readonly jti: string;
+    readonly shareCid: string;
+    readonly shareId: string;
+    readonly registrationCid: string;
+    readonly delegationCid: string;
+    readonly enforcementDelegationCid: string;
+    readonly envelopeCid: string;
+    readonly policyCid: string;
+    readonly nodeAudience: string;
+    readonly targetOrigin: string;
+    /**
+     * The OpenCredentials witness this delivery is scoped to, sourced from
+     * Node's own trusted credentials origin. Deliberately distinct from
+     * `nodeAudience` (the node's own DID) and `returnOrigin` (Share's page
+     * origin) — conflating any of these three would let a party impersonate
+     * another's audience.
+     */
+    readonly openCredentialsAudience: string;
+    readonly holder: string;
+    readonly recipientMatcher: unknown;
+    readonly deliveryEmail: string;
+    readonly shareUrl: string;
+    readonly returnOrigin: string;
+    readonly documentName: string;
+    readonly senderDid: string;
+    readonly senderTrust: string;
+    readonly contentSource: unknown;
+    readonly contentSourceDigest: string;
+    readonly shareExpiresAt: string;
+    readonly issuedAt: string;
+    readonly reportAbuseToken: string;
+    readonly actions: readonly string[];
+    readonly resource: string;
+    readonly authorityMaterialHandle: string;
+    readonly authorityMaterialDigest: string;
+    readonly requestBodyDigest: string;
+    readonly idempotencyKey: string;
+    readonly expiresAt: string;
+    readonly dataAuthority: false;
+}
+interface ShareDeliveryAuthorizationReceipt {
+    readonly authorization: ShareDeliveryAuthorization;
+    readonly proof: {
+        readonly alg: "EdDSA";
+        readonly kid: string;
+        readonly signature: string;
+    };
+}
+interface ValidateShareDeliveryAuthorizationExpected {
+    readonly request: ShareDeliveryAuthorizationRequest;
+    /** The enrolled receipt key from the node trust bundle. */
+    readonly nodeProof: {
+        readonly kid: string;
+        readonly publicKey: Uint8Array;
+    };
+    /**
+     * The OpenCredentials witness origin the caller trusts, from the same
+     * trust bundle as `nodeProof`. Validated independently of the
+     * authorization's own `nodeAudience`/`returnOrigin` fields so a Node that
+     * mislabels or omits its credentials origin fails closed here rather than
+     * silently inheriting one of those unrelated identities.
+     */
+    readonly credentialsAudience: string;
+}
+/**
+ * Validate the exact UTF-8 response bytes emitted by
+ * `POST /share/v2/deliveries/authorize`, bind them to the submitted
+ * request, and verify the Node's detached EdDSA proof.
+ */
+declare function validateShareDeliveryAuthorizationBytes(bytesValue: Uint8Array, expected: ValidateShareDeliveryAuthorizationExpected): ShareDeliveryAuthorizationReceipt;
+/** Build the trusted-signer descriptor `did:key:...#z...` expects from a raw node signing key. */
+declare function shareDeliveryTrustedKid(publicKey: Uint8Array): string;
+
+interface EncryptedShareHistoryStorage {
+    put(value: Uint8Array): Promise<void>;
+    list(): Promise<readonly Uint8Array[]>;
+    clear(): Promise<void>;
+}
+declare class MemoryEncryptedShareHistoryStorage implements EncryptedShareHistoryStorage {
+    private readonly values;
+    put(value: Uint8Array): Promise<void>;
+    list(): Promise<readonly Uint8Array[]>;
+    clear(): Promise<void>;
+}
+/**
+ * The durable record a sender needs, after a reload, to display and manage
+ * a share it created. Every identity/CID here comes verbatim from the
+ * Node-verified {@link OwnerSharePolicyRegistrationReceipt}; nothing is
+ * re-derived or guessed.
+ */
+interface SenderShareRecord {
+    readonly shareId: string;
+    readonly registrationCid?: string;
+    readonly policyCid?: string;
+    readonly ownerDelegationCid?: string;
+    readonly enforcementDelegationCid?: string;
+    readonly shareKeyDid?: string;
+    readonly ownerDid?: string;
+    readonly enforcerDid?: string;
+    readonly target: {
+        readonly origin: string;
+        readonly nodeAudience: string;
+        readonly spaceId: string;
+    };
+    readonly resource: {
+        readonly kind: "exact" | "prefix";
+        readonly path: string;
+    };
+    readonly actions: readonly OwnerShareAction[];
+    readonly recipientMatcher: OwnerShareMatcher;
+    /** The signed target discriminator, retained separately from the email matcher. */
+    readonly targetKind?: "bearer" | "recipientDid" | "email" | "emailDomain";
+    readonly registeredAt: string;
+    readonly expiresAt: string;
+    readonly revokedAt?: string;
+    readonly envelopeCid?: string;
+    readonly shareCid?: string;
+    /** Complete bearer links are encrypted at rest and only revealed explicitly. */
+    readonly link?: string;
+    readonly filename?: string;
+}
+/** Create the durable encrypted-history shape from canonical publication receipts. */
+declare function historyRecordForPublishedShare(result: PublishedShare, now?: Date): SenderShareRecord;
+/**
+ * "direct" revokes only this share's enforcement delegation. "ancestor"
+ * revokes the owner delegation the share descends from, which transitively
+ * denies every share built on it (see `revocation_in_ancestry` in
+ * `tinycloud-node-server/src/share_v2.rs`). Both are existing CIDs that a
+ * caller passes to the node's generic `tinycloud.delegation/revoke`
+ * invocation (`DelegationManager.revoke` / `TinyCloudNode.revokeDelegation`)
+ * -- there is no share-v2-specific revoke route.
+ */
+type SenderShareRevocationScope = "direct" | "ancestor";
+interface SenderShareRecordStorage {
+    put(record: SenderShareRecord): Promise<void>;
+    list(): Promise<readonly SenderShareRecord[]>;
+    get(shareId: string): Promise<SenderShareRecord | undefined>;
+    delete(shareId: string): Promise<void>;
+}
+interface StoredSenderShareKey {
+    readonly cryptoKey: CryptoKey;
+    readonly publicKey: Uint8Array;
+    readonly extractable: boolean;
+}
+interface SenderShareKeyStorage {
+    put(shareId: string, key: StoredSenderShareKey): Promise<void>;
+    get(shareId: string): Promise<StoredSenderShareKey | undefined>;
+    delete(shareId: string): Promise<void>;
+}
+/** In-memory reference implementation. Real deployments back these with IndexedDB so the non-extractable `CryptoKey` survives a reload via structured clone. */
+declare class MemorySenderShareRecordStorage implements SenderShareRecordStorage {
+    private readonly records;
+    put(record: SenderShareRecord): Promise<void>;
+    list(): Promise<readonly SenderShareRecord[]>;
+    get(shareId: string): Promise<SenderShareRecord | undefined>;
+    delete(shareId: string): Promise<void>;
+}
+declare class MemorySenderShareKeyStorage implements SenderShareKeyStorage {
+    private readonly keys;
+    put(shareId: string, key: StoredSenderShareKey): Promise<void>;
+    get(shareId: string): Promise<StoredSenderShareKey | undefined>;
+    delete(shareId: string): Promise<void>;
+}
+interface SenderShareStoreOptions {
+    readonly records: SenderShareRecordStorage;
+    readonly keys: SenderShareKeyStorage;
+    readonly now?: () => Date;
+}
+/**
+ * Reload-safe sender-side management for shares created through
+ * {@link canonicalOwnerSharePolicy} / `registerOwnerSharePolicy`. Persists
+ * the registration receipt's canonical identity tuple plus the ephemeral
+ * share key's non-extractable `CryptoKey` handle, so a sender can list,
+ * inspect, and revoke shares it created in an earlier session -- without
+ * ever re-exporting private key material.
+ */
+declare class SenderShareStore {
+    private readonly records;
+    private readonly keys;
+    private readonly now;
+    constructor(options: SenderShareStoreOptions);
+    /** Persist a Node-verified registration receipt and its share key handle. */
+    save(receipt: OwnerSharePolicyRegistrationReceipt, key: DelegatedShareKey): Promise<SenderShareRecord>;
+    /** List shares created in any session, most recent first. */
+    list(options?: {
+        readonly includeRevoked?: boolean;
+        readonly includeExpired?: boolean;
+    }): Promise<readonly SenderShareRecord[]>;
+    get(shareId: string): Promise<SenderShareRecord | undefined>;
+    /** Recover a signer for the persisted share key after a reload. */
+    loadKey(shareId: string): Promise<DelegatedShareKey | undefined>;
+    /**
+     * The delegation CID to pass to the node's existing generic
+     * `tinycloud.delegation/revoke` invocation to revoke this share at the
+     * requested scope. Does not itself call the node -- callers invoke
+     * their own `revokeDelegation`/`DelegationManager.revoke` with the
+     * returned CID, then call {@link markRevoked} once that succeeds.
+     */
+    revocationTarget(shareId: string, scope: SenderShareRevocationScope): Promise<string>;
+    /** Mark a share revoked locally after the caller's node-side revoke call succeeds. */
+    markRevoked(shareId: string, revokedAt?: string): Promise<SenderShareRecord>;
+    /** Forget a share and clear its persisted key handle. */
+    remove(shareId: string): Promise<void>;
+}
+/** WebCrypto-backed persistence adapter; links and private material are absent. */
+declare class EncryptedSenderShareHistory {
+    private readonly storage;
+    private readonly key;
+    private readonly now;
+    constructor(storage: EncryptedShareHistoryStorage, key: CryptoKey, now?: () => Date);
+    put(record: SenderShareRecord): Promise<void>;
+    list(): Promise<readonly SenderShareRecord[]>;
+    clear(): Promise<void>;
+}
+
+type ShareNotifyState = "delivered" | "already-delivered" | "partial-failure";
+interface ShareNotifyResult {
+    readonly protocol: "tinycloud-share";
+    readonly version: 1;
+    readonly shareId: string;
+    readonly state: ShareNotifyState;
+    readonly idempotencyKey: string;
+    readonly attempts: number;
+    readonly retryable?: boolean;
+}
+interface ShareNotifyInput {
+    readonly shareId: string;
+    readonly recipient: string;
+    readonly record?: SenderShareRecord;
+    readonly idempotencyKey?: string;
+    readonly signal?: AbortSignal;
+}
+interface ShareDeliveryAdapter {
+    /** The server must deduplicate this key before any message is sent. */
+    deliver(input: ShareNotifyInput): Promise<"delivered" | "already-delivered">;
+}
+declare class ShareNotifyError extends Error {
+    readonly code: "delivery-failed";
+    constructor(message?: string);
+}
+/** Match a delivery address against the recipient constraint recorded when the share was created. */
+declare function recipientMatchesShareRecord(record: SenderShareRecord, recipient: string): boolean;
+/**
+ * Delivery is deliberately separate from publication. A failed notification
+ * never causes a second envelope or link to be minted.
+ */
+declare function notifyShare(input: {
+    readonly shareId: string;
+    readonly recipient: string;
+    readonly record?: SenderShareRecord;
+    readonly adapter: ShareDeliveryAdapter;
+    readonly idempotencyKey?: string;
+    readonly maxAttempts?: number;
+    readonly signal?: AbortSignal;
+}): Promise<ShareNotifyResult>;
+
+type ShareRevocationResult = {
+    readonly state: "revoked";
+    readonly target: "recipientDid" | "email" | "emailDomain";
+    readonly delegationCid: string;
+    readonly revokedAt: string;
+} | {
+    readonly state: "retention-only";
+    readonly target: "bearer";
+    readonly reason: "bearer-capability-cannot-be-revoked";
+} | {
+    readonly state: "unsupported";
+    readonly target: string;
+    readonly reason: string;
+    readonly code: "unsupported-target";
+};
+interface ShareRevocationAdapter {
+    revokeDelegation(input: {
+        readonly delegationCid: string;
+        readonly scope: "direct" | "ancestor";
+    }): Promise<void>;
+}
+/** Report retention for bearer shares; only node-enforced targets are revokeable. */
+declare function revokeShare(input: {
+    readonly record: SenderShareRecord;
+    /** Optional durable store; successful revocation is persisted before return. */
+    readonly records?: SenderShareRecordStorage;
+    readonly adapter?: ShareRevocationAdapter;
+    readonly scope?: "direct" | "ancestor";
+    readonly now?: () => Date;
+}): Promise<ShareRevocationResult>;
+interface ShareHistoryView {
+    readonly shareId: string;
+    readonly target: string;
+    readonly recipient?: string;
+    readonly expiresAt: string;
+    readonly revoked: boolean;
+    readonly link?: string;
+}
+declare function listShares(storage: SenderShareRecordStorage): Promise<readonly ShareHistoryView[]>;
+declare function showShare(input: {
+    readonly storage: SenderShareRecordStorage;
+    readonly shareId: string;
+    readonly revealLink?: boolean;
+    readonly link?: string;
+}): Promise<ShareHistoryView>;
+
+interface LegacyShareReader<T> {
+    read(link: string): Promise<T>;
+}
+interface LegacyMigrationResult<T> {
+    readonly protocol: "tinycloud-share";
+    readonly version: 1;
+    readonly legacy: true;
+    readonly migrated: PublishedShare;
+    readonly value: T;
+}
+declare function isLegacyShareLink(value: string): boolean;
+/** Modern commands never call this function implicitly. */
+declare function receiveLegacyShare<T>(link: string, reader: LegacyShareReader<T>): Promise<T>;
+/** Read tc1, then explicitly re-mint through the modern publisher. */
+declare function migrateShare<T>(input: {
+    readonly link: string;
+    readonly reader: LegacyShareReader<T>;
+    readonly publish: (value: T) => Promise<PublishedShare>;
+}): Promise<LegacyMigrationResult<T>>;
+
+interface ShareNodeTrust {
+    readonly invitationKid: string;
+    readonly invitationPublicKey: Uint8Array;
+}
+interface SharePresentationMaterial {
+    readonly holderDid: string;
+    readonly credential: string;
+    readonly credentialDigest?: string;
+    readonly holderBinding: Record<string, unknown>;
+    readonly proof: Record<string, unknown>;
+    readonly sign?: (bytes: Uint8Array) => Promise<Uint8Array>;
+    readonly email?: string;
+}
+interface SharePolicyChallenge {
+    readonly challengeId: string;
+    readonly nonce: string;
+    readonly expiresAt: string;
+    readonly enforcerDid?: string;
+    readonly action: string;
+    readonly requestBodyDigest: string;
+    readonly [key: string]: unknown;
+}
+interface ShareRecipientClientOptions {
+    readonly nodeOrigin: string;
+    readonly trustedNode: ShareNodeTrust;
+    readonly holderDid: string;
+    readonly envelope: ShareEnvelopeV2;
+    readonly fetchFn?: typeof fetch;
+    readonly buildPresentation?: (input: {
+        readonly challenge: SharePolicyChallenge;
+        readonly envelope: ShareEnvelopeV2;
+        readonly policy: Record<string, unknown>;
+    }) => Promise<SharePresentationMaterial>;
+    readonly sign?: (bytes: Uint8Array) => Promise<Uint8Array>;
+}
+interface SharePolicySession {
+    readonly sessionId: string;
+    readonly expiresAt: string;
+    readonly actions: readonly ("read" | "list" | "edit")[];
+    readonly resource: {
+        readonly kind: "exact" | "prefix";
+        readonly path: string;
+    };
+}
+declare class ShareRecipientClient {
+    private readonly options;
+    private readonly fetchFn;
+    private session;
+    private signer;
+    private holderProof;
+    constructor(options: ShareRecipientClientOptions);
+    beginChallenge(envelope: ShareEnvelopeV2): Promise<SharePolicyChallenge>;
+    private establish;
+    authorize(envelope: ShareEnvelopeV2): Promise<ShareAuthorizedContent>;
+    establishPolicySession(): Promise<SharePolicySession>;
+    resumeWithProof(envelope: ShareEnvelopeV2, resumeToken: string, proof: unknown): Promise<ShareAuthorizedContent>;
+    nativeInvoke(request: {
+        readonly action: string;
+        readonly resource?: Record<string, unknown>;
+        readonly body?: number[];
+        readonly bodyDigest?: number[];
+        readonly ifMatch?: string;
+        readonly contentType?: string;
+    }): Promise<Response>;
+}
+declare function createAddressedAuthorization(input: Omit<ShareRecipientClientOptions, "envelope">): ShareAuthorizationAdapter<ShareAuthorizedContent>;
+
+declare const SHARE_V2_PROTOCOL: Readonly<{
+    readonly challengeDomain: "xyz.tinycloud.share/policy-challenge/v2\0";
+    readonly sessionDomain: "xyz.tinycloud.share/policy-session/v2\0";
+    readonly invocationDomain: "xyz.tinycloud.share/invocation/v2\0";
+    readonly readResponseDomain: "xyz.tinycloud.share/read-response/v2\0";
+    readonly holderBindingDomain: "xyz.tinycloud.share/email-claim-holder-binding/v1\0";
+    readonly holderBindingName: "holderBinding";
+    readonly holderBindingType: "TinyCloudEmailClaimHolderBinding";
+    readonly holderBindingVersion: 1;
+}>;
+declare function createShareV2HolderBindingArtifact(input: {
+    readonly holderDid: string;
+    readonly message: Record<string, unknown>;
+    readonly sign: (bytes: Uint8Array) => Promise<Uint8Array>;
+}): Promise<Record<string, unknown>>;
+
+interface SharePolicyPublishAdapter<TPublishOutcome = TargetPublishOutcome> {
+    publishPolicy(input: TargetPublishInput & {
+        readonly notify: boolean;
+    }): Promise<TPublishOutcome>;
+    claim(input: {
+        readonly envelope: ShareEnvelopeV2;
+        readonly method: "email-claim" | "email-otp";
+        readonly resumeToken?: string;
+        readonly proof?: unknown;
+    }): Promise<ShareAuthorizationResult<unknown>>;
+}
+/** Canonical exact-email/domain publication seam shared by web and CLI. */
+declare function publishPolicyShare<TPublishOutcome = TargetPublishOutcome>(input: {
+    readonly source: Uint8Array;
+    readonly filename: string;
+    readonly target: Extract<ShareTarget, {
+        readonly kind: "email" | "emailDomain";
+    }>;
+    readonly expiresAt: Date;
+    readonly origin: string;
+    readonly notify?: boolean;
+    readonly adapter: SharePolicyPublishAdapter<TPublishOutcome>;
+}): Promise<TPublishOutcome>;
+/** Claim, OTP, or resume a policy share without exposing mailbox material. */
+declare function claimShare(input: {
+    readonly envelope: ShareEnvelopeV2;
+    readonly adapter: SharePolicyPublishAdapter;
+    readonly method?: "email-claim" | "email-otp";
+    readonly resumeToken?: string;
+    readonly proof?: unknown;
+}): Promise<ShareAuthorizationResult<unknown>>;
+/** Explicit name for noninteractive callers resuming a previously returned step. */
+declare function resumeShareAuthorization<T>(input: {
+    readonly envelope: ShareEnvelopeV2;
+    readonly method: "openkey-device" | "email-claim" | "email-otp";
+    readonly resumeToken: string;
+    readonly proof?: unknown;
+    readonly adapter: ShareAuthorizationAdapter<T>;
+}): Promise<ShareAuthorizationResult<T>>;
+
+export { type AddressedPublishAuthority, type AddressedSharePublishOptions, type CreateOwnerDelegationParams, DEFAULT_MAX_CONTENT_BLOB_BYTES, DEFAULT_MAX_SEALED_BLOB_BYTES, DEFAULT_SHARE_LIFETIME_MS, type DelegatedShareKey, EncryptedSenderShareHistory, type EncryptedShareHistoryStorage, type LegacyMigrationResult, type LegacyShareReader, MAX_CONTENT_BYTES, MemoryEncryptedShareHistoryStorage, MemorySenderShareKeyStorage, MemorySenderShareRecordStorage, MemoryShareCache, OWNER_SHARE_REGISTRATION_DOMAIN, type OwnerDelegationPermission, type OwnerDelegationReceipt, type OwnerShareAction, type OwnerShareDecryption, type OwnerShareMatcher, type OwnerSharePolicyRegistration, type OwnerSharePolicyRegistrationReceipt, type OwnerSharePolicyV2, type ParsedAddressedEnvelope, type PublishedShare, type PublishedShareMetadata, type RegisterOwnerSharePolicyParams, type RegisteredPolicyAuthorityOptions, SHARE_CONTENT_LIMIT, SHARE_DELIVERY_AUTHORIZATION_DOMAIN, SHARE_PUBLISH_RESULT_VERSION, SHARE_RESULT_VERSION, SHARE_SEALED_OVERHEAD, SHARE_V2_PROTOCOL, type SenderShareKeyStorage, type SenderShareRecord, type SenderShareRecordStorage, type SenderShareRevocationScope, SenderShareStore, type ShareAuthorizationAdapter, type ShareAuthorizationDenied, type ShareAuthorizationMethod, type ShareAuthorizationReady, type ShareAuthorizationRequired, type ShareAuthorizationResult, type ShareAuthorizedContent, type ShareCache, type ShareCacheEntry, type ShareCacheKey, type ShareCacheMetadata, type ShareDeliveryAdapter, type ShareDeliveryAuthorization, type ShareDeliveryAuthorizationReceipt, type ShareDeliveryAuthorizationRequest, type ShareErrorCode, type ShareErrorInfo, type ShareFetchOptions, type ShareHistoryView, type ShareInspection, type ShareMetadata, type ShareNodeTrust, ShareNotifyError, type ShareNotifyInput, type ShareNotifyResult, type ShareNotifyState, type SharePolicyAuthority, type SharePolicyChallenge, type SharePolicyEvidence, type SharePolicyPublishAdapter, type SharePolicySession, type SharePresentationMaterial, SharePublishError, type SharePublishErrorCode, type SharePublishOptions, type SharePublishTarget, type ShareReceiveAuthorizationRequired, ShareReceiveError, type ShareReceiveOutcome, type ShareReceiveResult, ShareRecipientClient, type ShareRecipientClientOptions, type ShareRevocationAdapter, type ShareRevocationResult, type ShareTarget, type ShareUpload, type ShareUploadAuthorization, type ShareUploadInput, type ShareUploadResult, type SignedDelegation, type TargetPublishAdapter, type TargetPublishInput, type TargetPublishOutcome, type ValidateShareDeliveryAuthorizationExpected, type VerifyBearerEnvelopeOptions, authorizationMethodForTarget, authorizeShare, canonicalOwnerSharePolicy, claimShare, computeOwnerShareRegistrationCid, createAddressedAuthorization, createDelegatedShareKey, createPolicyEnforcementDelegation, createRegisteredPolicyAuthority, createShareV2HolderBindingArtifact, historyRecordForPublishedShare, inspectShare, isLegacyShareLink, listShares, migrateShare, normalizeShareTarget, notifyShare, parseAddressedEnvelope, publishAddressedShare, publishPolicyShare, publishShare, publishTargetShare, receiveLegacyShare, receiveShare, recipientMatchesShareRecord, redactPublishedShare, restoreDelegatedShareKey, resumeShareAuthorization, revokeShare, shareDeliveryTrustedKid, showShare, targetAuthorizationMethod, toShareErrorInfo, validateOwnerSharePolicyRegistration, validateOwnerSharePolicyRegistrationBytes, validateShareDeliveryAuthorizationBytes, verifyBearerEnvelope };