@dalmore/api-contracts 1.0.7 → 1.0.8

package/src/common/types/transaction.types.ts

@@ -0,0 +1,198 @@
+import { TypeID } from 'typeid-js';
+import {
+  dateSchema,
+  InvestorAccountType,
+  numberPrecisionSchema,
+} from './common.types';
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { accountIdSchema } from './account.types';
+import {
+  paymentMethodIdSchema,
+  PaymentMethodProvider,
+  PaymentMethodResponse,
+} from './payment-methods.types';
+import { tradeIdSchema, TradeZod } from './trade.types';
+import {
+  IInvestorAccount,
+  investorAccountIdSchema,
+} from './investor-account.types';
+import { TransactionStatus, TransactionType } from './common.types';
+export { TransactionStatus, TransactionType };
+
+export enum RefundPaymentMethod {
+  CHECK = 'CHECK',
+  WIRE = 'WIRE',
+  CREDIT_CARD = 'CREDIT_CARD',
+}
+
+export const transactionIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'transaction';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid transaction ID format. Must be a valid TypeID with "transaction" prefix. ex: transaction_00041061050r3gg28a1c60t3gf`,
+  },
+);
+
+export const TransactionZod = IBaseEntity.extend({
+  id: transactionIdSchema,
+  accountId: accountIdSchema,
+  type: z.nativeEnum(TransactionType),
+  provider: z.nativeEnum(PaymentMethodProvider),
+  status: z.nativeEnum(TransactionStatus),
+  tid: z.string().nullable(),
+  amount: z.number(),
+  currencyCode: z.string(),
+  tradeId: z.lazy(() => tradeIdSchema).nullable(),
+  paymentMethodId: z.lazy(() => paymentMethodIdSchema).nullable(),
+  paymentMethod: z
+    .lazy(() => PaymentMethodResponse)
+    .optional()
+    .nullable(),
+  trade: z
+    .lazy(() => TradeZod)
+    .optional()
+    .nullable(),
+  errorMessage: z.string().nullable(),
+  description: z.string().nullable(),
+  chargedAt: dateSchema.nullable().optional(),
+  totalPaidBalance: z.number().nullable().optional(),
+});
+export type TransactionZod = z.infer<typeof TransactionZod>;
+
+export const PostTransactionZod = z.object({
+  tid: z.string().min(3).max(64).openapi({ example: 'TXN8A7B6C5' }),
+  type: z
+    .nativeEnum(TransactionType)
+    .openapi({ example: TransactionType.CHARGE }),
+  amount: numberPrecisionSchema(
+    2,
+    z.number().min(0.01).max(9999999999),
+  ).openapi({ example: 2000 }),
+  tradeId: z
+    .lazy(() => tradeIdSchema)
+    .openapi({
+      example: 'trade_01j5y5ghx5fg68d663j1fvy2x7',
+    }),
+  paymentMethodId: z
+    .lazy(() => paymentMethodIdSchema)
+    .openapi({
+      example: 'payment_method_01j5y5ghx5fg68d663j1fvy2x7',
+    }),
+  chargedAt: dateSchema,
+  status: z.nativeEnum(TransactionStatus),
+  currencyCode: z
+    .string()
+    .length(3)
+    .nullable()
+    .optional()
+    .openapi({ example: 'USD' }),
+});
+export type PostTransactionZod = z.infer<typeof PostTransactionZod>;
+
+export const InvestorPostTransactionZod = z.object({
+  tid: z.string().min(3).max(64).openapi({ example: 'TXN8A7B6C5' }),
+  tradeId: z
+    .lazy(() => tradeIdSchema)
+    .openapi({
+      example: 'trade_01j5y5ghx5fg68d663j1fvy2x7',
+    }),
+  name: z.string().min(1).max(255).openapi({ example: 'John Doe' }),
+  chargedAt: dateSchema,
+  amount: numberPrecisionSchema(
+    2,
+    z.number().positive().max(9999999999),
+  ).openapi({ example: 2000 }),
+});
+
+export type InvestorPostTransactionZod = z.infer<
+  typeof InvestorPostTransactionZod
+>;
+
+export const refundTransactionIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'refund_transaction';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid refund transaction ID format. Must be a valid TypeID with "refund_transaction" prefix. ex: refund_transaction_00041061050r3gg28a1c60t3gf`,
+  },
+);
+
+export const RefundTransactionZod = IBaseEntity.extend({
+  id: refundTransactionIdSchema,
+  status: z.nativeEnum(TransactionStatus),
+  type: z.nativeEnum(TransactionType),
+  amount: z.number(),
+  transactionId: transactionIdSchema,
+  transaction: z
+    .lazy(() => TransactionZod)
+    .optional()
+    .nullable(),
+  payeeId: z.lazy(() => investorAccountIdSchema),
+  payee: z.lazy(() => IInvestorAccount).optional(),
+  payeeType: z.nativeEnum(InvestorAccountType),
+  payeePaymentMethod: z.nativeEnum(RefundPaymentMethod),
+  tid: z.string().nullable(),
+  notes: z.string().nullable(),
+  refundedAt: z.date().nullable(),
+  settledAt: z.date().nullable(),
+  voidedAt: z.date().nullable(),
+  errorMessage: z.string().nullable(),
+});
+
+export type RefundTransactionZod = z.infer<typeof RefundTransactionZod>;
+
+export const GetRefundResponseZod = RefundTransactionZod.extend({
+  transactionBalance: z.number(),
+});
+
+export type GetRefundResponseZod = z.infer<typeof GetRefundResponseZod>;
+
+export const CreateRefundZod = z.object({
+  transactionId: transactionIdSchema,
+  amount: numberPrecisionSchema(
+    2,
+    z.number().positive().max(999999999),
+  ).openapi({ example: 500 }),
+  notes: z.string().max(1000).nullable().optional().openapi({
+    example: 'Partial refund for customer request',
+  }),
+});
+export type CreateRefundZod = z.infer<typeof CreateRefundZod>;
+
+export const UpdateRefundZod = z.object({
+  status: z.nativeEnum(TransactionStatus).openapi({
+    example: TransactionStatus.SETTLED,
+  }),
+  notes: z.string().max(1000).nullable().optional().openapi({
+    example: 'Refund processed successfully',
+  }),
+});
+export type UpdateRefundZod = z.infer<typeof UpdateRefundZod>;
+
+export const GetTransactionRefundsResponseZod = z.object({
+  refunds: z.array(RefundTransactionZod),
+  totalRefunded: z.number(),
+  refundableBalance: z.number(),
+});
+export type GetTransactionRefundsResponseZod = z.infer<
+  typeof GetTransactionRefundsResponseZod
+>;
+
+export const ComplianceTransactionQueryZod = z.object({
+  accountId: accountIdSchema,
+});
+export type ComplianceTransactionQueryZod = z.infer<
+  typeof ComplianceTransactionQueryZod
+>;

package/src/common/types/trusted-contact.types.ts

@@ -0,0 +1,122 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { IPaginationMeta, TrustedContactRelationship } from './common.types';
+import { PhoneZodSchema } from './phone.type';
+import { AddressSchema } from './address.types';
+import { investorAccountIdSchema } from './investor-account.types';
+import { PhoneNumberData } from './sms.types';
+
+extendZodWithOpenApi(z);
+
+export const trustedContactIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'trusted_contact';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid trusted contact ID format. Must be a valid TypeID with "trusted_contact" prefix.',
+  },
+);
+const trustedContactsInclude = z.enum(['investorAccount']);
+/**
+ * @description Query parameters for including related entities
+ * @example in contract us as -> query: z.object({}).merge(TrustedContactsIncludeQuery),
+ */
+export const TrustedContactsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          trustedContactsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${trustedContactsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${trustedContactsInclude.options.join(',')}`,
+    }),
+});
+
+export const ITrustedContactZod = IBaseEntity.extend({
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
+  email: z.string().email().nullable(),
+  phone: PhoneNumberData.nullable(),
+  address: z.string().nullable(),
+  address2: z.string().nullable(),
+  city: z.string().nullable(),
+  state: z.string().nullable(),
+  zip: z.string().nullable(),
+  country: z.string().nullable(),
+  relationship: z.nativeEnum(TrustedContactRelationship),
+});
+
+export type ITrustedContactZod = z.infer<typeof ITrustedContactZod>;
+
+export const PostTrustedContactZod = z
+  .object({
+    firstName: z.string().min(1).max(255).openapi({ example: 'John' }),
+    lastName: z.string().min(1).max(255).openapi({ example: 'Doe' }),
+    email: z.string().email().openapi({ example: 'john.doe@example.com' }),
+    phone: PhoneZodSchema.nullable().optional(),
+    relationship: z
+      .nativeEnum(TrustedContactRelationship)
+      .nullable()
+      .default(TrustedContactRelationship.OTHER)
+      .openapi({
+        example: TrustedContactRelationship.CHILD,
+      }),
+    investorAccountId: z.lazy(() => investorAccountIdSchema),
+  })
+  .and(AddressSchema);
+
+export type PostTrustedContactZod = z.infer<typeof PostTrustedContactZod>;
+
+export const PatchTrustedContactZod = z
+  .object({
+    firstName: z
+      .string()
+      .min(1)
+      .max(255)
+      .optional()
+      .openapi({ example: 'John' }),
+    lastName: z.string().min(1).max(255).optional().openapi({ example: 'Doe' }),
+    email: z
+      .string()
+      .email()
+      .optional()
+      .openapi({ example: 'john.doe@example.com' }),
+    phone: PhoneZodSchema.nullable().optional(),
+    relationship: z.nativeEnum(TrustedContactRelationship).optional().openapi({
+      example: TrustedContactRelationship.CHILD,
+    }),
+  })
+  .and(AddressSchema);
+
+export type PatchTrustedContactZod = z.infer<typeof PatchTrustedContactZod>;
+
+export const IPaginatedTrustedContact = z.object({
+  items: z.array(ITrustedContactZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedTrustedContact = z.infer<typeof IPaginatedTrustedContact>;
+
+export const GetTrustedContactFilters = z.object({
+  search: z.string().optional().openapi({ example: 'John' }),
+  relationship: z
+    .nativeEnum(TrustedContactRelationship)
+    .openapi({ example: TrustedContactRelationship.CHILD }),
+  investorAccountId: z.lazy(() => investorAccountIdSchema).optional(),
+});
+export type GetTrustedContactFilters = z.infer<typeof GetTrustedContactFilters>;

package/src/common/types/typography.types.ts

@@ -0,0 +1,75 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { z } from 'zod';
+
+extendZodWithOpenApi(z);
+
+export enum WebSafeFonts {
+  // Sans-Serif Fonts
+  Arial = 'Arial',
+  Helvetica = 'Helvetica',
+  Verdana = 'Verdana',
+  Tahoma = 'Tahoma',
+  TrebuchetMS = 'Trebuchet MS',
+  SegoeUI = 'Segoe UI',
+  GillSans = 'Gill Sans',
+  CenturyGothic = 'Century Gothic',
+  LucidaSans = 'Lucida Sans',
+
+  // Serif Fonts
+  TimesNewRoman = 'Times New Roman',
+  Georgia = 'Georgia',
+  Palatino = 'Palatino',
+  Baskerville = 'Baskerville',
+  Garamond = 'Garamond',
+  Bookman = 'Bookman',
+  Perpetua = 'Perpetua',
+  CalistoMT = 'Calisto MT',
+
+  // Monospace Fonts
+  CourierNew = 'Courier New',
+  Consolas = 'Consolas',
+  Monaco = 'Monaco',
+  LucidaConsole = 'Lucida Console',
+  AndaleMono = 'Andale Mono',
+  Menlo = 'Menlo',
+
+  // Decorative Fonts
+  ComicSans = 'Comic Sans MS',
+  Impact = 'Impact',
+  Charcoal = 'Charcoal',
+  Papyrus = 'Papyrus',
+
+  // System Fonts
+  SystemUI = 'system-ui',
+  AppleSystem = '-apple-system',
+  BlinkMacSystemFont = 'BlinkMacSystemFont',
+  DroidSans = 'Droid Sans',
+  NotoSans = 'Noto Sans',
+  Futura = 'Futura',
+
+  // Web-Friendly Fonts
+  OpenSans = 'Open Sans',
+  Roboto = 'Roboto',
+  Lato = 'Lato',
+  Poppins = 'Poppins',
+  Montserrat = 'Montserrat',
+  Oswald = 'Oswald',
+  Nunito = 'Nunito',
+  SourceSansPro = 'Source Sans Pro',
+
+  // Cursive Fonts
+  Pacifico = 'Pacifico',
+  BrushScript = 'Brush Script MT',
+  SnellRoundhand = 'Snell Roundhand',
+  LucidaHandwriting = 'Lucida Handwriting',
+
+  // Fantasy Fonts
+  Jokerman = 'Jokerman',
+  Broadway = 'Broadway',
+  Harrington = 'Harrington',
+}
+
+export const typographySchema = z
+  .nativeEnum(WebSafeFonts)
+  .optional()
+  .openapi({ example: WebSafeFonts.Arial });

package/src/common/types/user-manual.types.ts

@@ -0,0 +1,290 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import {
+  IPaginationMeta,
+  PaginationOptionsZod,
+  PortalType,
+  UserManualType,
+} from './common.types';
+import { IBaseEntity } from './entity.types';
+
+extendZodWithOpenApi(z);
+
+export const userManualCategorySchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'user_manual_category';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid user manual category ID format. Must be a valid TypeID with "user_manual_category" prefix.',
+  },
+);
+
+export const userManualPageSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'user_manual_page';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid user manual page ID format. Must be a valid TypeID with "user_manual_page" prefix.',
+  },
+);
+
+export const userManualPageUrlSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'user_manual_page_url';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid user manual page URL ID format. Must be a valid TypeID with "user_manual_page_url" prefix.',
+  },
+);
+
+export const PostUserManualCategoryZod = z.object({
+  name: z.string().min(1).max(255).openapi({ example: 'User Manual' }),
+  site: z.nativeEnum(PortalType).openapi({ example: PortalType.COMPLIANCE }),
+  type: z.nativeEnum(UserManualType).openapi({ example: UserManualType.FAQ }),
+});
+
+export type PostUserManualCategoryZod = z.infer<
+  typeof PostUserManualCategoryZod
+>;
+
+export const PatchUserManualCategoryZod = z.object({
+  name: z
+    .string()
+    .min(1)
+    .max(255)
+    .optional()
+    .openapi({ example: 'User Manual' }),
+  type: z
+    .nativeEnum(UserManualType)
+    .optional()
+    .openapi({ example: UserManualType.FAQ }),
+});
+
+export type PatchUserManualCategoryZod = z.infer<
+  typeof PatchUserManualCategoryZod
+>;
+
+export const PostUserManualPageZod = z.object({
+  question: z
+    .string()
+    .min(1)
+    .max(500)
+    .openapi({ example: 'User Manual Question' }),
+  answer: z
+    .string()
+    .min(1)
+    .max(200000)
+    .openapi({ example: 'User Manual Content' }),
+  userManualCategoryId: userManualCategorySchema.openapi({
+    example: 'user_manual_category_01jatr819xff9s6wek8d2tng3x',
+  }),
+  urls: z
+    .array(z.string().url())
+    .optional()
+    .openapi({ example: ['https://example.com'] }),
+});
+
+export type PostUserManualPageZod = z.infer<typeof PostUserManualPageZod>;
+
+export const PatchUserManualPageZod = z.object({
+  question: z
+    .string()
+    .min(1)
+    .max(500)
+    .optional()
+    .openapi({ example: 'User Manual Question' }),
+  answer: z
+    .string()
+    .min(1)
+    .max(200000)
+    .optional()
+    .openapi({ example: 'User Manual Answer' }),
+  userManualCategoryId: userManualCategorySchema.optional().openapi({
+    example: 'user_manual_category_01jatr819xff9s6wek8d2tng3x',
+  }),
+});
+
+export const UserManualsPaginationOptionsZod = PaginationOptionsZod.extend({
+  page: z.coerce.number().optional().default(1),
+  limit: z.coerce.number().optional().default(100),
+});
+
+export type UserManualsPaginationOptionsZod = z.infer<
+  typeof UserManualsPaginationOptionsZod
+>;
+
+export type PatchUserManualPageZod = z.infer<typeof PatchUserManualPageZod>;
+
+export const PatchUserManualPageUrlZod = z.object({
+  url: z.string().url().openapi({ example: 'https://example.com' }),
+});
+
+export type PatchUserManualPageUrlZod = z.infer<
+  typeof PatchUserManualPageUrlZod
+>;
+
+export const OrderUserManualCategoriesZod = z.object({
+  userManualCategories: z.array(userManualCategorySchema),
+});
+
+export type OrderUserManualCategoriesZod = z.infer<
+  typeof OrderUserManualCategoriesZod
+>;
+
+export const OrderUserManualPagesZod = z.object({
+  userManualPages: z.array(userManualPageSchema),
+});
+
+export type OrderUserManualPagesZod = z.infer<typeof OrderUserManualPagesZod>;
+
+export const IUserManualCategory = IBaseEntity.extend({
+  name: z.string().nullable().optional(),
+  site: z.nativeEnum(PortalType),
+  type: z.nativeEnum(UserManualType),
+  userManualPages: z.array(z.lazy(() => IUserManualPage)),
+  order: z.number().nullable().optional(),
+});
+
+export type IUserManualCategory = z.infer<typeof IUserManualCategory>;
+
+export const IUserManualPage = IBaseEntity.extend({
+  question: z.string().nullable().optional(),
+  answer: z.string().nullable().optional(),
+  userManualCategoryId: userManualCategorySchema.optional().nullable(),
+  userManualCategory: z.lazy(() => IUserManualCategory),
+  order: z.number().nullable().optional(),
+});
+
+export type IUserManualPage = z.infer<typeof IUserManualPage>;
+
+export const IUserManualPageUrl = IBaseEntity.extend({
+  url: z.string().url().optional().nullable(),
+  userManualPageId: userManualPageSchema.optional().nullable(),
+  userManualPage: z
+    .lazy(() => IUserManualPage)
+    .optional()
+    .nullable(),
+});
+
+export type IUserManualPageUrl = z.infer<typeof IUserManualPageUrl>;
+
+export const GetUserManualPagesZod = z.object({
+  categoryId: userManualCategorySchema
+    .optional()
+    .openapi({ example: 'user_manual_category_01jatr819xff9s6wek8d2tng3x' }),
+  search: z.string().optional(),
+  site: z.nativeEnum(PortalType).openapi({ example: PortalType.COMPLIANCE }),
+});
+
+export type GetUserManualPagesZod = z.infer<typeof GetUserManualPagesZod>;
+
+export const GetUserManualCategoryZod = z.object({
+  search: z.string().optional(),
+  site: z.nativeEnum(PortalType).openapi({ example: PortalType.COMPLIANCE }),
+  type: z
+    .nativeEnum(UserManualType)
+    .optional()
+    .openapi({ example: UserManualType.USER_MANUAL }),
+});
+export type GetUserManualCategoryZod = z.infer<typeof GetUserManualCategoryZod>;
+
+export const GetLimitedUserManualCategoryZod = GetUserManualCategoryZod.omit({
+  site: true,
+});
+export type GetLimitedUserManualCategoryZod = z.infer<
+  typeof GetLimitedUserManualCategoryZod
+>;
+export const userManualPagesInclude = z.enum([
+  'userManualCategory',
+  'userManualPageUrls',
+]);
+export const userManualPagesIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          userManualPagesInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${userManualPagesInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${userManualPagesInclude.options.join(',')}`,
+    }),
+});
+
+export const userManualCategoriesInclude = z.enum(['userManualPages']);
+export const userManualCategoriesIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          userManualCategoriesInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${userManualCategoriesInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${userManualCategoriesInclude.options.join(',')}`,
+    }),
+});
+
+export const IPaginatedUserManualCategory = z.object({
+  items: z.array(IUserManualCategory),
+  meta: IPaginationMeta,
+});
+
+export type IPaginatedUserManualCategory = z.infer<
+  typeof IPaginatedUserManualCategory
+>;
+
+export const IPaginatedUserManualPage = z.object({
+  items: z.array(IUserManualPage),
+  meta: IPaginationMeta,
+});
+
+export type IPaginatedUserManualPage = z.infer<typeof IPaginatedUserManualPage>;
+
+export const UserManualOrderResponseZod = z.object({
+  message: z.string(),
+});
+
+export type UserManualOrderResponseZod = z.infer<
+  typeof UserManualOrderResponseZod
+>;
+
+export const PostUserManualPageUrlZod = z.object({
+  userManualPageId: userManualPageUrlSchema.openapi({
+    example: 'user_manual_page_123456789',
+  }),
+  url: z.string().url().openapi({ example: 'https://example.com' }),
+});
+
+export type PostUserManualPageUrlZod = z.infer<typeof PostUserManualPageUrlZod>;