@dalmore/api-contracts 0.0.0-dev.7c97041 → 0.0.0-dev.835d7eb

package/common/types/transaction.types.ts

@@ -1,198 +0,0 @@
-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/common/types/trusted-contact.types.ts

@@ -1,122 +0,0 @@
-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/common/types/typography.types.ts

@@ -1,75 +0,0 @@
-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/common/types/user-manual.types.ts

@@ -1,290 +0,0 @@
-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>;