@cashie/core-lib 1.0.0

package/dist/data/cashieDataUrl.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Decode `tokenURI` / `badgeUri` payloads produced by on-chain
+ * `TokenMetadataEncoderLib` (`MetadataEncodingPrimitives.JSON_DATA_URI_BASE64_PREFIX`).
+ *
+ * Validation uses Zod schemas in `./types.js`. Parsed identity fields align with
+ * **`IdentityType`** / **`BurnAuth`** from `identity/types.ts`.
+ *
+ * Pair **`parseCashieReceiptBadgeMetadataFromBadgeUri`** / **`parseCashiePaymentRecordBadgeMetadataFromBadgeUri`**
+ * with **`IERC5114.metadataFormat()`** once the badge is minted on-chain.
+ */
+import { type CashieIdentitySoulTokenMetadata, type CashiePaymentRecordBadgeMetadata, type CashieReceiptBadgeMetadata, type ParsedCashieMetadata } from './types.js';
+/**
+ * Strips {@link CASHIE_JSON_DATA_URI_BASE64_PREFIX} and returns the UTF-8 JSON string inside.
+ *
+ * @param dataUri The data URI to decode
+ * @returns The UTF-8 JSON string
+ */
+export declare function decodeCashieJsonDataUriToUtf8(dataUri: string): string;
+/**
+ * Strips {@link CASHIE_SVG_DATA_URI_BASE64_PREFIX} and returns the UTF-8 SVG markup inside.
+ *
+ * @param dataUri The SVG data URI to decode
+ * @returns The UTF-8 SVG markup string
+ */
+export declare function decodeCashieSvgDataUriToUtf8(dataUri: string): string;
+/**
+ * Decodes the URI and parses JSON (untyped).
+ *
+ * @param dataUri The data URI to parse
+ * @returns The parsed JSON
+ */
+export declare function parseCashieJsonDataUriJson(dataUri: string): unknown;
+/**
+ * Parses `CashieIdentitySoul.tokenURI` metadata (`IdentitySoulMetadataEncoderLib`).
+ *
+ * @param dataUri The data URI to parse
+ * @returns The parsed identity soul metadata
+ */
+export declare function parseCashieIdentitySoulTokenMetadata(dataUri: string): CashieIdentitySoulTokenMetadata;
+/**
+ * Parses `CashieReceiptBadge.badgeUri` metadata (`ReceiptBadgeMetadataEncoderLib`).
+ *
+ * @param dataUri The data URI to parse
+ * @returns The parsed receipt badge metadata
+ */
+export declare function parseCashieReceiptBadgeMetadata(dataUri: string): CashieReceiptBadgeMetadata;
+/**
+ * Same as {@link parseCashieReceiptBadgeMetadata}, but enforces that
+ * `IERC5114.metadataFormat()` matches {@link CASHIE_RECEIPT_BADGE_METADATA_FORMAT}.
+ *
+ * @param badgeUri The badge URI to parse
+ * @param metadataFormatFromContract The metadata format from the contract
+ * @returns The parsed receipt badge metadata
+ */
+export declare function parseCashieReceiptBadgeMetadataFromBadgeUri(badgeUri: string, metadataFormatFromContract: string): CashieReceiptBadgeMetadata;
+/**
+ * Parses `CashiePaymentRecordBadge.badgeUri` metadata (`PaymentRecordBadgeMetadataEncoderLib`).
+ *
+ * @param dataUri The data URI to parse
+ * @returns The parsed payment record badge metadata
+ */
+export declare function parseCashiePaymentRecordBadgeMetadata(dataUri: string): CashiePaymentRecordBadgeMetadata;
+/**
+ * Same as {@link parseCashiePaymentRecordBadgeMetadata}, but enforces that
+ * `IERC5114.metadataFormat()` matches {@link CASHIE_PAYMENT_RECORD_BADGE_METADATA_FORMAT}.
+ *
+ * @param badgeUri The badge URI to parse
+ * @param metadataFormatFromContract The metadata format from the contract
+ * @returns The parsed payment record badge metadata
+ */
+export declare function parseCashiePaymentRecordBadgeMetadataFromBadgeUri(badgeUri: string, metadataFormatFromContract: string): CashiePaymentRecordBadgeMetadata;
+/**
+ * Dispatches on JSON shape: **`identityType`** ⇒ identity soul; **`receiptType`** ⇒ receipt badge;
+ * **`receiptBadgeId`** (without **`receiptType`**) ⇒ payment record badge.
+ *
+ * @param dataUri The data URI to parse
+ * @returns The parsed metadata
+ */
+export declare function parseCashieMetadataDataUri(dataUri: string): ParsedCashieMetadata;

package/dist/data/encoder.d.ts

@@ -0,0 +1,130 @@
+import type { Address, Hex } from 'viem';
+import type { PaymentIntent } from '../intent/types.js';
+/**
+ * Mirrors on-chain `ReceiptType`
+ */
+export declare const ReceiptType: {
+    readonly OneTime: 0;
+    readonly Recurring: 1;
+};
+export type ReceiptType = (typeof ReceiptType)[keyof typeof ReceiptType];
+/**
+ * Fields ABI-encoded in the same order as `ReceiptBadgeEncoderLib.encodeMintPayload`
+ * (`packages/contracts/src/identity/libraries/ReceiptBadgeEncoderLib.sol`).
+ */
+export type ReceiptBadgeMintPayload = {
+    soulBoundTo: {
+        identityContract: Address;
+        tokenId: bigint;
+    };
+    receiptType: ReceiptType;
+    blockNumber: bigint;
+    recipient: Address;
+    chainId: bigint;
+    tokenAddress: Address;
+    allowance: bigint;
+    /** `bytes32` salt (`0x` + 64 hex chars). */
+    salt: Hex;
+};
+/**
+ * Canonical `abi.encode` of `ReceiptBadgeMintPayload` (matches Solidity `ReceiptBadgeEncoderLib.encodeMintPayload`).
+ *
+ * @param payload Mint tuple fields in router/storage shape
+ * @returns ABI-encoded bytes as hex
+ */
+export declare function encodeReceiptBadgeMintPayload(payload: ReceiptBadgeMintPayload): Hex;
+/**
+ * `keccak256(encodeReceiptBadgeMintPayload(payload))` — matches `ReceiptBadgeEncoderLib.getMintPayloadHash`.
+ * On-chain `badgeId == uint256(bytes32 digest)`.
+ *
+ * @param payload Mint tuple fields in router/storage shape
+ * @returns 32-byte digest (`0x…`)
+ */
+export declare function getReceiptBadgeMintPayloadHash(payload: ReceiptBadgeMintPayload): Hex;
+/**
+ * Deterministic ERC-5114 badge id: `uint256(getReceiptBadgeMintPayloadHash(payload))`.
+ *
+ * @param payload Mint tuple fields in router/storage shape
+ * @returns Badge id as bigint
+ */
+export declare function receiptBadgeIdFromMintPayload(payload: ReceiptBadgeMintPayload): bigint;
+/**
+ * Maps a {@link PaymentIntent} to {@link ReceiptBadgeMintPayload} (matches `TokenDistributor._issueReceiptBadge`).
+ *
+ * @param identityContract `CashieIdentitySoul` address bound in `soulBoundTo`
+ * @param paymentIntent Payment fields and mint salt
+ * @param blockNumber Execution block (`block.number` at mint)
+ * @param receiptType Receipt badge type from `ReceiptBadgeRouterMintPayload`
+ * @returns Receipt badge mint tuple in router/storage shape
+ */
+export declare function receiptBadgeMintPayloadFromPaymentIntent(identityContract: Address, paymentIntent: PaymentIntent, blockNumber: bigint, receiptType: ReceiptType): ReceiptBadgeMintPayload;
+/**
+ * Deterministic receipt badge id for a payment intent (matches on-chain `CashieReceiptBadge.mint`).
+ *
+ * @param identityContract `CashieIdentitySoul` address
+ * @param paymentIntent Payment fields and mint salt
+ * @param blockNumber Execution block (`block.number` at mint)
+ * @param receiptType Receipt badge type from `ReceiptBadgeRouterMintPayload`
+ * @returns Deterministic receipt badge id
+ */
+export declare function receiptBadgeIdFromPaymentIntent(identityContract: Address, paymentIntent: PaymentIntent, blockNumber: bigint, receiptType: ReceiptType): bigint;
+/**
+ * Fields ABI-encoded in the same order as `PaymentRecordBadgeEncoderLib.encodeMintPayload`
+ * (`packages/contracts/src/identity/libraries/PaymentRecordBadgeEncoderLib.sol`).
+ */
+export type PaymentRecordBadgeMintPayload = {
+    soulBoundTo: {
+        identityContract: Address;
+        tokenId: bigint;
+    };
+    blockNumber: bigint;
+    payer: Address;
+    chainId: bigint;
+    tokenAddress: Address;
+    allowance: bigint;
+    receiptBadgeId: bigint;
+    /** `bytes32` salt (`0x` + 64 hex chars). */
+    salt: Hex;
+};
+/**
+ * Canonical `abi.encode` of `PaymentRecordBadgeMintPayload` (matches Solidity `PaymentRecordBadgeEncoderLib.encodeMintPayload`).
+ *
+ * @param payload Mint tuple fields in router/storage shape
+ * @returns ABI-encoded bytes as hex
+ */
+export declare function encodePaymentRecordBadgeMintPayload(payload: PaymentRecordBadgeMintPayload): Hex;
+/**
+ * `keccak256(encodePaymentRecordBadgeMintPayload(payload))` — matches `PaymentRecordBadgeEncoderLib.getMintPayloadHash`.
+ * On-chain `badgeId == uint256(bytes32 digest)`.
+ *
+ * @param payload Mint tuple fields in router/storage shape
+ * @returns 32-byte digest (`0x…`)
+ */
+export declare function getPaymentRecordBadgeMintPayloadHash(payload: PaymentRecordBadgeMintPayload): Hex;
+/**
+ * Deterministic ERC-5114 badge id: `uint256(getPaymentRecordBadgeMintPayloadHash(payload))`.
+ *
+ * @param payload Mint tuple fields in router/storage shape
+ * @returns Badge id as bigint
+ */
+export declare function paymentRecordBadgeIdFromMintPayload(payload: PaymentRecordBadgeMintPayload): bigint;
+/**
+ * Maps a {@link PaymentIntent} to {@link PaymentRecordBadgeMintPayload} (matches `TokenDistributor._issuePaymentRecordBadge`).
+ *
+ * @param identityContract `CashieIdentitySoul` address bound in `soulBoundTo`
+ * @param paymentIntent Payment fields and mint salt
+ * @param blockNumber Execution block (`block.number` at mint)
+ * @param receiptBadgeId Linked receipt badge id from the same payment
+ * @returns Payment record badge mint tuple in router/storage shape
+ */
+export declare function paymentRecordBadgeMintPayloadFromPaymentIntent(identityContract: Address, paymentIntent: PaymentIntent, blockNumber: bigint, receiptBadgeId: bigint): PaymentRecordBadgeMintPayload;
+/**
+ * Deterministic payment record badge id for a payment intent (matches on-chain `CashiePaymentRecordBadge.mint`).
+ *
+ * @param identityContract `CashieIdentitySoul` address
+ * @param paymentIntent Payment fields and mint salt
+ * @param blockNumber Execution block (`block.number` at mint)
+ * @param receiptType Receipt badge type from `ReceiptBadgeRouterMintPayload`
+ * @returns Deterministic payment record badge id
+ */
+export declare function paymentRecordBadgeIdFromPaymentIntent(identityContract: Address, paymentIntent: PaymentIntent, blockNumber: bigint, receiptType: ReceiptType): bigint;

package/dist/data/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './encoder.js';
+export * from './cashieDataUrl.js';

package/dist/data/types.d.ts

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+/** Matches `MetadataEncodingPrimitives.JSON_DATA_URI_BASE64_PREFIX`. */
+export declare const CASHIE_JSON_DATA_URI_BASE64_PREFIX: "data:application/json;base64,";
+/** Matches `MetadataEncodingPrimitives` SVG data URI prefix (`svgMarkupToImageDataUri`). */
+export declare const CASHIE_SVG_DATA_URI_BASE64_PREFIX: "data:image/svg+xml;base64,";
+/**
+ * Matches `CashieReceiptBadge.metadataFormat()` (`_METADATA_FORMAT`).
+ * ERC-5114 JSON does not embed this string; compare against the contract when resolving badges.
+ */
+export declare const CASHIE_RECEIPT_BADGE_METADATA_FORMAT: "Cashie-ReceiptBadge-v1";
+/**
+ * Matches `CashiePaymentRecordBadge.metadataFormat()` (`_METADATA_FORMAT`).
+ * ERC-5114 JSON does not embed this string; compare against the contract when resolving badges.
+ */
+export declare const CASHIE_PAYMENT_RECORD_BADGE_METADATA_FORMAT: "Cashie-PaymentRecordBadge-v1";
+/**
+ * `identityType` strings emitted by `IdentitySoulMetadataEncoderLib` — parallel to {@link IdentityType} ordinals.
+ */
+export declare const cashieIdentitySoulIdentityTypeJsonSchema: z.ZodEnum<{
+    Individual: "Individual";
+    Business: "Business";
+}>;
+/** Map JSON `identityType` labels to {@link IdentityType} values used in EIP-712 / structs. */
+export declare const JSON_IDENTITY_TYPE_LABEL_TO_IDENTITY_TYPE: {
+    readonly Individual: 0;
+    readonly Business: 1;
+};
+/** Non-empty `0x` hex (addresses, arbitrary commitment bytes on-chain). */
+export declare const hex0xSchema: z.ZodString;
+/** `bytes32` serialized like Solidity `Strings.toHexString(..., 32)`. */
+export declare const bytes32HexSchema: z.ZodString;
+export declare const cashieReceiptBadgeSoulBoundToSchema: z.ZodObject<{
+    identityContract: z.ZodString;
+    tokenId: z.ZodString;
+}, z.core.$strict>;
+/** EIP-721 JSON from `ReceiptBadgeMetadataEncoderLib`. */
+export declare const cashieReceiptBadgeMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    image: z.ZodString;
+    soulBoundTo: z.ZodObject<{
+        identityContract: z.ZodString;
+        tokenId: z.ZodString;
+    }, z.core.$strict>;
+    receiptType: z.ZodEnum<{
+        OneTime: "OneTime";
+        Recurring: "Recurring";
+    }>;
+    blockNumber: z.ZodString;
+    recipient: z.ZodString;
+    chainId: z.ZodString;
+    tokenAddress: z.ZodString;
+    allowance: z.ZodString;
+    salt: z.ZodString;
+}, z.core.$strict>;
+/** EIP-721 JSON from `PaymentRecordBadgeMetadataEncoderLib`. */
+export declare const cashiePaymentRecordBadgeMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    image: z.ZodString;
+    soulBoundTo: z.ZodObject<{
+        identityContract: z.ZodString;
+        tokenId: z.ZodString;
+    }, z.core.$strict>;
+    blockNumber: z.ZodString;
+    payer: z.ZodString;
+    chainId: z.ZodString;
+    tokenAddress: z.ZodString;
+    allowance: z.ZodString;
+    receiptBadgeId: z.ZodString;
+    salt: z.ZodString;
+}, z.core.$strict>;
+/**
+ * EIP-721 JSON from `IdentitySoulMetadataEncoderLib` (on-chain wire format).
+ * Use `.parse()` on decoded token URI JSON.
+ */
+export declare const cashieIdentitySoulTokenMetadataJsonSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    image: z.ZodString;
+    identityType: z.ZodPipe<z.ZodEnum<{
+        Individual: "Individual";
+        Business: "Business";
+    }>, z.ZodTransform<0 | 1, "Individual" | "Business">>;
+    domain: z.ZodString;
+    burnAuth: z.ZodPipe<z.ZodString, z.ZodTransform<0 | 1 | 2 | 3, string>>;
+    identityCommitment: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Parsed identity soul metadata (`IdentityType` / `BurnAuth` ordinals).
+ */
+export declare const cashieIdentitySoulTokenMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    image: z.ZodString;
+    identityType: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    domain: z.ZodString;
+    burnAuth: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+    identityCommitment: z.ZodString;
+}, z.core.$strict>;
+export type CashieReceiptBadgeSoulBoundTo = z.infer<typeof cashieReceiptBadgeSoulBoundToSchema>;
+export type CashieReceiptBadgeMetadata = z.infer<typeof cashieReceiptBadgeMetadataSchema>;
+export type CashiePaymentRecordBadgeMetadata = z.infer<typeof cashiePaymentRecordBadgeMetadataSchema>;
+export type CashieIdentitySoulTokenMetadata = z.infer<typeof cashieIdentitySoulTokenMetadataSchema>;
+export type ParsedCashieMetadata = {
+    kind: 'identitySoul';
+    data: CashieIdentitySoulTokenMetadata;
+} | {
+    kind: 'receiptBadge';
+    format: typeof CASHIE_RECEIPT_BADGE_METADATA_FORMAT;
+    data: CashieReceiptBadgeMetadata;
+} | {
+    kind: 'paymentRecordBadge';
+    format: typeof CASHIE_PAYMENT_RECORD_BADGE_METADATA_FORMAT;
+    data: CashiePaymentRecordBadgeMetadata;
+};

package/dist/erc-7715/common.types.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const addressSchema: z.ZodCustom<`0x${string}`, `0x${string}`>;
+export declare const hexSchema: z.ZodCustom<`0x${string}`, `0x${string}`>;
+export declare const baseScopeSchema: z.ZodObject<{
+    type: z.ZodString;
+    isAdjustmentAllowed: z.ZodBoolean;
+    justification: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+/**
+ * A custom error class for ERC-7715 validation errors.
+ */
+export declare class ERC7715ValidationError extends Error {
+    readonly schemaName: string;
+    readonly zodError: z.ZodError;
+    constructor(schemaName: string, zodError: z.ZodError);
+}
+/**
+ * Parses a value with a given schema and throws an error if the value is invalid.
+ *
+ * @param schemaName - The name of the schema
+ * @param schema - The schema to parse the value with
+ * @param value - The value to parse
+ * @returns The parsed value
+ */
+export declare function parseWithSchema<TSchema extends z.ZodType>(schemaName: string, schema: TSchema, value: unknown): z.output<TSchema>;
+/**
+ * A base scope type that all scopes must inherit from.
+ */
+export type BaseScopeSchema = z.infer<typeof baseScopeSchema>;
+/**
+ * Parses a base scope schema and throws an error if the value is invalid.
+ *
+ * @param scope - The scope to parse
+ * @returns The parsed base scope schema
+ */
+export declare function parseBaseScopeSchema(scope: unknown): BaseScopeSchema;

package/dist/erc-7715/index.d.ts

@@ -0,0 +1,4 @@
+export * from './permission/index.js';
+export * from './request/index.js';
+export * from './rules/index.js';
+export * from './common.types.js';

package/dist/erc-7715/permission/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './schemas.js';

package/dist/erc-7715/permission/schemas.d.ts

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+import type { RewardItem } from '../../intent/index.js';
+import type { BillingPeriod, ERC20TokenPaymentPermission, PaymentDetailsType, PaymentDetailsTypeMapping, Permission } from './types.js';
+export declare const billingPeriodSchema: z.ZodEnum<{
+    weekly: "weekly";
+    monthly: "monthly";
+    annually: "annually";
+}>;
+export declare const paymentDetailsTypeSchema: z.ZodEnum<{
+    single: "single";
+    recurring: "recurring";
+}>;
+export declare const rewardItemSchema: z.ZodType<RewardItem>;
+export declare const basePaymentDetailsDataSchema: z.ZodObject<{
+    allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+}, z.core.$strict>;
+export declare const singlePaymentDetailsSchema: z.ZodObject<{
+    allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+    type: z.ZodLiteral<"single">;
+}, z.core.$strict>;
+export declare const recurringPaymentDetailsSchema: z.ZodObject<{
+    allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+    type: z.ZodLiteral<"recurring">;
+    startDate: z.ZodOptional<z.ZodNumber>;
+    billingPeriod: z.ZodEnum<{
+        weekly: "weekly";
+        monthly: "monthly";
+        annually: "annually";
+    }>;
+}, z.core.$strict>;
+export declare const paymentDetailsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+    type: z.ZodLiteral<"single">;
+}, z.core.$strict>, z.ZodObject<{
+    allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+    rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+    type: z.ZodLiteral<"recurring">;
+    startDate: z.ZodOptional<z.ZodNumber>;
+    billingPeriod: z.ZodEnum<{
+        weekly: "weekly";
+        monthly: "monthly";
+        annually: "annually";
+    }>;
+}, z.core.$strict>], "type">;
+export declare const erc20TokenPaymentPermissionSchema: z.ZodObject<{
+    isAdjustmentAllowed: z.ZodBoolean;
+    justification: z.ZodString;
+    type: z.ZodLiteral<"erc20-token-payment">;
+    data: z.ZodObject<{
+        recipient: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        paymentDetails: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+            type: z.ZodLiteral<"single">;
+        }, z.core.$strict>, z.ZodObject<{
+            allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+            type: z.ZodLiteral<"recurring">;
+            startDate: z.ZodOptional<z.ZodNumber>;
+            billingPeriod: z.ZodEnum<{
+                weekly: "weekly";
+                monthly: "monthly";
+                annually: "annually";
+            }>;
+        }, z.core.$strict>], "type">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const permissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    isAdjustmentAllowed: z.ZodBoolean;
+    justification: z.ZodString;
+    type: z.ZodLiteral<"erc20-token-payment">;
+    data: z.ZodObject<{
+        recipient: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        paymentDetails: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+            type: z.ZodLiteral<"single">;
+        }, z.core.$strict>, z.ZodObject<{
+            allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+            type: z.ZodLiteral<"recurring">;
+            startDate: z.ZodOptional<z.ZodNumber>;
+            billingPeriod: z.ZodEnum<{
+                weekly: "weekly";
+                monthly: "monthly";
+                annually: "annually";
+            }>;
+        }, z.core.$strict>], "type">;
+    }, z.core.$strict>;
+}, z.core.$strict>], "type">;
+export declare const permissionSchemas: {
+    'erc20-token-payment': z.ZodObject<{
+        isAdjustmentAllowed: z.ZodBoolean;
+        justification: z.ZodString;
+        type: z.ZodLiteral<"erc20-token-payment">;
+        data: z.ZodObject<{
+            recipient: z.ZodCustom<`0x${string}`, `0x${string}`>;
+            paymentDetails: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"single">;
+            }, z.core.$strict>, z.ZodObject<{
+                allowance: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                tokenAddress: z.ZodCustom<`0x${string}`, `0x${string}`>;
+                rewardItems: z.ZodOptional<z.ZodArray<z.ZodType<RewardItem, unknown, z.core.$ZodTypeInternals<RewardItem, unknown>>>>;
+                type: z.ZodLiteral<"recurring">;
+                startDate: z.ZodOptional<z.ZodNumber>;
+                billingPeriod: z.ZodEnum<{
+                    weekly: "weekly";
+                    monthly: "monthly";
+                    annually: "annually";
+                }>;
+            }, z.core.$strict>], "type">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+};
+/**
+ * Parses a billing period.
+ *
+ * @param value - The value to parse.
+ * @returns The parsed billing period.
+ */
+export declare function parseBillingPeriod(value: unknown): BillingPeriod;
+/**
+ * Parses a payment details type.
+ *
+ * @param value - The value to parse.
+ * @returns The parsed payment details type.
+ */
+export declare function parsePaymentDetailsType(value: unknown): PaymentDetailsType;
+/**
+ * Parses a base payment details data.
+ *
+ * @param value - The value to parse.
+ * @returns The parsed base payment details data.
+ */
+export declare function parseBasePaymentDetailsData(value: unknown): z.infer<typeof basePaymentDetailsDataSchema>;
+/**
+ * Parses a payment details.
+ *
+ * @param value - The value to parse.
+ * @returns The parsed payment details.
+ */
+export declare function parsePaymentDetails<T extends PaymentDetailsType>(value: unknown): PaymentDetailsTypeMapping[T];
+/**
+ * Parses an ERC20 token payment permission.
+ *
+ * @param value - The value to parse.
+ * @returns The parsed ERC20 token payment permission.
+ */
+export declare function parseERC20TokenPaymentPermission(value: unknown): ERC20TokenPaymentPermission;
+/**
+ * Parses a permission.
+ *
+ * @param value - The value to parse.
+ * @returns The parsed permission.
+ */
+export declare function parsePermission(value: unknown): Permission;

package/dist/erc-7715/permission/types.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { basePaymentDetailsDataSchema, billingPeriodSchema, erc20TokenPaymentPermissionSchema, paymentDetailsTypeSchema, recurringPaymentDetailsSchema, singlePaymentDetailsSchema } from './schemas.js';
+export type BasePaymentDetailsData = z.infer<typeof basePaymentDetailsDataSchema>;
+export type BillingPeriod = z.infer<typeof billingPeriodSchema>;
+export type PaymentDetailsTypeMapping = {
+    single: z.infer<typeof singlePaymentDetailsSchema>;
+    recurring: z.infer<typeof recurringPaymentDetailsSchema>;
+};
+export type PaymentDetailsType = z.infer<typeof paymentDetailsTypeSchema>;
+/**
+ * A permission to make a payment using an ERC20 token.
+ */
+export type ERC20TokenPaymentPermission = z.infer<typeof erc20TokenPaymentPermissionSchema>;
+/**
+ * A mapping of permission types to their corresponding permission schemas.
+ */
+export type PermissionTypeMapping = {
+    'erc20-token-payment': ERC20TokenPaymentPermission;
+};
+/**
+ * A type that represents the different types of permissions.
+ */
+export type SupportedPermissionTypes = keyof PermissionTypeMapping;
+/**
+ * A type that represents a permission.
+ */
+export type Permission<TPermission extends SupportedPermissionTypes = SupportedPermissionTypes> = PermissionTypeMapping[TPermission];

package/dist/erc-7715/request/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './schemas.js';