@dalmore/api-contracts 0.0.0-dev.4c056b7 → 0.0.0-dev.4ddef03

package/common/types/site.types.ts

@@ -1,270 +0,0 @@
-import { z } from 'zod';
-import { IBaseEntity } from './entity.types';
-import { TypeID } from 'typeid-js';
-import {
-  AccountStatus,
-  AccountZod,
-  IPaginationMeta,
-  UrlSchema,
-} from './common.types';
-import { accountIdSchema } from './account.types';
-import { fileIdSchema } from './file.types';
-import { IAsset } from './asset.types';
-import { GetInvestorAccountTypeSettingsZod } from './site-settings.types';
-import { InvestorPageResponseZod, pageIdSchema } from './page.types';
-import { ThemeFileType } from './common.types';
-import { IAccountContact } from './account-contact.types';
-
-export const sitesIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'site';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message: `Invalid site ID format. Must be a valid TypeID with "site" prefix. Example: site_01j5y5ghx5fg68d663j1fvy2x7`,
-  },
-);
-
-export const SiteZod = IBaseEntity.extend({
-  id: sitesIdSchema,
-  accountId: accountIdSchema.nullable(),
-  account: AccountZod.nullable().optional(),
-  title: z.string().nullable(),
-  description: z.string().nullable(),
-  keywords: z.string().nullable(),
-  logo: z.lazy(() => fileIdSchema).nullable(),
-  favicon: z.lazy(() => fileIdSchema).nullable(),
-  backgroundImage: z.lazy(() => fileIdSchema).nullable(),
-  domain: z.string(),
-  customDomain: z.string().nullable(),
-  enabled: z.boolean().default(false),
-  message: z.string().nullable(),
-  withPersonaThemeId: z.string().nullable(),
-  gaIds: z.array(z.string()).nullable(),
-  investorAccountTypes: z
-    .object({
-      individual: z.boolean(),
-      joint: z.boolean(),
-      entity: z.boolean(),
-      retirement: z.boolean(),
-    })
-    .nullable(),
-  tagline: z.string().nullable(),
-  supportEmail: z.string(),
-  senderEmail: z.string(),
-  trackingPixelCode: z.string().nullable(),
-  conversionPixelCode: z.string().nullable(),
-  demoEmail: z.string().nullable(),
-  demoPassword: z.string().nullable(),
-  publicOfferings: z.boolean().default(false),
-  publicPages: z.boolean().default(false),
-  publicDataRooms: z.boolean().default(false),
-});
-export type SiteZod = z.infer<typeof SiteZod>;
-
-export const SitesParamSchema = z.object({
-  id: sitesIdSchema,
-});
-
-export const SitesFiltersZod = z.object({
-  url: z.string().optional(),
-  accountId: accountIdSchema.optional(),
-  enabled: z.preprocess(
-    (val) =>
-      val === 'true' || val === '1'
-        ? true
-        : val === 'false' || val === '0'
-          ? false
-          : val,
-    z.boolean().optional(),
-  ),
-});
-
-const sitesInclude = z.enum(['account']);
-export const SitesIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          sitesInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${sitesInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${sitesInclude.options.join(',')}`,
-    }),
-});
-export interface SitesIncludeQuery extends z.infer<typeof SitesIncludeQuery> {}
-
-export const SitesPaginated = z.object({
-  items: z.array(SiteZod),
-  meta: IPaginationMeta,
-});
-
-/**
- * Zod schema for validating a DNS CNAME record response from Cloudflare's API.
- *
- * This schema defines the structure of a CNAME DNS record response from Cloudflare,
- * including metadata, settings, and record-specific details. It is based on the API
- * specification for DNS records.
- *
- * For more details on the API response structure, see:
- * @see {@link https://developers.cloudflare.com/api/resources/dns/subresources/records/models/cname_record/#(schema) Cloudflare CNAME Record Schema Documentation
- *
- ***/
-export const CloudflareRecordResponse = z.object({
-  comment: z.string().optional(), // Comments or notes about the DNS record. This field has no effect on DNS responses.
-  content: z.string().optional(), // A valid hostname. Must not match the record's name.
-  name: z.string().optional(), // DNS record name (or @ for the zone apex) in Punycode.
-  proxied: z.boolean().optional(), // Whether the record is receiving the performance and security benefits of Cloudflare.
-  settings: z
-    .object({
-      flatten_cname: z.boolean().optional(), // If enabled, causes the CNAME record to be resolved externally and the resulting address records (e.g., A and AAAA) to be returned instead of the CNAME record itself. This setting is unavailable for proxied records, since they are always flattened.
-      ipv4_only: z.boolean().optional(), // When enabled, only A records will be generated, and AAAA records will not be created. This setting is intended for exceptional cases. Note that this option only applies to proxied records and it has no effect on whether Cloudflare communicates with the origin using IPv4 or IPv6.
-      ipv6_only: z.boolean().optional(), // When enabled, only AAAA records will be generated, and A records will not be created. This setting is intended for exceptional cases. Note that this option only applies to proxied records and it has no effect on whether Cloudflare communicates with the origin using IPv4 or IPv6.
-    })
-    .optional(), // Settings for the DNS record.
-  tags: z.array(z.string().optional()), // Custom tags for the DNS record. This field has no effect on DNS responses.
-  ttl: z.number().optional(), // Time To Live (TTL) of the DNS record in seconds. Setting to 1 means 'automatic'. Value must be between 60 and 86400, with the minimum reduced to 30 for Enterprise zones.
-  type: z.enum(['CNAME']).optional(), // Record type.
-  id: z.string(), // Identifier
-  created_on: z.string(), // When the record was created.
-  meta: z.unknown().optional(), // Extra Cloudflare-specific information about the record,
-  modified_on: z.string(), // When the record was last modified.
-  proxiable: z.boolean(), // Whether the record can be proxied by Cloudflare or not.
-  comment_modified_on: z.string().optional(), // When the record comment was last modified. Omitted if there is no comment.
-  tags_modified_on: z.string().optional(), // When the record tags were last modified. Omitted if there are no tags.
-});
-export type CloudflareRecordResponse = z.infer<typeof CloudflareRecordResponse>;
-
-/**
- * Zod schema for validating Cloudflare API response information.
- *
- * This schema defines the structure of the response info object from Cloudflare APIs, including
- * a numeric code and a message string.
- *
- * @see {@link https://developers.cloudflare.com/api/resources/$shared/models/response_info/#(schema) Cloudflare API Response Info Schema}
- */
-export const CloudflareResponseInfoZod = z.object({
-  code: z.number(),
-  message: z.string(),
-});
-
-export type CloudflareResponseInfoZod = z.infer<
-  typeof CloudflareResponseInfoZod
->;
-
-/**
- * Zod schema for validating a response from the Cloudflare DNS Records API.
- *
- * For more details on the API response structure, see the Cloudflare documentation:
- * @see {@link https://developers.cloudflare.com/api/resources/dns/subresources/records/methods/create/ Cloudflare DNS Records API - Create Method}
- */
-export const CloudflareResponseZod = z.object({
-  errors: z.array(CloudflareResponseInfoZod),
-  messages: z.array(CloudflareResponseInfoZod),
-  success: z.boolean(),
-  result: CloudflareRecordResponse,
-});
-export type CloudflareResponseZod = z.infer<typeof CloudflareResponseZod>;
-
-export enum OperationType {
-  CREATE = 'CREATE',
-  UPDATE = 'UPDATE',
-  RETRIEVE = 'RETRIEVE',
-}
-
-export const SiteUrlsZod = z.object({
-  backgroundImage: z.string().nullable(),
-  favicon: z.string().nullable(),
-  logo: z.string().nullable(),
-  title: z.string().nullable(),
-  description: z.string().nullable(),
-  keywords: z.string().nullable(),
-  withPersonaThemeId: z.string().nullable(),
-  siteId: z.string().nullable(),
-  tagline: z.string().nullable(),
-});
-export type SiteUrlsZod = z.infer<typeof SiteUrlsZod>;
-
-export const DownloadThemeFileZod = z.object({
-  type: z.nativeEnum(ThemeFileType).openapi({ example: ThemeFileType.LIGHT }),
-  url: UrlSchema,
-});
-
-export type DownloadThemeFileZod = z.infer<typeof DownloadThemeFileZod>;
-
-export const SiteUrlZod = z.object({
-  url: UrlSchema,
-});
-export type SiteUrlZod = z.infer<typeof SiteUrlZod>;
-
-export const VerifyPasswordZod = z.object({
-  password: z.string(),
-});
-export type VerifyPasswordZod = z.infer<typeof VerifyPasswordZod>;
-
-export const VerifyPasswordResponseZod = z.object({
-  success: z.boolean(),
-});
-export type VerifyPasswordResponseZod = z.infer<
-  typeof VerifyPasswordResponseZod
->;
-
-export const SiteConfigsZod = z.object({
-  id: z.string(),
-  name: z.string(),
-  accountId: accountIdSchema,
-  withPersonaThemeId: z.string().nullable(),
-  gaIds: z.array(z.string()).nullable(),
-  heroAsset: z.lazy(() => IAsset).nullable(),
-  investorAccountSettings: GetInvestorAccountTypeSettingsZod.nullable(),
-  tagline: z.string().nullable(),
-  senderEmail: z.string(),
-  landingPageId: pageIdSchema.nullable(),
-  landingPage: z.lazy(() => InvestorPageResponseZod).nullable(),
-  trackingPixelCode: z.string().nullable(),
-  conversionPixelCode: z.string().nullable(),
-  publicOfferings: z.boolean().default(false),
-  publicPages: z.boolean().default(false),
-  publicDataRooms: z.boolean().default(false),
-  themeCss: z.string().nullable().optional(),
-  demoEmail: z.string().nullable(),
-  demoPassword: z.string().nullable(),
-  accountContacts: z.array(IAccountContact).nullable().optional(),
-  status: z.nativeEnum(AccountStatus),
-});
-export type SiteConfigsZod = z.infer<typeof SiteConfigsZod>;
-
-/**
- * Cloudflare Turnstile server-side validation response schema.
- * Handles both successful and failed responses.
- *
- * @see {@link https://developers.cloudflare.com/turnstile/get-started/server-side-validation/ Cloudflare Turnstile Server-side Validation}
- */
-export const CloudflareTurnstileResponseZod = z.object({
-  success: z.boolean(),
-  'error-codes': z.array(z.string()).optional(),
-  challenge_ts: z.string().datetime().optional(),
-  hostname: z.string().optional(),
-  action: z.string().optional(),
-  cdata: z.string().optional(),
-  metadata: z
-    .object({
-      ephemeral_id: z.string(),
-    })
-    .optional(),
-});
-
-export type CloudflareTurnstileResponseZod = z.infer<
-  typeof CloudflareTurnstileResponseZod
->;

package/common/types/sms.types.ts

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-
-/**
- * @description list of supported country codes.. Informs supported sms functionality.
- */
-export const SupportedCountryCodes = ['US'] as const;
-
-/**
- * @description list of supported country schemas. Informs supported sms functionality.
- */
-export const SupportedCountryCodesSchema = z.enum([...SupportedCountryCodes]);
-
-/**
- * @description list of supported two factor methods.
- */
-export enum TwoFactorMethod {
-  NONE = 'NONE',
-  AUTHENTICATOR = 'AUTHENTICATOR',
-  SMS = 'SMS',
-}
-
-export const PhoneNumberData = z.object({
-  countryCallingCode: z.string(),
-  country: z.string(),
-  nationalNumber: z.string(),
-  number: z.string(),
-  formatNational: z.string(),
-  formatInternational: z.string(),
-});
-export type PhoneNumberData = z.infer<typeof PhoneNumberData>;

package/common/types/state-machine.types.ts

@@ -1,177 +0,0 @@
-import { z } from 'zod';
-import { AicZod } from './aic.types';
-import { FileZod } from './file.types';
-import {
-  TradeStatus,
-  TransactionType,
-  TransactionStatus,
-} from './common.types';
-import { typeid } from 'typeid-js';
-
-export enum StateMachineType {
-  AIC_VALIDATION = 'AIC_VALIDATION',
-  FILE_REVIEW = 'FILE_REVIEW',
-  FINALIZE_TRADE = 'FINALIZE_TRADE',
-}
-
-export enum StateMachineEvents {
-  START = 'START',
-  STEP_FORWARD = 'STEP_FORWARD',
-  COMPLETE = 'COMPLETE',
-}
-
-export enum StateMachineTags {
-  CAN_PROGRESS = 'CAN_PROGRESS',
-}
-
-export const BaseStateMachineStates = {
-  IDLE: 'IDLE',
-  COMPLETED: 'COMPLETED',
-  DONE: 'DONE',
-} as const;
-
-export type BaseStateMachineStatesType = typeof BaseStateMachineStates;
-
-// Simplified schema for FINALIZE_TRADE state machine payload
-// Frontend sends minimal data, we transform it to Trade entity structure
-const FinalizeTradePayloadZod = z
-  .object({
-    txnChargedAmount: z.number(),
-    totalAmount: z.number().nullable().optional(),
-    tradeStatus: z.nativeEnum(TradeStatus),
-    transactions: z
-      .array(
-        z.object({
-          type: z.nativeEnum(TransactionType),
-          status: z.nativeEnum(TransactionStatus),
-          amount: z.number(),
-          refundTransactions: z
-            .array(
-              z.object({
-                type: z.nativeEnum(TransactionType),
-                status: z.nativeEnum(TransactionStatus),
-                amount: z.number(),
-              }),
-            )
-            .optional()
-            .nullable()
-            .default([]),
-        }),
-      )
-      .optional()
-      .nullable()
-      .default([]),
-  })
-  .transform((data) => {
-    return {
-      id: typeid('trade').toString(),
-      txnChargedAmount: data.txnChargedAmount || null,
-      tradeStatus: data.tradeStatus,
-      totalAmount: data.txnChargedAmount || null,
-      adjustments: [],
-      transactions: (data.transactions || []).map((txn) => ({
-        id: typeid('transaction').toString(),
-        type: txn.type,
-        status: txn.status,
-        amount: txn.amount,
-        tradeId: typeid('trade').toString(),
-        refundTransactions: (txn.refundTransactions || []).map((refund) => ({
-          id: typeid('refund_transaction').toString(),
-          type: refund.type,
-          status: refund.status,
-          amount: refund.amount,
-          transactionId: typeid('transaction').toString(),
-        })),
-      })),
-    };
-  });
-export type FinalizeTradePayloadZod = z.infer<typeof FinalizeTradePayloadZod>;
-
-export const CreateStateMachineConfigurationZod = z.discriminatedUnion('type', [
-  z.object({
-    name: z.string(),
-    description: z.string(),
-    type: z.literal(StateMachineType.AIC_VALIDATION),
-    payload: AicZod,
-  }),
-  z.object({
-    type: z.literal(StateMachineType.FILE_REVIEW),
-    name: z.string(),
-    description: z.string(),
-    payload: FileZod,
-  }),
-  z.object({
-    type: z.literal(StateMachineType.FINALIZE_TRADE),
-    name: z.string(),
-    description: z.string(),
-    payload: FinalizeTradePayloadZod,
-  }),
-]);
-export type CreateStateMachineConfigurationZod = z.infer<
-  typeof CreateStateMachineConfigurationZod
->;
-
-export const StateMachineConfigurationZod = z.object({
-  id: z.string(),
-  name: z.string(),
-  description: z.string(),
-  type: z.nativeEnum(StateMachineType),
-  payload: z.record(z.string(), z.any()),
-});
-
-export type StateMachineConfigurationZod = z.infer<
-  typeof StateMachineConfigurationZod
->;
-
-export const StartStateMachineZod = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal(StateMachineType.AIC_VALIDATION),
-    payload: AicZod,
-    debugMode: z.boolean().optional().default(false),
-  }),
-  z.object({
-    type: z.literal(StateMachineType.FILE_REVIEW),
-    payload: FileZod,
-    debugMode: z.boolean().optional().default(false),
-  }),
-  z.object({
-    type: z.literal(StateMachineType.FINALIZE_TRADE),
-    payload: FinalizeTradePayloadZod,
-    debugMode: z.boolean().optional().default(false),
-  }),
-]);
-export type StartStateMachineZod = z.infer<typeof StartStateMachineZod>;
-
-export const DebugStateMachineZod = z.object({
-  sessionId: z.string(),
-});
-export type DebugStateMachineZod = z.infer<typeof DebugStateMachineZod>;
-
-export const StateMachineTransitionZod = z.object({
-  to: z.string(),
-  from: z.string(),
-  timestamp: z.string(),
-});
-export type StateMachineTransitionZod = z.infer<
-  typeof StateMachineTransitionZod
->;
-
-export const StateMachineResponseZod = z.object({
-  sessionId: z.string(),
-  currentState: z.string(),
-  error: z.string().optional(),
-  transitionHistory: z.array(StateMachineTransitionZod),
-  isCompleted: z.boolean(),
-  isDebugMode: z.boolean(),
-  canTransition: z.boolean(),
-});
-export type StateMachineResponseZod = z.infer<typeof StateMachineResponseZod>;
-
-export const StateMachineSessionZod = z.object({
-  id: z.string(),
-  type: z.nativeEnum(StateMachineType),
-  persistedSnapshot: z.string().nullable(),
-  payload: z.record(z.string(), z.any()),
-  debugMode: z.boolean(),
-});
-export type StateMachineSessionZod = z.infer<typeof StateMachineSessionZod>;

package/common/types/states.types.ts

@@ -1,163 +0,0 @@
-import { z } from 'zod';
-import { CountryCode, CountryEnumSchema } from './countries.types';
-
-const StateSchema = z.object({
-  code: z.string().length(2),
-  name: z.string(),
-});
-type State = z.infer<typeof StateSchema>;
-
-const StatesSchema = z.array(StateSchema);
-
-export const states: State[] = [
-  { code: 'AL', name: 'Alabama' },
-  { code: 'AK', name: 'Alaska' },
-  { code: 'AZ', name: 'Arizona' },
-  { code: 'AR', name: 'Arkansas' },
-  { code: 'CA', name: 'California' },
-  { code: 'CO', name: 'Colorado' },
-  { code: 'CT', name: 'Connecticut' },
-  { code: 'DE', name: 'Delaware' },
-  { code: 'FL', name: 'Florida' },
-  { code: 'GA', name: 'Georgia' },
-  { code: 'HI', name: 'Hawaii' },
-  { code: 'ID', name: 'Idaho' },
-  { code: 'IL', name: 'Illinois' },
-  { code: 'IN', name: 'Indiana' },
-  { code: 'IA', name: 'Iowa' },
-  { code: 'KS', name: 'Kansas' },
-  { code: 'KY', name: 'Kentucky' },
-  { code: 'LA', name: 'Louisiana' },
-  { code: 'ME', name: 'Maine' },
-  { code: 'MD', name: 'Maryland' },
-  { code: 'MA', name: 'Massachusetts' },
-  { code: 'MI', name: 'Michigan' },
-  { code: 'MN', name: 'Minnesota' },
-  { code: 'MS', name: 'Mississippi' },
-  { code: 'MO', name: 'Missouri' },
-  { code: 'MT', name: 'Montana' },
-  { code: 'NE', name: 'Nebraska' },
-  { code: 'NV', name: 'Nevada' },
-  { code: 'NH', name: 'New Hampshire' },
-  { code: 'NJ', name: 'New Jersey' },
-  { code: 'NM', name: 'New Mexico' },
-  { code: 'NY', name: 'New York' },
-  { code: 'NC', name: 'North Carolina' },
-  { code: 'ND', name: 'North Dakota' },
-  { code: 'OH', name: 'Ohio' },
-  { code: 'OK', name: 'Oklahoma' },
-  { code: 'OR', name: 'Oregon' },
-  { code: 'PA', name: 'Pennsylvania' },
-  { code: 'RI', name: 'Rhode Island' },
-  { code: 'SC', name: 'South Carolina' },
-  { code: 'SD', name: 'South Dakota' },
-  { code: 'TN', name: 'Tennessee' },
-  { code: 'TX', name: 'Texas' },
-  { code: 'UT', name: 'Utah' },
-  { code: 'VT', name: 'Vermont' },
-  { code: 'VA', name: 'Virginia' },
-  { code: 'WA', name: 'Washington' },
-  { code: 'WV', name: 'West Virginia' },
-  { code: 'WI', name: 'Wisconsin' },
-  { code: 'WY', name: 'Wyoming' },
-];
-const validatedStates = StatesSchema.parse(states);
-
-const stateEnum = states.reduce(
-  (acc, state) => {
-    acc[state.code] = state.code;
-    return acc;
-  },
-  {} as Record<string, string>,
-);
-
-export const StateCode = Object.freeze(stateEnum);
-
-/**
- * Finds a state by its code
- *
- * @param {string} code the state code
- * @returns {State | undefined} the state or undefined
- * @example findStateByCode('CA') => { code: 'CA', name: 'California' }
- * @example findStateByCode('XX') => undefined
- */
-function findStateByCode(code: string): State | undefined {
-  return validatedStates.find((state) => state.code === code.toUpperCase());
-}
-
-export { StatesSchema, findStateByCode, validatedStates };
-export type { State };
-
-export const canadaProvinces = [
-  { name: 'Alberta', code: 'AB' },
-  { name: 'British Columbia', code: 'BC' },
-  { name: 'Manitoba', code: 'MB' },
-  { name: 'New Brunswick', code: 'NB' },
-  { name: 'Newfoundland and Labrador', code: 'NL' },
-  { name: 'Nova Scotia', code: 'NS' },
-  { name: 'Ontario', code: 'ON' },
-  { name: 'Prince Edward Island', code: 'PE' },
-  { name: 'Quebec', code: 'QC' },
-  { name: 'Saskatchewan', code: 'SK' },
-  { name: 'Northwest Territories', code: 'NT' },
-  { name: 'Nunavut', code: 'NU' },
-  { name: 'Yukon', code: 'YT' },
-];
-
-const canadaProvinceEnum = canadaProvinces.reduce(
-  (acc, province) => {
-    acc[province.code] = province.code;
-    return acc;
-  },
-  {} as Record<string, string>,
-);
-
-export const CanadaProvinceCode = Object.freeze(canadaProvinceEnum);
-
-export function refineAddressState(
-  country: string | undefined | null,
-  state: string | undefined | null,
-) {
-  {
-    if (country === CountryCode['US'])
-      return z.nativeEnum(StateCode).nullable().optional().safeParse(state)
-        .success;
-    if (country === CountryCode['CA'])
-      return z
-        .nativeEnum(CanadaProvinceCode)
-        .nullable()
-        .optional()
-        .safeParse(state).success;
-    return z.string().min(2).max(35).nullable().optional().safeParse(state)
-      .success;
-  }
-}
-
-export const CountryStateSchema = z
-  .object({
-    country: CountryEnumSchema.nullable().optional(),
-    state: z.string().nullable().optional(),
-  })
-  .refine(({ state, country }) => refineAddressState(country, state), {
-    message: `state value is not valid. It should be 2 uppercase letters representing the valid state for the country.`,
-  });
-
-export const RequiredCountryStateSchema = z
-  .object({
-    country: CountryEnumSchema,
-    state: z.string(),
-  })
-  .refine(
-    ({ state, country }) => {
-      if (country === CountryCode['US']) {
-        return z.nativeEnum(StateCode).safeParse(state).success;
-      }
-      if (country === CountryCode['CA']) {
-        return z.nativeEnum(CanadaProvinceCode).safeParse(state).success;
-      }
-      return z.string().min(2).max(35).safeParse(state).success;
-    },
-    {
-      message: `state value is not valid. It should be 2 uppercase letters representing the valid state for the country.`,
-    },
-  );

package/common/types/subdoc-preview.types.ts

@@ -1,35 +0,0 @@
-import { z } from 'zod';
-import { IBaseEntity } from './entity.types';
-import { SignatureStatus } from './common.types';
-import { SignerDataSchema } from './signer.types';
-
-export const ISubDocPreview = IBaseEntity.extend({
-  templateId: z.string().min(1).max(36),
-  signers: z.array(SignerDataSchema).nullable(),
-  documentId: z.string().min(1).max(36).nullable(),
-  signatureUrl: z.string().min(1).max(255).nullable(),
-  errors: z.string().nullable(),
-  status: z.nativeEnum(SignatureStatus),
-  jointStatus: z.nativeEnum(SignatureStatus),
-});
-export type ISubDocPreview = z.infer<typeof ISubDocPreview>;
-
-export const CreateSubDocPreview = z.object({
-  templateId: z.string().min(1).max(36),
-  subDocPreviewData: z.record(z.string()),
-});
-export type CreateSubDocPreview = z.infer<typeof CreateSubDocPreview>;
-
-export const CreateSubDocPreviewResponse = z.object({ documentId: z.string() });
-export type CreateSubDocPreviewResponse = z.infer<
-  typeof CreateSubDocPreviewResponse
->;
-
-export const SubDocPreviewFormFields = z.array(
-  z.object({
-    id: z.string().min(1).max(255),
-    type: z.string().min(1).max(255),
-    options: z.array(z.string()).optional(),
-  }),
-);
-export type SubDocPreviewFormFields = z.infer<typeof SubDocPreviewFormFields>;