@otim/utils 0.0.4 → 0.0.6

package/dist/schemas/index.mjs

@@ -1,410 +1,322 @@
-// src/schemas/account.ts
-var AccountType = {
-  Otim: "otim",
-  Bank: "bank",
-  Ephemeral: "ephemeral",
-  Custodian: "custodian",
-  Wallet: "wallet"
+import { z as z$1 } from "zod";
+
+//#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
-import { z } from "zod";
-var ContactSchema = z.object({
-  userId: z.string(),
-  name: z.string(),
-  address: z.string(),
-  createdAt: z.string(),
-  updatedAt: z.string()
+//#endregion
+//#region src/schemas/contact.ts
+const ContactSchema = z$1.object({
+	userId: z$1.string(),
+	name: z$1.string(),
+	address: z$1.string(),
+	createdAt: z$1.string(),
+	updatedAt: z$1.string()
 });
-var ContactsSchema = z.array(ContactSchema);
-
-// src/schemas/instruction.ts
-import { z as z3 } from "zod";
+const ContactsSchema = z$1.array(ContactSchema);
 
-// src/schemas/misc.ts
-import { z as z2 } from "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) => z2.string().regex(regex, message);
-var nonEmptyStringSchema = z2.string().min(1);
-var numberSchema = z2.union([
-  z2.number().finite(),
-  z2.string().regex(/^-?\d*\.?\d+(?:[eE][-+]?\d+)?$/).transform(Number)
-]);
-var decimalStringSchema = z2.string().regex(/^-?\d*\.?\d+$/).refine((val) => !isNaN(parseFloat(val)), {
-  message: "Must be a valid decimal number"
-});
-var bigintSchema = z2.union([
-  z2.bigint(),
-  z2.string().regex(/^-?\d+$/).transform(BigInt)
-]);
-var hexStringSchema = z2.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) => z$1.string().regex(regex, message);
+const nonEmptyStringSchema = z$1.string().min(1);
+const numberSchema = z$1.union([z$1.number().finite(), z$1.string().regex(/^-?\d*\.?\d+(?:[eE][-+]?\d+)?$/).transform(Number)]);
+const decimalStringSchema = z$1.string().regex(/^-?\d*\.?\d+$/).refine((val) => !isNaN(parseFloat(val)), { message: "Must be a valid decimal number" });
+const bigintSchema = z$1.union([z$1.bigint(), z$1.string().regex(/^-?\d+$/).transform(BigInt)]);
+const hexStringSchema = z$1.string().startsWith("0x").transform((val) => val);
+const chainIdSchema = z$1.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 = z2.object({
-  v: z2.number(),
-  r: z2.string(),
-  s: z2.string()
+const sortValues = Object.values(Sort);
+const vrsSchema = z$1.object({
+	v: z$1.number(),
+	r: z$1.string(),
+	s: z$1.string()
 });
-var eip2098SignatureSchema = z2.object({
-  yParity: z2.number(),
-  r: z2.string(),
-  s: z2.string()
+const eip2098SignatureSchema = z$1.object({
+	yParity: z$1.number(),
+	r: z$1.string(),
+	s: z$1.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 = z3.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 = z$1.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 = z3.enum(instructionActionValues);
-var InstructionScheduleStartType = {
-  Now: "now",
-  DateTime: "datetime"
+const instructionActionValues = Object.values(InstructionAction);
+const instructionActionSchema = z$1.enum(instructionActionValues);
+const InstructionScheduleStartType = {
+	Now: "now",
+	DateTime: "datetime"
 };
-var instructionScheduleStartValues = Object.values(
-  InstructionScheduleStartType
-);
-var baseStartSchema = z3.object({
-  type: z3.enum(instructionScheduleStartValues)
-});
-var nowStartSchema = baseStartSchema.extend({
-  type: z3.literal(InstructionScheduleStartType.Now)
-});
-var dateTimeStartSchema = baseStartSchema.extend({
-  type: z3.literal(InstructionScheduleStartType.DateTime),
-  startDate: dateStandardSchema,
-  startTime: z3.string()
+const instructionScheduleStartValues = Object.values(InstructionScheduleStartType);
+const baseStartSchema = z$1.object({ type: z$1.enum(instructionScheduleStartValues) });
+const nowStartSchema = baseStartSchema.extend({ type: z$1.literal(InstructionScheduleStartType.Now) });
+const dateTimeStartSchema = baseStartSchema.extend({
+	type: z$1.literal(InstructionScheduleStartType.DateTime),
+	startDate: dateStandardSchema,
+	startTime: z$1.string()
 });
-var instructionScheduleStartSchema = z3.discriminatedUnion("type", [
-  nowStartSchema,
-  dateTimeStartSchema
-]);
-var InstructionScheduleRepeatType = {
-  UntilDeactivated: "until-deactivated",
-  MaxExecutions: "max-executions"
+const instructionScheduleStartSchema = z$1.discriminatedUnion("type", [nowStartSchema, dateTimeStartSchema]);
+const InstructionScheduleRepeatType = {
+	UntilDeactivated: "until-deactivated",
+	MaxExecutions: "max-executions"
 };
-var instructionScheduleRepeatValues = Object.values(
-  InstructionScheduleRepeatType
-);
-var baseRepeatSchema = z3.object({});
-var untilDeactivatedRepeatSchema = baseRepeatSchema.extend({
-  type: z3.literal(InstructionScheduleRepeatType.UntilDeactivated)
+const instructionScheduleRepeatValues = Object.values(InstructionScheduleRepeatType);
+const baseRepeatSchema = z$1.object({});
+const untilDeactivatedRepeatSchema = baseRepeatSchema.extend({ type: z$1.literal(InstructionScheduleRepeatType.UntilDeactivated) });
+const maxExecutionsRepeatSchema = baseRepeatSchema.extend({
+	type: z$1.literal(InstructionScheduleRepeatType.MaxExecutions),
+	maxExecutions: numberSchema
 });
-var maxExecutionsRepeatSchema = baseRepeatSchema.extend({
-  type: z3.literal(InstructionScheduleRepeatType.MaxExecutions),
-  maxExecutions: numberSchema
-});
-var instructionScheduleRepeatSchema = z3.discriminatedUnion("type", [
-  untilDeactivatedRepeatSchema,
-  maxExecutionsRepeatSchema
-]);
-var InstructionScheduleRetryType = {
-  UntilDeactivated: "until-deactivated",
-  TimeLimited: "time-limited"
+const instructionScheduleRepeatSchema = z$1.discriminatedUnion("type", [untilDeactivatedRepeatSchema, maxExecutionsRepeatSchema]);
+const InstructionScheduleRetryType = {
+	UntilDeactivated: "until-deactivated",
+	TimeLimited: "time-limited"
 };
-var instructionScheduleRetryValues = Object.values(
-  InstructionScheduleRetryType
-);
-var baseRetrySchema = z3.object({});
-var untilDeactivatedRetrySchema = baseRetrySchema.extend({
-  type: z3.literal(InstructionScheduleRetryType.UntilDeactivated)
-});
-var timeLimitedRetrySchema = baseRetrySchema.extend({
-  type: z3.literal(InstructionScheduleRetryType.TimeLimited),
-  retryCount: numberSchema
+const instructionScheduleRetryValues = Object.values(InstructionScheduleRetryType);
+const baseRetrySchema = z$1.object({});
+const untilDeactivatedRetrySchema = baseRetrySchema.extend({ type: z$1.literal(InstructionScheduleRetryType.UntilDeactivated) });
+const timeLimitedRetrySchema = baseRetrySchema.extend({
+	type: z$1.literal(InstructionScheduleRetryType.TimeLimited),
+	retryCount: numberSchema
 });
-var instructionScheduleRetrySchema = z3.discriminatedUnion("type", [
-  untilDeactivatedRetrySchema,
-  timeLimitedRetrySchema
-]);
-var TimeUnit = {
-  None: "none",
-  Second: "second",
-  Minute: "minute",
-  Hour: "hour",
-  Day: "day",
-  Week: "week",
-  Month: "month"
+const instructionScheduleRetrySchema = z$1.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 = z3.enum(timeUnitValues);
-var instructionExecutionStateSchema = z3.object({
-  executionStatus: instructionStateSchema.optional(),
-  executionCounter: z3.number().int().optional(),
-  lastExecuted: z3.number().int().optional()
+const timeUnitValues = Object.values(TimeUnit);
+const timeUnitSchema = z$1.enum(timeUnitValues);
+const instructionExecutionStateRawSchema = z$1.object({
+	execution_status: instructionStateSchema.optional(),
+	execution_counter: z$1.number().int().optional(),
+	last_executed: z$1.number().int().optional()
 });
-var instructionSchema = z3.object({
-  instructionId: hexStringSchema,
-  createdAt: z3.number().optional(),
-  startAt: z3.string().nullish(),
-  interval: z3.number().nullish(),
-  timeout: z3.number().nullish(),
-  maxExecutions: z3.number().nullish(),
-  executionState: instructionExecutionStateSchema.optional(),
-  actionName: z3.string().optional(),
-  arguments: z3.any(),
-  nickname: z3.string().nullish(),
-  lastInstructedValue: z3.string().optional(),
-  lastErrorCode: z3.number().nullish(),
-  lastErrorMessage: z3.string().nullish(),
-  totalInstructedValue: z3.string().optional(),
-  instructedTokenAddress: hexStringSchema.nullish(),
-  chainId: z3.number().nullish(),
-  chain: z3.string().optional()
+const instructionExecutionStateSchema = instructionExecutionStateRawSchema.transform((data) => ({
+	executionStatus: data.execution_status,
+	executionCounter: data.execution_counter,
+	lastExecuted: data.last_executed
+}));
+const instructionSchema = z$1.object({
+	instructionId: hexStringSchema,
+	createdAt: z$1.number().optional(),
+	startAt: z$1.string().nullish(),
+	interval: z$1.number().nullish(),
+	timeout: z$1.number().nullish(),
+	maxExecutions: z$1.number().nullish(),
+	executionState: instructionExecutionStateSchema,
+	actionName: z$1.string().optional(),
+	arguments: z$1.any(),
+	nickname: z$1.string().nullish(),
+	lastInstructedValue: z$1.string().optional(),
+	lastErrorCode: z$1.number().nullish(),
+	lastErrorMessage: z$1.string().nullish(),
+	totalInstructedValue: z$1.string().optional(),
+	instructedTokenAddress: hexStringSchema.nullish(),
+	chainId: z$1.number().nullish(),
+	chain: z$1.string().optional()
 });
-var instructionsSchema = z3.array(instructionSchema);
-var instructionSummarySchema = z3.object({
-  instructionId: hexStringSchema,
-  chainId: z3.number().int(),
-  executionCount: z3.number().int(),
-  onTimeCount: z3.number().int(),
-  lateCount: z3.number().int(),
-  wasActivatedDuring: z3.boolean(),
-  amount: z3.number().default(0),
-  instructedValue: z3.string().nullish().default("0"),
-  instructedTokenAddress: z3.string().nullish().default(null)
+const instructionsSchema = z$1.array(instructionSchema);
+const instructionSummarySchema = z$1.object({
+	instructionId: hexStringSchema,
+	chainId: z$1.number().int(),
+	executionCount: z$1.number().int(),
+	onTimeCount: z$1.number().int(),
+	lateCount: z$1.number().int(),
+	wasActivatedDuring: z$1.boolean(),
+	amount: z$1.number().default(0),
+	instructedValue: z$1.string().nullish().default("0"),
+	instructedTokenAddress: z$1.string().nullish().default(null)
 });
-var instructionSummariesSchema = z3.array(instructionSummarySchema);
-var instructionSummariesByDateSchema = z3.record(
-  z3.string(),
-  instructionSummariesSchema
-);
-var InstructionViewTimescale = {
-  Days: "days",
-  Hours: "hours",
-  Minutes: "minutes",
-  Seconds: "seconds"
+const instructionSummariesSchema = z$1.array(instructionSummarySchema);
+const instructionSummariesByDateSchema = z$1.record(z$1.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
-import { z as z4 } from "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 = z4.object({
-  id: z4.string(),
-  fromUserId: z4.string().nullable().optional(),
-  toUserId: z4.string().nullable().optional(),
-  payerAddress: z4.string().nullable().optional(),
-  ephemeralWalletAddress: z4.string(),
-  ephemeralWalletId: z4.string().optional(),
-  instructions: z4.object({
-    ids: z4.array(z4.string()),
-    completionIds: z4.array(z4.string())
-  }).optional(),
-  metadata: z4.record(z4.string(), z4.unknown()).optional(),
-  // UI-derived fields
-  status: z4.union([
-    z4.literal(PaymentStatus.Due),
-    z4.literal(PaymentStatus.NotDue),
-    z4.literal(PaymentStatus.Paid)
-  ]),
-  dueDate: z4.string(),
-  amountDue: z4.number(),
-  note: z4.string().nullable().optional(),
-  address: z4.string().nullable().optional(),
-  addedOn: z4.string(),
-  source: z4.union([
-    z4.literal(PaymentSource.Bill),
-    z4.literal(PaymentSource.Stripe),
-    z4.literal(PaymentSource.Clio),
-    z4.literal(PaymentSource.QuickBooks)
-  ]).nullish(),
-  attachmentUrl: z4.string().url().nullable().optional(),
-  attachmentName: z4.string().nullable().optional(),
-  fromAccountAddress: z4.string().nullable().optional()
+const paymentSchema = z$1.object({
+	id: z$1.string(),
+	fromUserId: z$1.string().nullable().optional(),
+	toUserId: z$1.string().nullable().optional(),
+	payerAddress: z$1.string().nullable().optional(),
+	ephemeralWalletAddress: z$1.string(),
+	ephemeralWalletId: z$1.string().optional(),
+	instructions: z$1.object({
+		ids: z$1.array(z$1.string()),
+		completionIds: z$1.array(z$1.string())
+	}).optional(),
+	metadata: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	status: z$1.union([
+		z$1.literal(PaymentStatus.Due),
+		z$1.literal(PaymentStatus.NotDue),
+		z$1.literal(PaymentStatus.Paid)
+	]),
+	dueDate: z$1.string(),
+	amountDue: z$1.number(),
+	note: z$1.string().nullable().optional(),
+	address: z$1.string().nullable().optional(),
+	addedOn: z$1.string(),
+	source: z$1.union([
+		z$1.literal(PaymentSource.Bill),
+		z$1.literal(PaymentSource.Stripe),
+		z$1.literal(PaymentSource.Clio),
+		z$1.literal(PaymentSource.QuickBooks)
+	]).nullish(),
+	attachmentUrl: z$1.string().url().nullable().optional(),
+	attachmentName: z$1.string().nullable().optional(),
+	fromAccountAddress: z$1.string().nullable().optional()
 });
-var PaymentsSchema = z4.array(paymentSchema);
+const PaymentsSchema = z$1.array(paymentSchema);
 
-// src/schemas/token.ts
-import { z as z5 } from "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 = z5.enum(TokenValues);
+const TokenValues = Object.values(Token);
+const tokenSchema = z$1.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
-import { z as z6 } from "zod";
-var transactionSchema = z6.object({
-  instructionId: instructionIdSchema,
-  transactionHash: hexStringSchema.optional(),
-  blockHash: z6.string().nullable(),
-  transactionStatus: z6.string(),
-  error: z6.string().nullish(),
-  startedAt: z6.string(),
-  startedAtBlock: z6.number(),
-  finishedAt: z6.string().nullable(),
-  finishedAtBlock: z6.number().nullable(),
-  amount: z6.object({ value: z6.number(), token: z6.string() }).nullish(),
-  instructedValue: z6.string(),
-  instructedTokenAddress: z6.string().nullable(),
-  executionNum: z6.number(),
-  chainId: z6.number().nullish(),
-  chain: z6.string().optional()
-});
-var transactionWithValidAmountSchema = transactionSchema.extend({
-  amount: z6.object({
-    value: z6.number(),
-    token: z6.string()
-  })
+//#endregion
+//#region src/schemas/transaction.ts
+const transactionSchema = z$1.object({
+	instructionId: instructionIdSchema,
+	transactionHash: hexStringSchema.optional(),
+	blockHash: z$1.string().nullable(),
+	transactionStatus: z$1.string(),
+	error: z$1.string().nullish(),
+	startedAt: z$1.string(),
+	startedAtBlock: z$1.number(),
+	finishedAt: z$1.string().nullable(),
+	finishedAtBlock: z$1.number().nullable(),
+	amount: z$1.object({
+		value: z$1.number(),
+		token: z$1.string()
+	}).nullish(),
+	instructedValue: z$1.string(),
+	instructedTokenAddress: z$1.string().nullable(),
+	executionNum: z$1.number(),
+	chainId: z$1.number().nullish(),
+	chain: z$1.string().optional()
 });
-var transactionsSchema = z6.array(transactionSchema);
+const transactionWithValidAmountSchema = transactionSchema.extend({ amount: z$1.object({
+	value: z$1.number(),
+	token: z$1.string()
+}) });
+const transactionsSchema = z$1.array(transactionSchema);
 
-// src/schemas/user.ts
-import { z as z7 } from "zod";
-var entityIdSchema = z7.string().uuid();
-var addressSchema = z7.string().regex(/^0x[a-fA-F0-9]{40}$/).transform((v) => v.toLowerCase());
-var userPreferencesSchema = z7.object({
-  chainId: z7.number().optional(),
-  tokenSymbol: z7.string().optional(),
-  localCurrency: z7.string().optional()
+//#endregion
+//#region src/schemas/user.ts
+const entityIdSchema = z$1.string().uuid();
+const addressSchema = z$1.string().regex(/^0x[a-fA-F0-9]{40}$/).transform((v) => v.toLowerCase());
+const userPreferencesSchema = z$1.object({
+	chainId: z$1.number().optional(),
+	tokenSymbol: z$1.string().optional(),
+	localCurrency: z$1.string().optional()
 });
-var userSchema = z7.object({
-  id: entityIdSchema,
-  address: addressSchema,
-  createdAt: z7.string(),
-  updatedAt: z7.string(),
-  preferences: userPreferencesSchema.optional(),
-  isDeveloper: z7.boolean(),
-  developerPublicKey: z7.string().nullable().optional()
+const userSchema = z$1.object({
+	id: entityIdSchema,
+	address: addressSchema,
+	email: z$1.string().email().nullable().optional(),
+	createdAt: z$1.string(),
+	updatedAt: z$1.string(),
+	preferences: userPreferencesSchema.optional(),
+	isDeveloper: z$1.boolean(),
+	developerPublicKey: z$1.string().nullable().optional()
 });
-export {
-  AccountType,
-  ContactSchema,
-  ContactsSchema,
-  DATE_ISO_8601_REGEX,
-  DATE_REGEX,
-  DATE_STANDARD_REGEX,
-  InstructionAction,
-  InstructionScheduleRepeatType,
-  InstructionScheduleRetryType,
-  InstructionScheduleStartType,
-  InstructionState,
-  InstructionViewTimescale,
-  PaymentSource,
-  PaymentStatus,
-  PaymentsSchema,
-  Sort,
-  TIME_REGEX,
-  TimeUnit,
-  Token,
-  TokenValues,
-  addressSchema,
-  assertInstructionAction,
-  assertToken,
-  assertsOptionalToken,
-  bigintSchema,
-  dateISO8601Schema,
-  dateSchema,
-  dateStandardSchema,
-  decimalStringSchema,
-  eip2098SignatureSchema,
-  entityIdSchema,
-  hexStringSchema,
-  instructionActionSchema,
-  instructionActionValues,
-  instructionExecutionStateSchema,
-  instructionIdSchema,
-  instructionScheduleRepeatSchema,
-  instructionScheduleRepeatValues,
-  instructionScheduleRetrySchema,
-  instructionScheduleRetryValues,
-  instructionScheduleStartSchema,
-  instructionScheduleStartValues,
-  instructionSchema,
-  instructionStateSchema,
-  instructionStateValues,
-  instructionSummariesByDateSchema,
-  instructionSummariesSchema,
-  instructionSummarySchema,
-  instructionViewTimescaleValues,
-  instructionsSchema,
-  nonEmptyStringSchema,
-  numberSchema,
-  paymentRequestSourceValues,
-  paymentSchema,
-  regexSchema,
-  sortValues,
-  timeSchema,
-  timeUnitSchema,
-  timeUnitValues,
-  tokenSchema,
-  transactionSchema,
-  transactionWithValidAmountSchema,
-  transactionsSchema,
-  userPreferencesSchema,
-  userSchema,
-  vrsSchema
-};
-//# sourceMappingURL=index.mjs.map
+
+//#endregion
+export { AccountConnectionStatus, AccountType, ContactSchema, ContactsSchema, DATE_ISO_8601_REGEX, DATE_REGEX, DATE_STANDARD_REGEX, InstructionAction, InstructionScheduleRepeatType, InstructionScheduleRetryType, InstructionScheduleStartType, InstructionState, InstructionViewTimescale, PaymentSource, PaymentStatus, PaymentsSchema, Sort, TIME_REGEX, TimeUnit, Token, TokenValues, addressSchema, assertInstructionAction, assertToken, assertsOptionalToken, bigintSchema, chainIdSchema, dateISO8601Schema, dateSchema, dateStandardSchema, decimalStringSchema, eip2098SignatureSchema, entityIdSchema, hexStringSchema, instructionActionSchema, instructionActionValues, instructionExecutionStateSchema, instructionIdSchema, instructionScheduleRepeatSchema, instructionScheduleRepeatValues, instructionScheduleRetrySchema, instructionScheduleRetryValues, instructionScheduleStartSchema, instructionScheduleStartValues, instructionSchema, instructionStateSchema, instructionStateValues, instructionSummariesByDateSchema, instructionSummariesSchema, instructionSummarySchema, instructionViewTimescaleValues, instructionsSchema, nonEmptyStringSchema, numberSchema, paymentRequestSourceValues, paymentSchema, regexSchema, sortValues, timeSchema, timeUnitSchema, timeUnitValues, tokenSchema, transactionSchema, transactionWithValidAmountSchema, transactionsSchema, userPreferencesSchema, userSchema, vrsSchema };
+//# sourceMappingURL=index.mjs.map