dataspace-client-sdk-node 0.2.2 → 0.2.3

package/dist/consent/pdfSignatureVerification.d.ts

@@ -1,18 +0,0 @@
-export interface PdfVerifySubmission {
-    pdf_buffer: Buffer;
-    content_type: string;
-}
-export interface PdfVerifyResult {
-    ok: boolean;
-    signer?: string;
-    signing_time?: string;
-    notes?: string[];
-}
-export interface PdfSignatureVerificationApi {
-    verifyPdfSignature(submission: PdfVerifySubmission): Promise<PdfVerifyResult>;
-}
-export declare class PdfSignatureVerificationHttpApi implements PdfSignatureVerificationApi {
-    private readonly endpoint;
-    constructor(endpoint: string);
-    verifyPdfSignature(submission: PdfVerifySubmission): Promise<PdfVerifyResult>;
-}

package/dist/consent/pdfSignatureVerification.js

@@ -1,23 +0,0 @@
-// pdfSignatureVerification.ts
-// Node.js SDK contract for PDF signature verification
-import fetch from 'node-fetch';
-export class PdfSignatureVerificationHttpApi {
-    endpoint;
-    constructor(endpoint) {
-        this.endpoint = endpoint;
-    }
-    async verifyPdfSignature(submission) {
-        const res = await fetch(this.endpoint, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/pdf' },
-            body: submission.pdf_buffer,
-        });
-        if (!res.ok)
-            throw new Error('PDF verification failed: ' + res.status);
-        return (await res.json());
-    }
-}
-// Usage (Node):
-// const api = new PdfSignatureVerificationHttpApi('https://api.example.com/verify-pdf');
-// const result = await api.verifyPdfSignature({ pdf_buffer, content_type: 'application/pdf' });
-// if (result.ok) { ... }

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-export * from './types.js';
-export * from './builders.js';
-export * from './vp-token.js';
-export * from './client.js';
-export * from './sdk/dataspace-wallet-sdk-node/index.js';

package/dist/index.js

@@ -1,9 +0,0 @@
-// TODO: AdapterCryptoSdkNode and other cryptography adapters should be re-exported here
-// to allow external consumers (tests, services) to import them from the SDK directly.
-// For now, consumers must import from gdc-common-utils-ts/adapters/node/crypto directly.
-// See subjectVaultPhoneResolution.test.ts for context and migration plan.
-export * from './types.js';
-export * from './builders.js';
-export * from './vp-token.js';
-export * from './client.js';
-export * from './sdk/dataspace-wallet-sdk-node/index.js';

package/dist/sdk/dataspace-wallet-sdk-node/MultiWalletClient.d.ts

@@ -1,9 +0,0 @@
-import type { WalletProvider } from './provider.js';
-import type { WalletContext } from './types.js';
-import { WalletClient } from './WalletClient.js';
-export declare class MultiWalletClient {
-    private readonly provider;
-    private readonly walletClients;
-    constructor(provider: WalletProvider);
-    forContext(context: WalletContext): WalletClient;
-}

package/dist/sdk/dataspace-wallet-sdk-node/MultiWalletClient.js

@@ -1,21 +0,0 @@
-import { WalletClient } from './WalletClient.js';
-function contextKey(context) {
-    return [context.tenantId, context.jurisdiction, context.sector, context.walletId ?? 'default'].join(':');
-}
-export class MultiWalletClient {
-    provider;
-    walletClients = new Map();
-    constructor(provider) {
-        this.provider = provider;
-    }
-    forContext(context) {
-        const key = contextKey(context);
-        const existing = this.walletClients.get(key);
-        if (existing) {
-            return existing;
-        }
-        const created = new WalletClient(this.provider, context);
-        this.walletClients.set(key, created);
-        return created;
-    }
-}

package/dist/sdk/dataspace-wallet-sdk-node/WalletClient.d.ts

@@ -1,26 +0,0 @@
-import type { WalletProvider } from './provider.js';
-import type { CompactJwsHeader, DecryptOptions, EncryptOptions, PublicJwk, SignOptions, VerifyOptions, WalletContext } from './types.js';
-export declare class WalletClient {
-    private readonly provider;
-    private readonly context;
-    constructor(provider: WalletProvider, context: WalletContext);
-    getPublicJwks(): Promise<PublicJwk[]>;
-    sign(payload: Uint8Array | string, options?: SignOptions): Promise<string>;
-    verify(payload: Uint8Array | string, signature: string, jwk: PublicJwk, options?: VerifyOptions): Promise<boolean>;
-    signCompactJws(params: {
-        header: CompactJwsHeader;
-        claims: Record<string, unknown>;
-    }): Promise<string>;
-    signDetachedJws(params: {
-        header: CompactJwsHeader;
-        payload: Uint8Array | string;
-    }): Promise<string>;
-    buildCompactJwe(params: {
-        plaintext: Uint8Array | string;
-        recipientJwk: PublicJwk;
-        contentType?: string;
-    }): Promise<string>;
-    decryptCompactJwe(jwe: string): Promise<Uint8Array>;
-    encrypt(plaintext: Uint8Array | string, recipientJwk: PublicJwk, options?: EncryptOptions): Promise<string>;
-    decrypt(ciphertext: string, options?: DecryptOptions): Promise<Uint8Array>;
-}

package/dist/sdk/dataspace-wallet-sdk-node/WalletClient.js

@@ -1,36 +0,0 @@
-// CompactJweHeader is used transitively through WalletProvider
-export class WalletClient {
-    provider;
-    context;
-    constructor(provider, context) {
-        this.provider = provider;
-        this.context = context;
-    }
-    getPublicJwks() {
-        return this.provider.getPublicJwks(this.context);
-    }
-    sign(payload, options) {
-        return this.provider.sign(payload, this.context, options);
-    }
-    verify(payload, signature, jwk, options) {
-        return this.provider.verify(payload, signature, jwk, options);
-    }
-    signCompactJws(params) {
-        return this.provider.signCompactJws(this.context, params);
-    }
-    signDetachedJws(params) {
-        return this.provider.signDetachedJws(this.context, params);
-    }
-    buildCompactJwe(params) {
-        return this.provider.buildCompactJwe(this.context, params);
-    }
-    decryptCompactJwe(jwe) {
-        return this.provider.decryptCompactJwe(jwe, this.context);
-    }
-    encrypt(plaintext, recipientJwk, options) {
-        return this.provider.encrypt(plaintext, recipientJwk, options);
-    }
-    decrypt(ciphertext, options) {
-        return this.provider.decrypt(ciphertext, this.context, options);
-    }
-}

package/dist/sdk/dataspace-wallet-sdk-node/index.d.ts

@@ -1,6 +0,0 @@
-export * from './types.js';
-export * from './provider.js';
-export * from './WalletClient.js';
-export * from './MultiWalletClient.js';
-export * from './providers/memory-provider.js';
-export * from './providers/seed-provider.js';

package/dist/sdk/dataspace-wallet-sdk-node/index.js

@@ -1,6 +0,0 @@
-export * from './types.js';
-export * from './provider.js';
-export * from './WalletClient.js';
-export * from './MultiWalletClient.js';
-export * from './providers/memory-provider.js';
-export * from './providers/seed-provider.js';

package/dist/sdk/dataspace-wallet-sdk-node/provider.d.ts

@@ -1,24 +0,0 @@
-import type { CompactJwsHeader, DecryptOptions, EncryptOptions, PublicJwk, SignOptions, VerifyOptions, WalletContext, WalletInitOptions, WalletProviderKind } from './types.js';
-export interface WalletProvider {
-    readonly kind: WalletProviderKind;
-    init?(options?: WalletInitOptions): Promise<void> | void;
-    getPublicJwks(context: WalletContext): Promise<PublicJwk[]>;
-    sign(payload: Uint8Array | string, context: WalletContext, options?: SignOptions): Promise<string>;
-    verify(payload: Uint8Array | string, signature: string, jwk: PublicJwk, options?: VerifyOptions): Promise<boolean>;
-    signCompactJws(context: WalletContext, params: {
-        header: CompactJwsHeader;
-        claims: Record<string, unknown>;
-    }): Promise<string>;
-    signDetachedJws(context: WalletContext, params: {
-        header: CompactJwsHeader;
-        payload: Uint8Array | string;
-    }): Promise<string>;
-    buildCompactJwe(context: WalletContext, params: {
-        plaintext: Uint8Array | string;
-        recipientJwk: PublicJwk;
-        contentType?: string;
-    }): Promise<string>;
-    decryptCompactJwe(jwe: string, context: WalletContext): Promise<Uint8Array>;
-    encrypt(plaintext: Uint8Array | string, recipientJwk: PublicJwk, options?: EncryptOptions): Promise<string>;
-    decrypt(ciphertext: string, context: WalletContext, options?: DecryptOptions): Promise<Uint8Array>;
-}

package/dist/sdk/dataspace-wallet-sdk-node/provider.js

@@ -1 +0,0 @@
-export {};

package/dist/sdk/dataspace-wallet-sdk-node/providers/memory-provider.d.ts

@@ -1,41 +0,0 @@
-import { type KeyObject } from 'node:crypto';
-import type { CompactJwsHeader, DecryptOptions, EncryptOptions, PrivateKeyRef, PublicJwk, SignOptions, VerifyOptions, WalletContext, WalletInitOptions, WalletProviderKind } from '../types.js';
-import type { WalletProvider } from '../provider.js';
-type StoredKeyPair = {
-    signingPublicJwk: PublicJwk;
-    signingPublicKey: KeyObject;
-    signingPrivateKey: KeyObject;
-    signingPrivateKeyRef: PrivateKeyRef;
-    encryptionPublicJwk: PublicJwk;
-    /** ML-KEM-768 secret key bytes (2400 bytes). Never exposed externally. */
-    mlKemSecretKeyBytes: Uint8Array;
-    encryptionPrivateKeyRef: PrivateKeyRef;
-};
-export declare class MemoryWalletProvider implements WalletProvider {
-    readonly kind: WalletProviderKind;
-    private readonly keysByContext;
-    init(options?: WalletInitOptions): void;
-    getPublicJwks(context: WalletContext): Promise<PublicJwk[]>;
-    sign(payload: Uint8Array | string, context: WalletContext, options?: SignOptions): Promise<string>;
-    verify(payload: Uint8Array | string, signature: string, jwk: PublicJwk, _options?: VerifyOptions): Promise<boolean>;
-    signCompactJws(context: WalletContext, params: {
-        header: CompactJwsHeader;
-        claims: Record<string, unknown>;
-    }): Promise<string>;
-    encrypt(plaintext: Uint8Array | string, recipientJwk: PublicJwk, options?: EncryptOptions): Promise<string>;
-    decrypt(ciphertext: string, context: WalletContext, options?: DecryptOptions): Promise<Uint8Array>;
-    protected ensureKeyPair(context: WalletContext): StoredKeyPair;
-    protected selectSigningKeyPair(context: WalletContext, keyId?: string): StoredKeyPair;
-    protected selectEncryptionKeyPair(context: WalletContext, keyId?: string): StoredKeyPair;
-    signDetachedJws(context: WalletContext, params: {
-        header: CompactJwsHeader;
-        payload: Uint8Array | string;
-    }): Promise<string>;
-    buildCompactJwe(context: WalletContext, params: {
-        plaintext: Uint8Array | string;
-        recipientJwk: PublicJwk;
-        contentType?: string;
-    }): Promise<string>;
-    decryptCompactJwe(jwe: string, context: WalletContext): Promise<Uint8Array>;
-}
-export {};

package/dist/sdk/dataspace-wallet-sdk-node/providers/memory-provider.js

@@ -1,216 +0,0 @@
-import { createCipheriv, createDecipheriv, createHash, createPublicKey, generateKeyPairSync, randomBytes, sign as cryptoSign, verify as cryptoVerify, } from 'node:crypto';
-import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';
-function contextKey(context) {
-    return [context.tenantId, context.jurisdiction, context.sector, context.walletId ?? 'default'].join(':');
-}
-function normalizeBytes(input) {
-    return typeof input === 'string' ? Buffer.from(input, 'utf8') : input;
-}
-function toBase64Url(buffer) {
-    return Buffer.from(buffer).toString('base64url');
-}
-function fromBase64Url(value) {
-    return Buffer.from(value, 'base64url');
-}
-function encodeJsonBase64Url(value) {
-    return toBase64Url(Buffer.from(JSON.stringify(value), 'utf8'));
-}
-function buildKid(context, jwk) {
-    const thumbprint = createHash('sha256')
-        .update(JSON.stringify({
-        crv: jwk.crv,
-        e: jwk.e,
-        kty: jwk.kty,
-        n: jwk.n,
-        x: jwk.x,
-        y: jwk.y,
-    }))
-        .digest('base64url')
-        .slice(0, 16);
-    return `wallet:${context.tenantId}:${context.jurisdiction}:${context.sector}:${thumbprint}`;
-}
-function buildPrivateKeyRef(kid, algorithm) {
-    return {
-        kid,
-        kind: 'managed',
-        algorithm,
-    };
-}
-function buildSigningKeyPair(context) {
-    const generated = generateKeyPairSync('ec', {
-        namedCurve: 'secp384r1',
-    });
-    const publicJwk = generated.publicKey.export({ format: 'jwk' });
-    const kid = buildKid(context, publicJwk);
-    const normalizedPublicJwk = {
-        ...publicJwk,
-        kid,
-        alg: 'ES384',
-        use: 'sig',
-        key_ops: ['verify'],
-    };
-    return {
-        publicJwk: normalizedPublicJwk,
-        publicKey: createPublicKey({ key: normalizedPublicJwk, format: 'jwk' }),
-        privateKey: generated.privateKey,
-        privateKeyRef: buildPrivateKeyRef(kid, 'ES384'),
-    };
-}
-/** Generate a ML-KEM-768 key pair for content-key encapsulation (JWE `encrypted_key`). */
-function buildMlKemEncryptionKeyPair(context) {
-    const seed = randomBytes(64);
-    const { publicKey: publicKeyBytes, secretKey: secretKeyBytes } = ml_kem768.keygen(seed);
-    const x = toBase64Url(publicKeyBytes);
-    const kid = createHash('sha256')
-        .update(JSON.stringify({ crv: 'ML-KEM-768', kty: 'OKP', x }))
-        .digest('base64url')
-        .slice(0, 16);
-    const fullKid = `wallet:${context.tenantId}:${context.jurisdiction}:${context.sector}:${kid}`;
-    const publicJwk = {
-        kty: 'OKP',
-        crv: 'ML-KEM-768',
-        x,
-        kid: fullKid,
-        alg: 'ML-KEM-768',
-        use: 'enc',
-        key_ops: ['wrapKey'],
-    };
-    return {
-        publicJwk,
-        secretKeyBytes,
-        privateKeyRef: buildPrivateKeyRef(fullKid, 'ML-KEM-768'),
-    };
-}
-export class MemoryWalletProvider {
-    kind = 'mem';
-    keysByContext = new Map();
-    init(options) {
-        for (const context of options?.contexts ?? []) {
-            this.ensureKeyPair(context);
-        }
-    }
-    async getPublicJwks(context) {
-        const pair = this.ensureKeyPair(context);
-        return [pair.signingPublicJwk, pair.encryptionPublicJwk];
-    }
-    async sign(payload, context, options) {
-        const pair = this.selectSigningKeyPair(context, options?.keyId);
-        const signature = cryptoSign('sha384', normalizeBytes(payload), pair.signingPrivateKey);
-        return toBase64Url(signature);
-    }
-    async verify(payload, signature, jwk, _options) {
-        const publicKey = createPublicKey({ key: jwk, format: 'jwk' });
-        return cryptoVerify('sha384', normalizeBytes(payload), publicKey, fromBase64Url(signature));
-    }
-    async signCompactJws(context, params) {
-        const pair = this.selectSigningKeyPair(context, params.header.kid);
-        const header = {
-            ...params.header,
-            alg: params.header.alg || 'ES384',
-            kid: params.header.kid || pair.signingPublicJwk.kid,
-        };
-        const signingInput = `${encodeJsonBase64Url(header)}.${encodeJsonBase64Url(params.claims)}`;
-        const signature = cryptoSign('sha384', Buffer.from(signingInput, 'ascii'), pair.signingPrivateKey);
-        return `${signingInput}.${toBase64Url(signature)}`;
-    }
-    async encrypt(plaintext, recipientJwk, options) {
-        // Delegate to buildCompactJwe; returns a compact JWE string.
-        return this.buildCompactJwe(undefined, {
-            plaintext,
-            recipientJwk,
-        });
-    }
-    async decrypt(ciphertext, context, options) {
-        // ciphertext is a compact JWE produced by encrypt / buildCompactJwe.
-        return this.decryptCompactJwe(ciphertext, context);
-    }
-    ensureKeyPair(context) {
-        const key = contextKey(context);
-        const existing = this.keysByContext.get(key);
-        if (existing) {
-            return existing;
-        }
-        const signingKeyPair = buildSigningKeyPair(context);
-        const encryptionKeyPair = buildMlKemEncryptionKeyPair(context);
-        const pair = {
-            signingPublicJwk: signingKeyPair.publicJwk,
-            signingPublicKey: signingKeyPair.publicKey,
-            signingPrivateKey: signingKeyPair.privateKey,
-            signingPrivateKeyRef: signingKeyPair.privateKeyRef,
-            encryptionPublicJwk: encryptionKeyPair.publicJwk,
-            mlKemSecretKeyBytes: encryptionKeyPair.secretKeyBytes,
-            encryptionPrivateKeyRef: encryptionKeyPair.privateKeyRef,
-        };
-        this.keysByContext.set(key, pair);
-        return pair;
-    }
-    selectSigningKeyPair(context, keyId) {
-        const pair = this.ensureKeyPair(context);
-        if (keyId && pair.signingPrivateKeyRef.kid !== keyId) {
-            throw new Error(`Wallet key not found for kid: ${keyId}`);
-        }
-        return pair;
-    }
-    selectEncryptionKeyPair(context, keyId) {
-        const pair = this.ensureKeyPair(context);
-        if (keyId && pair.encryptionPrivateKeyRef.kid !== keyId) {
-            throw new Error(`Wallet key not found for kid: ${keyId}`);
-        }
-        return pair;
-    }
-    async signDetachedJws(context, params) {
-        const pair = this.selectSigningKeyPair(context, params.header.kid);
-        const header = {
-            ...params.header,
-            alg: params.header.alg || 'ES384',
-            kid: params.header.kid || pair.signingPublicJwk.kid,
-            b64: false,
-            crit: ['b64'],
-        };
-        const payloadBytes = normalizeBytes(params.payload);
-        const encodedHeader = encodeJsonBase64Url(header);
-        const signingInput = Buffer.concat([Buffer.from(`${encodedHeader}.`, 'ascii'), payloadBytes]);
-        const signature = cryptoSign('sha384', signingInput, pair.signingPrivateKey);
-        return `${encodedHeader}..${toBase64Url(signature)}`;
-    }
-    async buildCompactJwe(context, params) {
-        const kid = params.recipientJwk.kid;
-        const header = {
-            alg: 'ML-KEM-768',
-            enc: 'A256GCM',
-            ...(params.contentType ? { cty: params.contentType } : {}),
-            ...(kid ? { kid } : {}),
-        };
-        const encodedHeader = encodeJsonBase64Url(header);
-        // ML-KEM-768: encapsulate derives a 32-byte CEK and produces a cipherText (1088 bytes)
-        // that the recipient can decapsulate with their secret key.
-        const publicKeyBytes = fromBase64Url(params.recipientJwk.x);
-        const { cipherText: encapsulatedKey, sharedSecret: cek } = ml_kem768.encapsulate(publicKeyBytes);
-        const iv = randomBytes(12);
-        const cipher = createCipheriv('aes-256-gcm', cek, iv);
-        cipher.setAAD(Buffer.from(encodedHeader, 'ascii'));
-        const ciphertext = Buffer.concat([cipher.update(normalizeBytes(params.plaintext)), cipher.final()]);
-        const authTag = cipher.getAuthTag();
-        return [
-            encodedHeader,
-            toBase64Url(encapsulatedKey),
-            toBase64Url(iv),
-            toBase64Url(ciphertext),
-            toBase64Url(authTag),
-        ].join('.');
-    }
-    async decryptCompactJwe(jwe, context) {
-        const parts = jwe.split('.');
-        if (parts.length !== 5) {
-            throw new Error('Invalid compact JWE: expected 5 parts.');
-        }
-        const [encodedHeader, encapsulatedKeyB64, ivB64, ciphertextB64, tagB64] = parts;
-        const pair = this.selectEncryptionKeyPair(context);
-        // Recover CEK by decapsulating the ML-KEM ciphertext with the secret key.
-        const cek = ml_kem768.decapsulate(fromBase64Url(encapsulatedKeyB64), pair.mlKemSecretKeyBytes);
-        const decipher = createDecipheriv('aes-256-gcm', cek, fromBase64Url(ivB64));
-        decipher.setAAD(Buffer.from(encodedHeader, 'ascii'));
-        decipher.setAuthTag(fromBase64Url(tagB64));
-        return Buffer.concat([decipher.update(fromBase64Url(ciphertextB64)), decipher.final()]);
-    }
-}

package/dist/sdk/dataspace-wallet-sdk-node/providers/seed-provider.d.ts

@@ -1,22 +0,0 @@
-import type { WalletContext } from '../types.js';
-import { MemoryWalletProvider } from './memory-provider.js';
-/**
- * Dev-only provider.
- *
- * It stabilizes wallet identity selection from a seed, but it is not intended
- * for production custody or HSM-backed key management.
- */
-export declare class SeedWalletProvider extends MemoryWalletProvider {
-    private readonly seed;
-    readonly kind: "seed";
-    constructor(seed: string);
-    protected ensureKeyPair(context: WalletContext): {
-        signingPublicJwk: import("../types.js").PublicJwk;
-        signingPublicKey: import("node:crypto").KeyObject;
-        signingPrivateKey: import("node:crypto").KeyObject;
-        signingPrivateKeyRef: import("../types.js").PrivateKeyRef;
-        encryptionPublicJwk: import("../types.js").PublicJwk;
-        mlKemSecretKeyBytes: Uint8Array;
-        encryptionPrivateKeyRef: import("../types.js").PrivateKeyRef;
-    };
-}

package/dist/sdk/dataspace-wallet-sdk-node/providers/seed-provider.js

@@ -1,28 +0,0 @@
-import { createHash } from 'node:crypto';
-import { MemoryWalletProvider } from './memory-provider.js';
-function stableWalletId(seed, context) {
-    return createHash('sha256')
-        .update(`${seed}:${context.tenantId}:${context.jurisdiction}:${context.sector}:${context.walletId ?? 'default'}`)
-        .digest('base64url')
-        .slice(0, 24);
-}
-/**
- * Dev-only provider.
- *
- * It stabilizes wallet identity selection from a seed, but it is not intended
- * for production custody or HSM-backed key management.
- */
-export class SeedWalletProvider extends MemoryWalletProvider {
-    seed;
-    kind = 'seed';
-    constructor(seed) {
-        super();
-        this.seed = seed;
-    }
-    ensureKeyPair(context) {
-        return super.ensureKeyPair({
-            ...context,
-            walletId: stableWalletId(this.seed, context),
-        });
-    }
-}

package/dist/sdk/dataspace-wallet-sdk-node/types.d.ts

@@ -1,51 +0,0 @@
-export type WalletContext = {
-    tenantId: string;
-    jurisdiction: string;
-    sector: string;
-    walletId?: string;
-};
-export type PublicJwk = JsonWebKey & {
-    kid?: string;
-    alg?: string;
-    use?: string;
-    key_ops?: string[];
-};
-export type PrivateKeyRef = {
-    kid: string;
-    kind: 'managed';
-    algorithm: 'ES384' | 'ML-KEM-768' | 'RSA-OAEP-256/RS256';
-};
-export type SignOptions = {
-    keyId?: string;
-    algorithm?: 'ES384' | 'RS256';
-};
-export type VerifyOptions = {
-    algorithm?: 'ES384' | 'RS256';
-};
-export type EncryptOptions = {
-    keyId?: string;
-    /** Defaults to ML-KEM-768 when recipient JWK has kty:'OKP', crv:'ML-KEM-768'; falls back to RSA-OAEP-256 for legacy RSA JWKs. */
-    algorithm?: 'ML-KEM-768' | 'RSA-OAEP-256';
-};
-export type DecryptOptions = {
-    keyId?: string;
-    algorithm?: 'RSA-OAEP-256';
-};
-export type WalletProviderKind = 'mem' | 'seed' | 'external';
-export type WalletInitOptions = {
-    contexts?: WalletContext[];
-};
-export type CompactJwsHeader = {
-    alg: string;
-    typ?: string;
-    kid?: string;
-    [key: string]: unknown;
-};
-export type CompactJweHeader = {
-    /** KEM algorithm. ML-KEM-768 (post-quantum) or RSA-OAEP-256 (legacy). */
-    alg: 'ML-KEM-768' | 'RSA-OAEP-256' | string;
-    enc: 'A256GCM' | 'A128GCM' | string;
-    cty?: string;
-    kid?: string;
-    [key: string]: unknown;
-};

package/dist/sdk/dataspace-wallet-sdk-node/types.js

@@ -1 +0,0 @@
-export {};