@otim/utils 0.0.4 → 0.0.6

package/dist/schemas/index.js

@@ -1,433 +1,390 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/schemas/index.ts
-var schemas_exports = {};
-__export(schemas_exports, {
-  AccountType: () => AccountType,
-  ContactSchema: () => ContactSchema,
-  ContactsSchema: () => ContactsSchema,
-  DATE_ISO_8601_REGEX: () => DATE_ISO_8601_REGEX,
-  DATE_REGEX: () => DATE_REGEX,
-  DATE_STANDARD_REGEX: () => DATE_STANDARD_REGEX,
-  InstructionAction: () => InstructionAction,
-  InstructionScheduleRepeatType: () => InstructionScheduleRepeatType,
-  InstructionScheduleRetryType: () => InstructionScheduleRetryType,
-  InstructionScheduleStartType: () => InstructionScheduleStartType,
-  InstructionState: () => InstructionState,
-  InstructionViewTimescale: () => InstructionViewTimescale,
-  PaymentSource: () => PaymentSource,
-  PaymentStatus: () => PaymentStatus,
-  PaymentsSchema: () => PaymentsSchema,
-  Sort: () => Sort,
-  TIME_REGEX: () => TIME_REGEX,
-  TimeUnit: () => TimeUnit,
-  Token: () => Token,
-  TokenValues: () => TokenValues,
-  addressSchema: () => addressSchema,
-  assertInstructionAction: () => assertInstructionAction,
-  assertToken: () => assertToken,
-  assertsOptionalToken: () => assertsOptionalToken,
-  bigintSchema: () => bigintSchema,
-  dateISO8601Schema: () => dateISO8601Schema,
-  dateSchema: () => dateSchema,
-  dateStandardSchema: () => dateStandardSchema,
-  decimalStringSchema: () => decimalStringSchema,
-  eip2098SignatureSchema: () => eip2098SignatureSchema,
-  entityIdSchema: () => entityIdSchema,
-  hexStringSchema: () => hexStringSchema,
-  instructionActionSchema: () => instructionActionSchema,
-  instructionActionValues: () => instructionActionValues,
-  instructionExecutionStateSchema: () => instructionExecutionStateSchema,
-  instructionIdSchema: () => instructionIdSchema,
-  instructionScheduleRepeatSchema: () => instructionScheduleRepeatSchema,
-  instructionScheduleRepeatValues: () => instructionScheduleRepeatValues,
-  instructionScheduleRetrySchema: () => instructionScheduleRetrySchema,
-  instructionScheduleRetryValues: () => instructionScheduleRetryValues,
-  instructionScheduleStartSchema: () => instructionScheduleStartSchema,
-  instructionScheduleStartValues: () => instructionScheduleStartValues,
-  instructionSchema: () => instructionSchema,
-  instructionStateSchema: () => instructionStateSchema,
-  instructionStateValues: () => instructionStateValues,
-  instructionSummariesByDateSchema: () => instructionSummariesByDateSchema,
-  instructionSummariesSchema: () => instructionSummariesSchema,
-  instructionSummarySchema: () => instructionSummarySchema,
-  instructionViewTimescaleValues: () => instructionViewTimescaleValues,
-  instructionsSchema: () => instructionsSchema,
-  nonEmptyStringSchema: () => nonEmptyStringSchema,
-  numberSchema: () => numberSchema,
-  paymentRequestSourceValues: () => paymentRequestSourceValues,
-  paymentSchema: () => paymentSchema,
-  regexSchema: () => regexSchema,
-  sortValues: () => sortValues,
-  timeSchema: () => timeSchema,
-  timeUnitSchema: () => timeUnitSchema,
-  timeUnitValues: () => timeUnitValues,
-  tokenSchema: () => tokenSchema,
-  transactionSchema: () => transactionSchema,
-  transactionWithValidAmountSchema: () => transactionWithValidAmountSchema,
-  transactionsSchema: () => transactionsSchema,
-  userPreferencesSchema: () => userPreferencesSchema,
-  userSchema: () => userSchema,
-  vrsSchema: () => vrsSchema
-});
-module.exports = __toCommonJS(schemas_exports);
+const require_chunk = require('../chunk-kSYXY2_d.js');
+let zod = require("zod");
 
-// src/schemas/account.ts
-var AccountType = {
-  Otim: "otim",
-  Bank: "bank",
-  Ephemeral: "ephemeral",
-  Custodian: "custodian",
-  Wallet: "wallet"
+//#region src/schemas/account.ts
+const AccountType = {
+	Otim: "otim",
+	Bank: "bank",
+	Ephemeral: "ephemeral",
+	Custodian: "custodian",
+	Wallet: "wallet"
+};
+const AccountConnectionStatus = {
+	Connected: "connected",
+	Disconnected: "disconnected",
+	Connecting: "connecting",
+	Reconnecting: "reconnecting"
 };
 
-// src/schemas/contact.ts
-var import_zod = require("zod");
-var ContactSchema = import_zod.z.object({
-  userId: import_zod.z.string(),
-  name: import_zod.z.string(),
-  address: import_zod.z.string(),
-  createdAt: import_zod.z.string(),
-  updatedAt: import_zod.z.string()
+//#endregion
+//#region src/schemas/contact.ts
+const ContactSchema = zod.z.object({
+	userId: zod.z.string(),
+	name: zod.z.string(),
+	address: zod.z.string(),
+	createdAt: zod.z.string(),
+	updatedAt: zod.z.string()
 });
-var ContactsSchema = import_zod.z.array(ContactSchema);
-
-// src/schemas/instruction.ts
-var import_zod3 = require("zod");
+const ContactsSchema = zod.z.array(ContactSchema);
 
-// src/schemas/misc.ts
-var import_zod2 = require("zod");
-var DATE_REGEX = /^(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
-var DATE_ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
-var DATE_STANDARD_REGEX = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/(19|20)\d{2}$/;
-var TIME_REGEX = /^(0[1-9]|1[0-2]):[0-5][0-9]:[0-5][0-9] (AM|PM)$/;
-var regexSchema = (regex, message) => import_zod2.z.string().regex(regex, message);
-var nonEmptyStringSchema = import_zod2.z.string().min(1);
-var numberSchema = import_zod2.z.union([
-  import_zod2.z.number().finite(),
-  import_zod2.z.string().regex(/^-?\d*\.?\d+(?:[eE][-+]?\d+)?$/).transform(Number)
-]);
-var decimalStringSchema = import_zod2.z.string().regex(/^-?\d*\.?\d+$/).refine((val) => !isNaN(parseFloat(val)), {
-  message: "Must be a valid decimal number"
-});
-var bigintSchema = import_zod2.z.union([
-  import_zod2.z.bigint(),
-  import_zod2.z.string().regex(/^-?\d+$/).transform(BigInt)
-]);
-var hexStringSchema = import_zod2.z.string().startsWith("0x").transform((val) => val);
-var dateSchema = regexSchema(DATE_REGEX);
-var dateISO8601Schema = regexSchema(DATE_ISO_8601_REGEX);
-var dateStandardSchema = regexSchema(DATE_STANDARD_REGEX);
-var timeSchema = regexSchema(TIME_REGEX);
-var Sort = {
-  Asc: "asc",
-  Desc: "desc"
+//#endregion
+//#region src/schemas/misc.ts
+const DATE_REGEX = /^(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+const DATE_ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
+const DATE_STANDARD_REGEX = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/(19|20)\d{2}$/;
+const TIME_REGEX = /^(0[1-9]|1[0-2]):[0-5][0-9]:[0-5][0-9] (AM|PM)$/;
+const regexSchema = (regex, message) => zod.z.string().regex(regex, message);
+const nonEmptyStringSchema = zod.z.string().min(1);
+const numberSchema = zod.z.union([zod.z.number().finite(), zod.z.string().regex(/^-?\d*\.?\d+(?:[eE][-+]?\d+)?$/).transform(Number)]);
+const decimalStringSchema = zod.z.string().regex(/^-?\d*\.?\d+$/).refine((val) => !isNaN(parseFloat(val)), { message: "Must be a valid decimal number" });
+const bigintSchema = zod.z.union([zod.z.bigint(), zod.z.string().regex(/^-?\d+$/).transform(BigInt)]);
+const hexStringSchema = zod.z.string().startsWith("0x").transform((val) => val);
+const chainIdSchema = zod.z.number().positive();
+const dateSchema = regexSchema(DATE_REGEX);
+const dateISO8601Schema = regexSchema(DATE_ISO_8601_REGEX);
+const dateStandardSchema = regexSchema(DATE_STANDARD_REGEX);
+const timeSchema = regexSchema(TIME_REGEX);
+const Sort = {
+	Asc: "asc",
+	Desc: "desc"
 };
-var sortValues = Object.values(Sort);
-var vrsSchema = import_zod2.z.object({
-  v: import_zod2.z.number(),
-  r: import_zod2.z.string(),
-  s: import_zod2.z.string()
+const sortValues = Object.values(Sort);
+const vrsSchema = zod.z.object({
+	v: zod.z.number(),
+	r: zod.z.string(),
+	s: zod.z.string()
 });
-var eip2098SignatureSchema = import_zod2.z.object({
-  yParity: import_zod2.z.number(),
-  r: import_zod2.z.string(),
-  s: import_zod2.z.string()
+const eip2098SignatureSchema = zod.z.object({
+	yParity: zod.z.number(),
+	r: zod.z.string(),
+	s: zod.z.string()
 });
 
-// src/schemas/instruction.ts
-var instructionIdSchema = hexStringSchema;
-var InstructionState = {
-  PendingActivation: "PendingActivation",
-  Active: "Active",
-  PendingDeactivation: "PendingDeactivation",
-  Deactivated: "Deactivated",
-  Errored: "Errored",
-  Completed: "Completed",
-  UserNotDelegated: "UserNotDelegated",
-  InFlight: "InFlight",
-  NotifyUser: "NotifyUser"
+//#endregion
+//#region src/schemas/instruction.ts
+const instructionIdSchema = hexStringSchema;
+const InstructionState = {
+	PendingActivation: "PendingActivation",
+	Active: "Active",
+	PendingDeactivation: "PendingDeactivation",
+	Deactivated: "Deactivated",
+	Errored: "Errored",
+	Completed: "Completed",
+	UserNotDelegated: "UserNotDelegated",
+	InFlight: "InFlight",
+	NotifyUser: "NotifyUser"
 };
-var instructionStateValues = Object.values(InstructionState);
-var instructionStateSchema = import_zod3.z.enum(instructionStateValues);
-var InstructionAction = {
-  RefuelERC20: "refuelERC20",
-  Refuel: "refuel",
-  Transfer: "transfer",
-  TransferERC20: "transferERC20",
-  UniswapV3ExactInput: "uniswapV3ExactInput",
-  Sweep: "sweep",
-  SweepERC20: "sweepERC20",
-  SweepCCTP: "sweepCCTP",
-  SweepUniswapV3: "sweepUniswapV3",
-  SweepDepositAccount: "sweepDepositAccount",
-  SweepDepositAccountERC20: "sweepDepositAccountERC20",
-  DeactivateInstruction: "deactivateInstruction",
-  SweepSkipCCTPDepositAccount: "sweepSkipCCTPDepositAccount"
+const instructionStateValues = Object.values(InstructionState);
+const instructionStateSchema = zod.z.enum(instructionStateValues);
+const InstructionAction = {
+	Refuel: "Refuel",
+	RefuelERC20: "RefuelERC20",
+	Transfer: "Transfer",
+	TransferERC20: "TransferERC20",
+	TransferCCTP: "TransferCCTP",
+	UniswapV3ExactInput: "UniswapV3ExactInput",
+	Sweep: "Sweep",
+	SweepERC20: "SweepERC20",
+	SweepCCTP: "SweepCCTP",
+	SweepUniswapV3: "SweepUniswapV3",
+	DeactivateInstruction: "DeactivateInstruction",
+	SweepSkipCCTPDepositAccount: "SweepSkipCCTPDepositAccount",
+	DepositERC4626: "DepositERC4626",
+	SweepDepositERC4626: "SweepDepositERC4626",
+	WithdrawERC4626: "WithdrawERC4626",
+	SweepWithdrawERC4626: "SweepWithdrawERC4626",
+	SweepDepositAccount: "SweepDepositAccount",
+	SweepDepositAccountERC20: "SweepDepositAccountERC20",
+	CallOnce: "CallOnce"
 };
-var instructionActionValues = Object.values(InstructionAction);
-var instructionActionSchema = import_zod3.z.enum(instructionActionValues);
-var InstructionScheduleStartType = {
-  Now: "now",
-  DateTime: "datetime"
+const instructionActionValues = Object.values(InstructionAction);
+const instructionActionSchema = zod.z.enum(instructionActionValues);
+const InstructionScheduleStartType = {
+	Now: "now",
+	DateTime: "datetime"
 };
-var instructionScheduleStartValues = Object.values(
-  InstructionScheduleStartType
-);
-var baseStartSchema = import_zod3.z.object({
-  type: import_zod3.z.enum(instructionScheduleStartValues)
+const instructionScheduleStartValues = Object.values(InstructionScheduleStartType);
+const baseStartSchema = zod.z.object({ type: zod.z.enum(instructionScheduleStartValues) });
+const nowStartSchema = baseStartSchema.extend({ type: zod.z.literal(InstructionScheduleStartType.Now) });
+const dateTimeStartSchema = baseStartSchema.extend({
+	type: zod.z.literal(InstructionScheduleStartType.DateTime),
+	startDate: dateStandardSchema,
+	startTime: zod.z.string()
 });
-var nowStartSchema = baseStartSchema.extend({
-  type: import_zod3.z.literal(InstructionScheduleStartType.Now)
-});
-var dateTimeStartSchema = baseStartSchema.extend({
-  type: import_zod3.z.literal(InstructionScheduleStartType.DateTime),
-  startDate: dateStandardSchema,
-  startTime: import_zod3.z.string()
-});
-var instructionScheduleStartSchema = import_zod3.z.discriminatedUnion("type", [
-  nowStartSchema,
-  dateTimeStartSchema
-]);
-var InstructionScheduleRepeatType = {
-  UntilDeactivated: "until-deactivated",
-  MaxExecutions: "max-executions"
+const instructionScheduleStartSchema = zod.z.discriminatedUnion("type", [nowStartSchema, dateTimeStartSchema]);
+const InstructionScheduleRepeatType = {
+	UntilDeactivated: "until-deactivated",
+	MaxExecutions: "max-executions"
 };
-var instructionScheduleRepeatValues = Object.values(
-  InstructionScheduleRepeatType
-);
-var baseRepeatSchema = import_zod3.z.object({});
-var untilDeactivatedRepeatSchema = baseRepeatSchema.extend({
-  type: import_zod3.z.literal(InstructionScheduleRepeatType.UntilDeactivated)
-});
-var maxExecutionsRepeatSchema = baseRepeatSchema.extend({
-  type: import_zod3.z.literal(InstructionScheduleRepeatType.MaxExecutions),
-  maxExecutions: numberSchema
+const instructionScheduleRepeatValues = Object.values(InstructionScheduleRepeatType);
+const baseRepeatSchema = zod.z.object({});
+const untilDeactivatedRepeatSchema = baseRepeatSchema.extend({ type: zod.z.literal(InstructionScheduleRepeatType.UntilDeactivated) });
+const maxExecutionsRepeatSchema = baseRepeatSchema.extend({
+	type: zod.z.literal(InstructionScheduleRepeatType.MaxExecutions),
+	maxExecutions: numberSchema
 });
-var instructionScheduleRepeatSchema = import_zod3.z.discriminatedUnion("type", [
-  untilDeactivatedRepeatSchema,
-  maxExecutionsRepeatSchema
-]);
-var InstructionScheduleRetryType = {
-  UntilDeactivated: "until-deactivated",
-  TimeLimited: "time-limited"
+const instructionScheduleRepeatSchema = zod.z.discriminatedUnion("type", [untilDeactivatedRepeatSchema, maxExecutionsRepeatSchema]);
+const InstructionScheduleRetryType = {
+	UntilDeactivated: "until-deactivated",
+	TimeLimited: "time-limited"
 };
-var instructionScheduleRetryValues = Object.values(
-  InstructionScheduleRetryType
-);
-var baseRetrySchema = import_zod3.z.object({});
-var untilDeactivatedRetrySchema = baseRetrySchema.extend({
-  type: import_zod3.z.literal(InstructionScheduleRetryType.UntilDeactivated)
+const instructionScheduleRetryValues = Object.values(InstructionScheduleRetryType);
+const baseRetrySchema = zod.z.object({});
+const untilDeactivatedRetrySchema = baseRetrySchema.extend({ type: zod.z.literal(InstructionScheduleRetryType.UntilDeactivated) });
+const timeLimitedRetrySchema = baseRetrySchema.extend({
+	type: zod.z.literal(InstructionScheduleRetryType.TimeLimited),
+	retryCount: numberSchema
 });
-var timeLimitedRetrySchema = baseRetrySchema.extend({
-  type: import_zod3.z.literal(InstructionScheduleRetryType.TimeLimited),
-  retryCount: numberSchema
-});
-var instructionScheduleRetrySchema = import_zod3.z.discriminatedUnion("type", [
-  untilDeactivatedRetrySchema,
-  timeLimitedRetrySchema
-]);
-var TimeUnit = {
-  None: "none",
-  Second: "second",
-  Minute: "minute",
-  Hour: "hour",
-  Day: "day",
-  Week: "week",
-  Month: "month"
+const instructionScheduleRetrySchema = zod.z.discriminatedUnion("type", [untilDeactivatedRetrySchema, timeLimitedRetrySchema]);
+const TimeUnit = {
+	None: "none",
+	Second: "second",
+	Minute: "minute",
+	Hour: "hour",
+	Day: "day",
+	Week: "week",
+	Month: "month"
 };
-var timeUnitValues = Object.values(TimeUnit);
-var timeUnitSchema = import_zod3.z.enum(timeUnitValues);
-var instructionExecutionStateSchema = import_zod3.z.object({
-  executionStatus: instructionStateSchema.optional(),
-  executionCounter: import_zod3.z.number().int().optional(),
-  lastExecuted: import_zod3.z.number().int().optional()
+const timeUnitValues = Object.values(TimeUnit);
+const timeUnitSchema = zod.z.enum(timeUnitValues);
+const instructionExecutionStateRawSchema = zod.z.object({
+	execution_status: instructionStateSchema.optional(),
+	execution_counter: zod.z.number().int().optional(),
+	last_executed: zod.z.number().int().optional()
 });
-var instructionSchema = import_zod3.z.object({
-  instructionId: hexStringSchema,
-  createdAt: import_zod3.z.number().optional(),
-  startAt: import_zod3.z.string().nullish(),
-  interval: import_zod3.z.number().nullish(),
-  timeout: import_zod3.z.number().nullish(),
-  maxExecutions: import_zod3.z.number().nullish(),
-  executionState: instructionExecutionStateSchema.optional(),
-  actionName: import_zod3.z.string().optional(),
-  arguments: import_zod3.z.any(),
-  nickname: import_zod3.z.string().nullish(),
-  lastInstructedValue: import_zod3.z.string().optional(),
-  lastErrorCode: import_zod3.z.number().nullish(),
-  lastErrorMessage: import_zod3.z.string().nullish(),
-  totalInstructedValue: import_zod3.z.string().optional(),
-  instructedTokenAddress: hexStringSchema.nullish(),
-  chainId: import_zod3.z.number().nullish(),
-  chain: import_zod3.z.string().optional()
+const instructionExecutionStateSchema = instructionExecutionStateRawSchema.transform((data) => ({
+	executionStatus: data.execution_status,
+	executionCounter: data.execution_counter,
+	lastExecuted: data.last_executed
+}));
+const instructionSchema = zod.z.object({
+	instructionId: hexStringSchema,
+	createdAt: zod.z.number().optional(),
+	startAt: zod.z.string().nullish(),
+	interval: zod.z.number().nullish(),
+	timeout: zod.z.number().nullish(),
+	maxExecutions: zod.z.number().nullish(),
+	executionState: instructionExecutionStateSchema,
+	actionName: zod.z.string().optional(),
+	arguments: zod.z.any(),
+	nickname: zod.z.string().nullish(),
+	lastInstructedValue: zod.z.string().optional(),
+	lastErrorCode: zod.z.number().nullish(),
+	lastErrorMessage: zod.z.string().nullish(),
+	totalInstructedValue: zod.z.string().optional(),
+	instructedTokenAddress: hexStringSchema.nullish(),
+	chainId: zod.z.number().nullish(),
+	chain: zod.z.string().optional()
 });
-var instructionsSchema = import_zod3.z.array(instructionSchema);
-var instructionSummarySchema = import_zod3.z.object({
-  instructionId: hexStringSchema,
-  chainId: import_zod3.z.number().int(),
-  executionCount: import_zod3.z.number().int(),
-  onTimeCount: import_zod3.z.number().int(),
-  lateCount: import_zod3.z.number().int(),
-  wasActivatedDuring: import_zod3.z.boolean(),
-  amount: import_zod3.z.number().default(0),
-  instructedValue: import_zod3.z.string().nullish().default("0"),
-  instructedTokenAddress: import_zod3.z.string().nullish().default(null)
+const instructionsSchema = zod.z.array(instructionSchema);
+const instructionSummarySchema = zod.z.object({
+	instructionId: hexStringSchema,
+	chainId: zod.z.number().int(),
+	executionCount: zod.z.number().int(),
+	onTimeCount: zod.z.number().int(),
+	lateCount: zod.z.number().int(),
+	wasActivatedDuring: zod.z.boolean(),
+	amount: zod.z.number().default(0),
+	instructedValue: zod.z.string().nullish().default("0"),
+	instructedTokenAddress: zod.z.string().nullish().default(null)
 });
-var instructionSummariesSchema = import_zod3.z.array(instructionSummarySchema);
-var instructionSummariesByDateSchema = import_zod3.z.record(
-  import_zod3.z.string(),
-  instructionSummariesSchema
-);
-var InstructionViewTimescale = {
-  Days: "days",
-  Hours: "hours",
-  Minutes: "minutes",
-  Seconds: "seconds"
+const instructionSummariesSchema = zod.z.array(instructionSummarySchema);
+const instructionSummariesByDateSchema = zod.z.record(zod.z.string(), instructionSummariesSchema);
+const InstructionViewTimescale = {
+	Days: "days",
+	Hours: "hours",
+	Minutes: "minutes",
+	Seconds: "seconds"
 };
-var instructionViewTimescaleValues = Object.values(
-  InstructionViewTimescale
-);
+const instructionViewTimescaleValues = Object.values(InstructionViewTimescale);
 function assertInstructionAction(action) {
-  if (!instructionActionValues.includes(action)) {
-    throw new Error(`Invalid instruction action: ${action}`);
-  }
+	if (!instructionActionValues.includes(action)) throw new Error(`Invalid instruction action: ${action}`);
 }
 
-// src/schemas/payment.ts
-var import_zod4 = require("zod");
-var PaymentStatus = {
-  Due: "due",
-  NotDue: "not-due",
-  Paid: "paid"
+//#endregion
+//#region src/schemas/payment.ts
+const PaymentStatus = {
+	Due: "due",
+	NotDue: "not-due",
+	Paid: "paid"
 };
-var PaymentSource = {
-  Bill: "Bill",
-  Stripe: "Stripe",
-  Clio: "Clio",
-  QuickBooks: "QuickBooks"
+const PaymentSource = {
+	Bill: "Bill",
+	Stripe: "Stripe",
+	Clio: "Clio",
+	QuickBooks: "QuickBooks"
 };
-var paymentRequestSourceValues = [
-  PaymentSource.Bill,
-  PaymentSource.Stripe,
-  PaymentSource.Clio,
-  PaymentSource.QuickBooks
+const paymentRequestSourceValues = [
+	PaymentSource.Bill,
+	PaymentSource.Stripe,
+	PaymentSource.Clio,
+	PaymentSource.QuickBooks
 ];
-var paymentSchema = import_zod4.z.object({
-  id: import_zod4.z.string(),
-  fromUserId: import_zod4.z.string().nullable().optional(),
-  toUserId: import_zod4.z.string().nullable().optional(),
-  payerAddress: import_zod4.z.string().nullable().optional(),
-  ephemeralWalletAddress: import_zod4.z.string(),
-  ephemeralWalletId: import_zod4.z.string().optional(),
-  instructions: import_zod4.z.object({
-    ids: import_zod4.z.array(import_zod4.z.string()),
-    completionIds: import_zod4.z.array(import_zod4.z.string())
-  }).optional(),
-  metadata: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional(),
-  // UI-derived fields
-  status: import_zod4.z.union([
-    import_zod4.z.literal(PaymentStatus.Due),
-    import_zod4.z.literal(PaymentStatus.NotDue),
-    import_zod4.z.literal(PaymentStatus.Paid)
-  ]),
-  dueDate: import_zod4.z.string(),
-  amountDue: import_zod4.z.number(),
-  note: import_zod4.z.string().nullable().optional(),
-  address: import_zod4.z.string().nullable().optional(),
-  addedOn: import_zod4.z.string(),
-  source: import_zod4.z.union([
-    import_zod4.z.literal(PaymentSource.Bill),
-    import_zod4.z.literal(PaymentSource.Stripe),
-    import_zod4.z.literal(PaymentSource.Clio),
-    import_zod4.z.literal(PaymentSource.QuickBooks)
-  ]).nullish(),
-  attachmentUrl: import_zod4.z.string().url().nullable().optional(),
-  attachmentName: import_zod4.z.string().nullable().optional(),
-  fromAccountAddress: import_zod4.z.string().nullable().optional()
+const paymentSchema = zod.z.object({
+	id: zod.z.string(),
+	fromUserId: zod.z.string().nullable().optional(),
+	toUserId: zod.z.string().nullable().optional(),
+	payerAddress: zod.z.string().nullable().optional(),
+	ephemeralWalletAddress: zod.z.string(),
+	ephemeralWalletId: zod.z.string().optional(),
+	instructions: zod.z.object({
+		ids: zod.z.array(zod.z.string()),
+		completionIds: zod.z.array(zod.z.string())
+	}).optional(),
+	metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+	status: zod.z.union([
+		zod.z.literal(PaymentStatus.Due),
+		zod.z.literal(PaymentStatus.NotDue),
+		zod.z.literal(PaymentStatus.Paid)
+	]),
+	dueDate: zod.z.string(),
+	amountDue: zod.z.number(),
+	note: zod.z.string().nullable().optional(),
+	address: zod.z.string().nullable().optional(),
+	addedOn: zod.z.string(),
+	source: zod.z.union([
+		zod.z.literal(PaymentSource.Bill),
+		zod.z.literal(PaymentSource.Stripe),
+		zod.z.literal(PaymentSource.Clio),
+		zod.z.literal(PaymentSource.QuickBooks)
+	]).nullish(),
+	attachmentUrl: zod.z.string().url().nullable().optional(),
+	attachmentName: zod.z.string().nullable().optional(),
+	fromAccountAddress: zod.z.string().nullable().optional()
 });
-var PaymentsSchema = import_zod4.z.array(paymentSchema);
+const PaymentsSchema = zod.z.array(paymentSchema);
 
-// src/schemas/token.ts
-var import_zod5 = require("zod");
-var Token = {
-  ETH: "ETH",
-  USDC: "USDC",
-  USDT: "USDT"
+//#endregion
+//#region src/schemas/token.ts
+const Token = {
+	ETH: "ETH",
+	USDC: "USDC",
+	USDT: "USDT"
 };
-var TokenValues = Object.values(Token);
-var tokenSchema = import_zod5.z.enum(TokenValues);
+const TokenValues = Object.values(Token);
+const tokenSchema = zod.z.enum(TokenValues);
 function assertToken(token) {
-  if (!TokenValues.includes(token)) {
-    throw new Error(`Invalid token: ${token}`);
-  }
+	if (!TokenValues.includes(token)) throw new Error(`Invalid token: ${token}`);
 }
 function assertsOptionalToken(token) {
-  if (token !== void 0) {
-    assertToken(token);
-  }
+	if (token !== void 0) assertToken(token);
 }
 
-// src/schemas/transaction.ts
-var import_zod6 = require("zod");
-var transactionSchema = import_zod6.z.object({
-  instructionId: instructionIdSchema,
-  transactionHash: hexStringSchema.optional(),
-  blockHash: import_zod6.z.string().nullable(),
-  transactionStatus: import_zod6.z.string(),
-  error: import_zod6.z.string().nullish(),
-  startedAt: import_zod6.z.string(),
-  startedAtBlock: import_zod6.z.number(),
-  finishedAt: import_zod6.z.string().nullable(),
-  finishedAtBlock: import_zod6.z.number().nullable(),
-  amount: import_zod6.z.object({ value: import_zod6.z.number(), token: import_zod6.z.string() }).nullish(),
-  instructedValue: import_zod6.z.string(),
-  instructedTokenAddress: import_zod6.z.string().nullable(),
-  executionNum: import_zod6.z.number(),
-  chainId: import_zod6.z.number().nullish(),
-  chain: import_zod6.z.string().optional()
-});
-var transactionWithValidAmountSchema = transactionSchema.extend({
-  amount: import_zod6.z.object({
-    value: import_zod6.z.number(),
-    token: import_zod6.z.string()
-  })
+//#endregion
+//#region src/schemas/transaction.ts
+const transactionSchema = zod.z.object({
+	instructionId: instructionIdSchema,
+	transactionHash: hexStringSchema.optional(),
+	blockHash: zod.z.string().nullable(),
+	transactionStatus: zod.z.string(),
+	error: zod.z.string().nullish(),
+	startedAt: zod.z.string(),
+	startedAtBlock: zod.z.number(),
+	finishedAt: zod.z.string().nullable(),
+	finishedAtBlock: zod.z.number().nullable(),
+	amount: zod.z.object({
+		value: zod.z.number(),
+		token: zod.z.string()
+	}).nullish(),
+	instructedValue: zod.z.string(),
+	instructedTokenAddress: zod.z.string().nullable(),
+	executionNum: zod.z.number(),
+	chainId: zod.z.number().nullish(),
+	chain: zod.z.string().optional()
 });
-var transactionsSchema = import_zod6.z.array(transactionSchema);
+const transactionWithValidAmountSchema = transactionSchema.extend({ amount: zod.z.object({
+	value: zod.z.number(),
+	token: zod.z.string()
+}) });
+const transactionsSchema = zod.z.array(transactionSchema);
 
-// src/schemas/user.ts
-var import_zod7 = require("zod");
-var entityIdSchema = import_zod7.z.string().uuid();
-var addressSchema = import_zod7.z.string().regex(/^0x[a-fA-F0-9]{40}$/).transform((v) => v.toLowerCase());
-var userPreferencesSchema = import_zod7.z.object({
-  chainId: import_zod7.z.number().optional(),
-  tokenSymbol: import_zod7.z.string().optional(),
-  localCurrency: import_zod7.z.string().optional()
+//#endregion
+//#region src/schemas/user.ts
+const entityIdSchema = zod.z.string().uuid();
+const addressSchema = zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/).transform((v) => v.toLowerCase());
+const userPreferencesSchema = zod.z.object({
+	chainId: zod.z.number().optional(),
+	tokenSymbol: zod.z.string().optional(),
+	localCurrency: zod.z.string().optional()
 });
-var userSchema = import_zod7.z.object({
-  id: entityIdSchema,
-  address: addressSchema,
-  createdAt: import_zod7.z.string(),
-  updatedAt: import_zod7.z.string(),
-  preferences: userPreferencesSchema.optional(),
-  isDeveloper: import_zod7.z.boolean(),
-  developerPublicKey: import_zod7.z.string().nullable().optional()
+const userSchema = zod.z.object({
+	id: entityIdSchema,
+	address: addressSchema,
+	email: zod.z.string().email().nullable().optional(),
+	createdAt: zod.z.string(),
+	updatedAt: zod.z.string(),
+	preferences: userPreferencesSchema.optional(),
+	isDeveloper: zod.z.boolean(),
+	developerPublicKey: zod.z.string().nullable().optional()
 });
-//# sourceMappingURL=index.js.map
+
+//#endregion
+exports.AccountConnectionStatus = AccountConnectionStatus;
+exports.AccountType = AccountType;
+exports.ContactSchema = ContactSchema;
+exports.ContactsSchema = ContactsSchema;
+exports.DATE_ISO_8601_REGEX = DATE_ISO_8601_REGEX;
+exports.DATE_REGEX = DATE_REGEX;
+exports.DATE_STANDARD_REGEX = DATE_STANDARD_REGEX;
+exports.InstructionAction = InstructionAction;
+exports.InstructionScheduleRepeatType = InstructionScheduleRepeatType;
+exports.InstructionScheduleRetryType = InstructionScheduleRetryType;
+exports.InstructionScheduleStartType = InstructionScheduleStartType;
+exports.InstructionState = InstructionState;
+exports.InstructionViewTimescale = InstructionViewTimescale;
+exports.PaymentSource = PaymentSource;
+exports.PaymentStatus = PaymentStatus;
+exports.PaymentsSchema = PaymentsSchema;
+exports.Sort = Sort;
+exports.TIME_REGEX = TIME_REGEX;
+exports.TimeUnit = TimeUnit;
+exports.Token = Token;
+exports.TokenValues = TokenValues;
+exports.addressSchema = addressSchema;
+exports.assertInstructionAction = assertInstructionAction;
+exports.assertToken = assertToken;
+exports.assertsOptionalToken = assertsOptionalToken;
+exports.bigintSchema = bigintSchema;
+exports.chainIdSchema = chainIdSchema;
+exports.dateISO8601Schema = dateISO8601Schema;
+exports.dateSchema = dateSchema;
+exports.dateStandardSchema = dateStandardSchema;
+exports.decimalStringSchema = decimalStringSchema;
+exports.eip2098SignatureSchema = eip2098SignatureSchema;
+exports.entityIdSchema = entityIdSchema;
+exports.hexStringSchema = hexStringSchema;
+exports.instructionActionSchema = instructionActionSchema;
+exports.instructionActionValues = instructionActionValues;
+exports.instructionExecutionStateSchema = instructionExecutionStateSchema;
+exports.instructionIdSchema = instructionIdSchema;
+exports.instructionScheduleRepeatSchema = instructionScheduleRepeatSchema;
+exports.instructionScheduleRepeatValues = instructionScheduleRepeatValues;
+exports.instructionScheduleRetrySchema = instructionScheduleRetrySchema;
+exports.instructionScheduleRetryValues = instructionScheduleRetryValues;
+exports.instructionScheduleStartSchema = instructionScheduleStartSchema;
+exports.instructionScheduleStartValues = instructionScheduleStartValues;
+exports.instructionSchema = instructionSchema;
+exports.instructionStateSchema = instructionStateSchema;
+exports.instructionStateValues = instructionStateValues;
+exports.instructionSummariesByDateSchema = instructionSummariesByDateSchema;
+exports.instructionSummariesSchema = instructionSummariesSchema;
+exports.instructionSummarySchema = instructionSummarySchema;
+exports.instructionViewTimescaleValues = instructionViewTimescaleValues;
+exports.instructionsSchema = instructionsSchema;
+exports.nonEmptyStringSchema = nonEmptyStringSchema;
+exports.numberSchema = numberSchema;
+exports.paymentRequestSourceValues = paymentRequestSourceValues;
+exports.paymentSchema = paymentSchema;
+exports.regexSchema = regexSchema;
+exports.sortValues = sortValues;
+exports.timeSchema = timeSchema;
+exports.timeUnitSchema = timeUnitSchema;
+exports.timeUnitValues = timeUnitValues;
+exports.tokenSchema = tokenSchema;
+exports.transactionSchema = transactionSchema;
+exports.transactionWithValidAmountSchema = transactionWithValidAmountSchema;
+exports.transactionsSchema = transactionsSchema;
+exports.userPreferencesSchema = userPreferencesSchema;
+exports.userSchema = userSchema;
+exports.vrsSchema = vrsSchema;
+//# sourceMappingURL=index.js.map