payid 0.5.9 → 1.0.0

package/dist/chunk-X7NYQ47Y.js

@@ -0,0 +1,27 @@
+// src/decision-proof/hash.ts
+import { keccak256 } from "ethers";
+function stableStringify(obj) {
+  if (Array.isArray(obj)) {
+    return `[${obj.map(stableStringify).join(",")}]`;
+  }
+  if (obj && typeof obj === "object") {
+    return `{${Object.keys(obj).sort().map(
+      (k) => `"${k}":${stableStringify(obj[k])}`
+    ).join(",")}}`;
+  }
+  return JSON.stringify(obj);
+}
+function toUtf8Bytes(str) {
+  return new TextEncoder().encode(str);
+}
+function hashContext(context) {
+  return keccak256(toUtf8Bytes(stableStringify(context)));
+}
+function hashRuleSet(ruleConfig) {
+  return keccak256(toUtf8Bytes(stableStringify(ruleConfig)));
+}
+
+export {
+  hashContext,
+  hashRuleSet
+};

package/dist/chunk-XMUHMJRD.js

@@ -0,0 +1,30 @@
+import {
+  SESSION_POLICY_V2_TYPES,
+  buildSessionPolicyV2Domain,
+  createSessionPolicyPayload,
+  createSessionPolicyV2,
+  decodeSessionPolicy,
+  decodeSessionPolicyV2,
+  decodeSessionPolicyV2QR,
+  encodeSessionPolicyV2QR
+} from "./chunk-AUW7WDAB.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/sessionPolicy/index.ts
+var sessionPolicy_exports = {};
+__export(sessionPolicy_exports, {
+  SESSION_POLICY_V2_TYPES: () => SESSION_POLICY_V2_TYPES,
+  buildSessionPolicyV2Domain: () => buildSessionPolicyV2Domain,
+  createSessionPolicyPayload: () => createSessionPolicyPayload,
+  createSessionPolicyV2: () => createSessionPolicyV2,
+  decodeSessionPolicy: () => decodeSessionPolicy,
+  decodeSessionPolicyV2: () => decodeSessionPolicyV2,
+  decodeSessionPolicyV2QR: () => decodeSessionPolicyV2QR,
+  encodeSessionPolicyV2QR: () => encodeSessionPolicyV2QR
+});
+
+export {
+  sessionPolicy_exports
+};

package/dist/context/index.d.ts

@@ -1,3 +1,4 @@
-export { b as buildContextV2 } from '../index-BEvnPzzt.js';
+export { b as buildContextV2 } from '../index-Dm2VdDEB.js';
 import 'ethers';
-import 'payid-types';
+import '../context.v1-C1m-tz0o.js';
+import '../context.v2-DIzPotmW.js';

package/dist/context.v1-C1m-tz0o.d.ts

@@ -0,0 +1,39 @@
+interface RuleContext {
+    tx: {
+        sender?: string;
+        asset: string;
+        amount: string;
+        amountUsd?: string;
+        chainId: number;
+        receiver?: string;
+    };
+    payId?: {
+        id: string;
+        owner: string;
+    };
+    intent?: {
+        type: "QR" | "DIRECT" | "API";
+        expiresAt?: number;
+        nonce?: string;
+        issuer?: string;
+    };
+}
+interface TxContext {
+    sender: string;
+    receiver: string;
+    asset: string;
+    amount: string;
+    amountUsd?: string;
+    chainId: number;
+    memo?: string;
+}
+interface PayIdContext {
+    id: string;
+    owner: string;
+}
+interface ContextV1 {
+    tx: TxContext;
+    payId: PayIdContext;
+}
+
+export type { ContextV1 as C, PayIdContext as P, RuleContext as R, TxContext as T };

package/dist/context.v2-DIzPotmW.d.ts

@@ -0,0 +1,37 @@
+import { C as ContextV1 } from './context.v1-C1m-tz0o.js';
+
+interface Attestation {
+    issuer: string;
+    issuedAt: number;
+    expiresAt: number;
+    signature: string;
+}
+
+interface EnvContext {
+    timestamp: number;
+    proof: Attestation;
+}
+interface StateContext {
+    spentToday: string;
+    period: string;
+    proof: Attestation;
+}
+interface OracleContext {
+    [key: string]: string | number | Attestation;
+    proof: Attestation;
+}
+interface RiskContext {
+    score: number;
+    category: string;
+    proof: Attestation & {
+        modelHash: string;
+    };
+}
+interface ContextV2 extends ContextV1 {
+    env?: EnvContext;
+    state?: StateContext;
+    oracle?: OracleContext;
+    risk?: RiskContext;
+}
+
+export type { Attestation as A, ContextV2 as C, EnvContext as E, OracleContext as O, RiskContext as R, StateContext as S };

package/dist/core/client/index.d.ts

@@ -1,5 +1,6 @@
-export { c as createPayID } from '../../index-BPJ_oOfy.js';
-import 'payid-types';
+export { P as PayIDClient, c as createPayID, c as createPayIDClient } from '../../index-CsynGAGv.js';
+import '../../rule-a_5ed-93.js';
+import '../../context.v1-C1m-tz0o.js';
+import '../../types-i4eTkhWa.js';
 import 'ethers';
-import '../../types-B8pJQdMQ.js';
-import '../../types-BmMf7udp.js';
+import '../../types-D2o6XS7a.js';

package/dist/core/client/index.js

@@ -1,12 +1,16 @@
 import {
-  createPayID
-} from "../../chunk-ROBSNIIZ.js";
+  PayIDClient,
+  createPayIDClient
+} from "../../chunk-EZ3BGZ7G.js";
 import "../../chunk-GG34PNTF.js";
-import "../../chunk-MXKZJKXE.js";
+import "../../chunk-AUW7WDAB.js";
 import "../../chunk-6VPSJFO4.js";
-import "../../chunk-PAJYP7JI.js";
+import "../../chunk-HKHRYRD6.js";
+import "../../chunk-X7NYQ47Y.js";
 import "../../chunk-KDC67LIN.js";
 import "../../chunk-MLKGABMK.js";
 export {
-  createPayID
+  PayIDClient,
+  createPayIDClient as createPayID,
+  createPayIDClient
 };

package/dist/core/server/index.d.ts

@@ -1,4 +1,5 @@
-export { c as createPayID } from '../../index-C1DHMQA0.js';
+export { P as PayIDServer, c as createPayIDServer } from '../../index-DSxDlF9J.js';
 import 'ethers';
-import 'payid-types';
-import '../../types-B8pJQdMQ.js';
+import '../../rule-a_5ed-93.js';
+import '../../context.v1-C1m-tz0o.js';
+import '../../types-i4eTkhWa.js';

package/dist/core/server/index.js

@@ -1,9 +1,12 @@
 import {
-  createPayID
-} from "../../chunk-AYJYFAXJ.js";
-import "../../chunk-PAJYP7JI.js";
+  PayIDServer,
+  createPayIDServer
+} from "../../chunk-ESTGPUEQ.js";
+import "../../chunk-HKHRYRD6.js";
+import "../../chunk-X7NYQ47Y.js";
 import "../../chunk-KDC67LIN.js";
 import "../../chunk-MLKGABMK.js";
 export {
-  createPayID
+  PayIDServer,
+  createPayIDServer
 };

package/dist/{index-2JCvey4-.d.ts → index-CDnE3SGM.d.ts}

@@ -1,4 +1,4 @@
-import { EnvContext, OracleContext, RiskContext, StateContext, Attestation } from 'payid-types';
+import { E as EnvContext, O as OracleContext, R as RiskContext, S as StateContext, A as Attestation } from './context.v2-DIzPotmW.js';
 import { Wallet } from 'ethers';
 
 declare function issueEnvContext(wallet: Wallet): Promise<EnvContext>;
@@ -9,15 +9,30 @@ declare function issueRiskContext(wallet: Wallet, score: number, category: strin
 
 declare function issueStateContext(wallet: Wallet, spentToday: string, period: string): Promise<StateContext>;
 
+/**
+ * Issues token price context with USD equivalent calculation
+ *
+ * @param wallet - Signer wallet for attestation
+ * @param tokenPrice - Token price in USD (8 decimals, e.g., 100000000 = $1.00)
+ * @param tokenAmount - Raw token amount in token units
+ * @param tokenDecimals - Token decimals (e.g., 6 for USDC, 18 for ETH)
+ * @returns Token price context with attestation proof
+ */
+declare function issueTokenPriceContext(wallet: Wallet, tokenPrice: bigint, tokenAmount: bigint, tokenDecimals: number): Promise<{
+    amountUsd: string;
+    proof: Attestation;
+}>;
+
 declare function signAttestation(issuerWallet: Wallet, payload: object, ttlSeconds?: number): Promise<Attestation>;
 
 declare const index_issueEnvContext: typeof issueEnvContext;
 declare const index_issueOracleContext: typeof issueOracleContext;
 declare const index_issueRiskContext: typeof issueRiskContext;
 declare const index_issueStateContext: typeof issueStateContext;
+declare const index_issueTokenPriceContext: typeof issueTokenPriceContext;
 declare const index_signAttestation: typeof signAttestation;
 declare namespace index {
-  export { index_issueEnvContext as issueEnvContext, index_issueOracleContext as issueOracleContext, index_issueRiskContext as issueRiskContext, index_issueStateContext as issueStateContext, index_signAttestation as signAttestation };
+  export { index_issueEnvContext as issueEnvContext, index_issueOracleContext as issueOracleContext, index_issueRiskContext as issueRiskContext, index_issueStateContext as issueStateContext, index_issueTokenPriceContext as issueTokenPriceContext, index_signAttestation as signAttestation };
 }
 
-export { issueEnvContext as a, issueOracleContext as b, issueRiskContext as c, issueStateContext as d, index as i, signAttestation as s };
+export { issueEnvContext as a, issueOracleContext as b, issueRiskContext as c, issueStateContext as d, issueTokenPriceContext as e, index as i, signAttestation as s };

package/dist/index-CsynGAGv.d.ts

@@ -0,0 +1,53 @@
+import { b as RuleConfig } from './rule-a_5ed-93.js';
+import { R as RuleContext } from './context.v1-C1m-tz0o.js';
+import { R as ResolverOptions, e as RuleSource, c as RuleResult, a as DecisionProof } from './types-i4eTkhWa.js';
+import { ethers } from 'ethers';
+import { P as PayIDSessionPolicyPayloadV1, S as SessionPolicyV2 } from './types-D2o6XS7a.js';
+
+declare class PayIDClient {
+    private readonly debugTrace?;
+    private readonly wasm?;
+    private readonly resolverOptions?;
+    private readonly _ready;
+    constructor(debugTrace?: boolean | undefined, wasm?: Uint8Array | undefined, resolverOptions?: ResolverOptions | undefined);
+    ready(): Promise<void>;
+    evaluate(context: RuleContext, rule: RuleConfig | RuleSource): Promise<RuleResult>;
+    evaluateAndProve(params: {
+        context: RuleContext;
+        authorityRule: RuleConfig | RuleSource;
+        evaluationRule?: RuleConfig;
+        sessionPolicy?: PayIDSessionPolicyPayloadV1;
+        sessionPolicyV2?: SessionPolicyV2;
+        payId: string;
+        payer: string;
+        receiver: string;
+        asset: string;
+        amount: bigint;
+        signer: ethers.Signer;
+        verifyingContract: string;
+        ruleAuthority: string;
+        ruleSetHashOverride?: string;
+        ttlSeconds?: number;
+        chainId: number;
+        blockTimestamp: number;
+        attestationUIDs?: string[];
+    }): Promise<{
+        result: RuleResult;
+        proof: DecisionProof | null;
+    }>;
+}
+
+/** Browser/edge-safe factory for the `payid/client` sub-path import. */
+declare function createPayIDClient(params?: {
+    wasm?: Uint8Array;
+    debugTrace?: boolean;
+}): PayIDClient;
+
+type index_PayIDClient = PayIDClient;
+declare const index_PayIDClient: typeof PayIDClient;
+declare const index_createPayIDClient: typeof createPayIDClient;
+declare namespace index {
+  export { index_PayIDClient as PayIDClient, createPayIDClient as createPayID, index_createPayIDClient as createPayIDClient };
+}
+
+export { PayIDClient as P, createPayIDClient as c, index as i };

package/dist/{index-Dj9IEios.d.ts → index-CubM9whW.d.ts}

@@ -1,5 +1,4 @@
-import * as payid_types from 'payid-types';
-import { RuleConfig, AnyRule } from 'payid-types';
+import { b as RuleConfig, A as AnyRule } from './rule-a_5ed-93.js';
 
 /**
  * Combine an authoritative rule set with additional ephemeral rules
@@ -43,7 +42,7 @@ import { RuleConfig, AnyRule } from 'payid-types';
 declare function combineRules(defaultRuleSet: RuleConfig, sessionRule: any[]): {
     version: string;
     logic: "AND" | "OR";
-    rules: payid_types.AnyRule[];
+    rules: AnyRule[];
 };
 
 /**
@@ -64,19 +63,7 @@ declare function canonicalizeRuleSet(ruleSet: {
     rules: AnyRule[];
 };
 
-/**
- * Compute a deterministic hash of a canonicalized rule set.
- *
- * PENTING: Fungsi ini HARUS menggunakan stableStringify (bukan JSON.stringify)
- * agar menghasilkan hash yang sama dengan:
- * - register-combined-rule.ts (canonicalize + keccak256)
- * - decision-proof/hash.ts (hashRuleSet)
- * - CombinedRuleStorage.sol (ruleSetHash tersimpan on-chain)
- *
- * Menggunakan JSON.stringify biasa akan menghasilkan key order berbeda
- * → hash berbeda → getRuleByHash revert dengan RULE_NOT_ACTIVE.
- */
-declare function hashRuleSet(ruleSet: any): string;
+declare function hashRuleSet(ruleConfig: any): string;
 
 declare const index_canonicalizeRuleSet: typeof canonicalizeRuleSet;
 declare const index_combineRules: typeof combineRules;
@@ -85,4 +72,4 @@ declare namespace index {
   export { index_canonicalizeRuleSet as canonicalizeRuleSet, index_combineRules as combineRules, index_hashRuleSet as hashRuleSet };
 }
 
-export { canonicalizeRuleSet as a, combineRules as c, hashRuleSet as h, index as i };
+export { combineRules as a, canonicalizeRuleSet as c, hashRuleSet as h, index as i };

package/dist/{index-C1DHMQA0.d.ts → index-DSxDlF9J.d.ts}

@@ -1,6 +1,7 @@
 import { ethers } from 'ethers';
-import { RuleContext, RuleConfig, RuleResult } from 'payid-types';
-import { R as RuleSource, D as DecisionProof } from './types-B8pJQdMQ.js';
+import { b as RuleConfig } from './rule-a_5ed-93.js';
+import { R as RuleContext } from './context.v1-C1m-tz0o.js';
+import { R as ResolverOptions, e as RuleSource, c as RuleResult, a as DecisionProof } from './types-i4eTkhWa.js';
 
 interface UserOperation {
     sender: string;
@@ -16,6 +17,36 @@ interface UserOperation {
     signature: string;
 }
 
+interface ZGStorageConfig {
+    nodeUrl: string;
+    indexerUrl: string;
+    privateKey: string;
+}
+declare class ZGStorage {
+    private config;
+    private indexer;
+    constructor(config: ZGStorageConfig);
+    /**
+     * Uploads data to 0G Storage
+     * @param data The data to upload (string or object)
+     * @returns The Merkle root hash of the uploaded data
+     */
+    upload(data: any): Promise<string>;
+    /**
+     * Downloads data from 0G Storage
+     * @param rootHash The Merkle root hash
+     * @returns The downloaded data as string
+     */
+    download(rootHash: string): Promise<string>;
+}
+
+type zgStorage_ZGStorage = ZGStorage;
+declare const zgStorage_ZGStorage: typeof ZGStorage;
+type zgStorage_ZGStorageConfig = ZGStorageConfig;
+declare namespace zgStorage {
+  export { zgStorage_ZGStorage as ZGStorage, type zgStorage_ZGStorageConfig as ZGStorageConfig };
+}
+
 /**
  * @class PayIDServer
  * @description Server-side PayID engine.
@@ -49,7 +80,9 @@ declare class PayIDServer {
     private readonly trustedIssuers?;
     private readonly debugTrace?;
     private readonly wasm?;
-    constructor(signer: ethers.Signer, trustedIssuers?: Set<string> | undefined, debugTrace?: boolean | undefined, wasm?: Uint8Array | undefined);
+    private readonly storage?;
+    private readonly resolverOptions?;
+    constructor(signer: ethers.Signer, trustedIssuers?: Set<string> | undefined, debugTrace?: boolean | undefined, wasm?: Uint8Array | undefined, storage?: ZGStorage | undefined, resolverOptions?: ResolverOptions | undefined);
     evaluateAndProve(params: {
         context: RuleContext;
         authorityRule: RuleConfig | RuleSource;
@@ -76,79 +109,23 @@ declare class PayIDServer {
         targetContract: string;
         paymasterAndData?: string;
         attestationUIDs?: string[];
+        paymentType?: "eth" | "erc20";
     }): UserOperation;
 }
 
-/**
- * Create a PayID policy engine instance backed by a WASM rule evaluator.
- *
- * ## Responsibility
- *
- * - Holds the WASM binary used for rule execution
- * - Defines the trust boundary for context attestation verification
- * - Acts as the primary entry point for PayID rule evaluation
- *
- * ## Trust model
- *
- * - If `trustedIssuers` is provided, Context V2 attestation
- *   verification is ENFORCED.
- * - If `trustedIssuers` is omitted, the engine runs in
- *   legacy (Context V1) mode without cryptographic verification.
- *
- * ## Environment
- *
- * This class is safe to instantiate in:
- * - Browsers
- * - Mobile apps
- * - Edge runtimes
- * - Backend services
- *
- * @param wasm
- *   Compiled PayID WASM rule engine binary.
- *
- * @param signer
- *   Signer account
- *
- * @param debugTrace
- *   Optional flag to enable decision trace generation for debugging.
- *
- * @param trustedIssuers
- *   Optional set of trusted attestation issuer addresses.
- *
- *   When provided, Context V2 attestation verification is ENFORCED:
- *   - Only attestations issued by addresses in this set are accepted.
- *   - Missing, expired, or invalid attestations cause evaluation to fail.
- *
- *   When omitted, the engine runs in legacy (Context V1) mode
- *   without cryptographic verification.
- *
- *   ⚠️ Important:
- *   - Do NOT pass an empty Set.
- *     An empty set means "no issuer is trusted" and will
- *     cause all attestations to be rejected.
- *
- *   @example
- *   ```ts
- *   const trustedIssuers = new Set([
- *     TIME_ISSUER,
- *     STATE_ISSUER,
- *     ORACLE_ISSUER,
- *     RISK_ISSUER
- *   ]);
- *
- *   const payid = new PayID(wasmBinary, ethers.Signer,  debugTrace, trustedIssuers);
- *   ```
- */
-declare function createPayID(params: {
-    wasm?: Uint8Array;
+/** Server/backend factory for the `payid/server` sub-path import. */
+declare function createPayIDServer(params: {
     signer: ethers.Signer;
+    wasm?: Uint8Array;
     debugTrace?: boolean;
     trustedIssuers?: Set<string>;
 }): PayIDServer;
 
-declare const index_createPayID: typeof createPayID;
+type index_PayIDServer = PayIDServer;
+declare const index_PayIDServer: typeof PayIDServer;
+declare const index_createPayIDServer: typeof createPayIDServer;
 declare namespace index {
-  export { index_createPayID as createPayID };
+  export { index_PayIDServer as PayIDServer, index_createPayIDServer as createPayIDServer };
 }
 
-export { type UserOperation as U, createPayID as c, index as i };
+export { PayIDServer as P, type UserOperation as U, ZGStorage as Z, createPayIDServer as c, index as i, zgStorage as z };

package/dist/{index-BEvnPzzt.d.ts → index-Dm2VdDEB.d.ts}

@@ -1,5 +1,6 @@
 import { Wallet } from 'ethers';
-import { ContextV1, ContextV2 } from 'payid-types';
+import { C as ContextV1 } from './context.v1-C1m-tz0o.js';
+import { C as ContextV2 } from './context.v2-DIzPotmW.js';
 
 /**
  * Build an attested Context V2 object from a base execution context

package/dist/index-G_1SiZJo.d.ts

@@ -0,0 +1,104 @@
+import { TypedDataField, ethers } from 'ethers';
+import { b as RuleConfig } from './rule-a_5ed-93.js';
+import { P as PayIDSessionPolicyPayloadV1, S as SessionPolicyV2 } from './types-D2o6XS7a.js';
+
+/**
+ * @deprecated V1 session policies have no chain binding and are vulnerable to
+ * cross-chain signature replay attacks. Use createSessionPolicyV2 instead.
+ * This function now throws to prevent creation of new V1 policies.
+ */
+declare function createSessionPolicyPayload(_params: {
+    receiver: string;
+    rule: RuleConfig;
+    expiresAt: number;
+    signer: ethers.Signer;
+}): Promise<PayIDSessionPolicyPayloadV1>;
+
+declare const SESSION_POLICY_V2_TYPES: Record<string, TypedDataField[]>;
+/**
+ * Build EIP-712 domain untuk SessionPolicyV2.
+ * Bind ke chainId + verifyingContract — policy tidak bisa di-replay di chain lain.
+ */
+declare function buildSessionPolicyV2Domain(chainId: number, verifyingContract: string): {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+};
+/**
+ * Create and sign a Channel A Session Policy (V2).
+ *
+ * Receiver sign CONSTRAINTS — bukan transaksi spesifik.
+ * Receiver tidak perlu tahu siapa payer-nya saat membuat ini.
+ *
+ * Security model:
+ *   - Receiver sign constraints (rule, maxAmount, asset, expiry)
+ *   - Payer sign context transaksinya sendiri
+ *   - Chain enforce keduanya — tidak ada self-approval
+ *
+ * Perbedaan dari V1:
+ *   - Bind ke ruleSetHash on-chain   → payer tidak bisa swap rule
+ *   - Bind ke allowedAsset+maxAmount → payer tidak bisa exceed
+ *   - Bind ke chainId+verifyingContract (EIP-712) → anti cross-chain replay
+ *   - Signed via EIP-712 → human-readable di wallet UI
+ *
+ * @throws Jika maxAmount <= 0, expiresAt sudah lewat, atau address invalid
+ */
+declare function createSessionPolicyV2(params: {
+    receiver: string;
+    ruleSetHash: string;
+    ruleAuthority: string;
+    allowedAsset: string;
+    maxAmount: bigint;
+    expiresAt: number;
+    payId: string;
+    chainId: number;
+    verifyingContract: string;
+    signer: ethers.Signer;
+}): Promise<SessionPolicyV2>;
+
+/**
+ * Decode and verify a V1 session policy.
+ * @deprecated Use decodeSessionPolicyV2 for new implementations.
+ */
+declare function decodeSessionPolicy(sessionPolicy: PayIDSessionPolicyPayloadV1, now: number): RuleConfig;
+/**
+ * Verify and decode a Channel A SessionPolicyV2.
+ *
+ * Checks (in order):
+ *   1. version === "payid.session.policy.v2"
+ *   2. blockTimestamp < expiresAt  (belum expired)
+ *   3. EIP-712 signature valid dan recovered === receiver
+ *
+ * @param policy         - SessionPolicyV2 dari QR / URL
+ * @param blockTimestamp - Timestamp dari block, bukan Date.now()
+ * @returns policy yang terverifikasi (same object)
+ * @throws  INVALID_SESSION_POLICY_V2_VERSION | SESSION_POLICY_V2_EXPIRED | INVALID_SESSION_POLICY_V2_SIGNATURE
+ */
+declare function decodeSessionPolicyV2(policy: SessionPolicyV2, blockTimestamp: number): SessionPolicyV2;
+/**
+ * Encode SessionPolicyV2 ke QR / URL string.
+ * Format: "payid-v2:<base64url(JSON)>"
+ */
+declare function encodeSessionPolicyV2QR(policy: SessionPolicyV2): string;
+/**
+ * Decode QR / URL string ke SessionPolicyV2.
+ * @throws QR_FORMAT_UNKNOWN | QR_CORRUPT | SESSION_POLICY_V2_INVALID
+ */
+declare function decodeSessionPolicyV2QR(qrString: string): SessionPolicyV2;
+
+declare const index_PayIDSessionPolicyPayloadV1: typeof PayIDSessionPolicyPayloadV1;
+declare const index_SESSION_POLICY_V2_TYPES: typeof SESSION_POLICY_V2_TYPES;
+declare const index_SessionPolicyV2: typeof SessionPolicyV2;
+declare const index_buildSessionPolicyV2Domain: typeof buildSessionPolicyV2Domain;
+declare const index_createSessionPolicyPayload: typeof createSessionPolicyPayload;
+declare const index_createSessionPolicyV2: typeof createSessionPolicyV2;
+declare const index_decodeSessionPolicy: typeof decodeSessionPolicy;
+declare const index_decodeSessionPolicyV2: typeof decodeSessionPolicyV2;
+declare const index_decodeSessionPolicyV2QR: typeof decodeSessionPolicyV2QR;
+declare const index_encodeSessionPolicyV2QR: typeof encodeSessionPolicyV2QR;
+declare namespace index {
+  export { index_PayIDSessionPolicyPayloadV1 as PayIDSessionPolicyPayloadV1, index_SESSION_POLICY_V2_TYPES as SESSION_POLICY_V2_TYPES, index_SessionPolicyV2 as SessionPolicyV2, index_buildSessionPolicyV2Domain as buildSessionPolicyV2Domain, index_createSessionPolicyPayload as createSessionPolicyPayload, index_createSessionPolicyV2 as createSessionPolicyV2, index_decodeSessionPolicy as decodeSessionPolicy, index_decodeSessionPolicyV2 as decodeSessionPolicyV2, index_decodeSessionPolicyV2QR as decodeSessionPolicyV2QR, index_encodeSessionPolicyV2QR as encodeSessionPolicyV2QR };
+}
+
+export { SESSION_POLICY_V2_TYPES as S, createSessionPolicyV2 as a, buildSessionPolicyV2Domain as b, createSessionPolicyPayload as c, decodeSessionPolicy as d, decodeSessionPolicyV2 as e, decodeSessionPolicyV2QR as f, encodeSessionPolicyV2QR as g, index as i };