@dalmore/api-contracts 1.0.5 → 1.0.6

package/src/common/types/data-record.types.ts

@@ -0,0 +1,325 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+import { dataRoomIdSchema } from './data-room.types';
+import { fileIdSchema } from './file.types';
+import { BaseStatus, IPaginationMeta } from './common.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+extendZodWithOpenApi(z);
+
+export const dataRecordIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'data_record';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid data_record ID format. Must be a valid TypeID with "data_record" prefix.',
+  },
+);
+
+export const dataRecordFileIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'data_record_file';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid data_record_file ID format. Must be a valid TypeID with "data_record" prefix.',
+  },
+);
+
+const dataRecordsInclude = z.enum(['dataRecordFiles', 'children']);
+
+/**
+ * @description Query parameters for including related entities
+ * @example in contract us as -> query: z.object({}).merge(DataRecordsIncludeQuery),
+ */
+export const DataRecordsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          dataRecordsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${dataRecordsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${dataRecordsInclude.options.join(',')}`,
+    }),
+});
+export interface DataRecordsIncludeQuery
+  extends z.infer<typeof DataRecordsIncludeQuery> {}
+
+export const DataRecordFileZod = IBaseEntity.extend({
+  dataRecordId: z.lazy(() => dataRecordIdSchema),
+  fileId: fileIdSchema.nullable(),
+});
+export type DataRecordFileZod = z.infer<typeof DataRecordFileZod>;
+
+export enum DataRecordType {
+  FOLDER = 'FOLDER',
+}
+
+export const DataRecordZod = IBaseEntity.extend({
+  name: z.string(),
+  type: z.nativeEnum(DataRecordType),
+  parentId: z.string().nullable(),
+  children: z.array(z.lazy(() => DataRecordZod)).openapi({
+    example: [
+      {
+        id: 'data_record_01jghnncbmfkpre0ybqv0n8017',
+        name: 'Record 1',
+        type: 'FOLDER',
+        parentId: 'data_record_01jghnncbmfkpre0ybqv0n8017',
+        children: [],
+        dataRecordFiles: [],
+        dataRoomId: 'data_room_01jghn6n7mep5a5q0t60ndzya6',
+      },
+    ],
+  }),
+  dataRecordFiles: z.array(DataRecordFileZod),
+  dataRoomId: z.lazy(() => dataRoomIdSchema),
+});
+export type DataRecordZod = z.infer<typeof DataRecordZod>;
+
+export const IPaginatedDataRecords = z.object({
+  items: z.array(DataRecordZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedDataRecords = z.infer<typeof IPaginatedDataRecords>;
+
+export const RecordPathResponse = z.object({
+  records: z.array(DataRecordZod),
+  path: z.string().openapi({ example: '/folder_1/folder_2/target_record' }),
+});
+export type RecordPathResponse = z.infer<typeof RecordPathResponse>;
+
+export const PostDataRecordFolder = z.object({
+  name: z.string().min(1).max(255),
+  dataRoomId: z.lazy(() => dataRoomIdSchema),
+  parentId: dataRecordIdSchema,
+});
+export type PostDataRecordFolder = z.infer<typeof PostDataRecordFolder>;
+
+export const DeleteDataRecordFolder = z.object({
+  folderId: dataRecordIdSchema,
+  force: z.boolean().default(false),
+});
+export type DeleteDataRecordFolder = z.infer<typeof DeleteDataRecordFolder>;
+
+export const MoveDataRecordFolder = z.object({
+  folderId: dataRecordIdSchema,
+  targetFolderId: dataRecordIdSchema,
+});
+export type MoveDataRecordFolder = z.infer<typeof MoveDataRecordFolder>;
+
+export const PostDataRecordFile = z.object({
+  dataRecordId: dataRecordIdSchema,
+});
+export type PostDataRecordFile = z.infer<typeof PostDataRecordFile>;
+
+export const PatchDataRecordFile = z.object({
+  fileId: fileIdSchema,
+});
+export type PatchDataRecordFile = z.infer<typeof PatchDataRecordFile>;
+
+export const DeleteDataRecordFile = z.object({
+  dataRecordId: dataRecordIdSchema,
+  fileId: fileIdSchema,
+});
+export type DeleteDataRecordFile = z.infer<typeof DeleteDataRecordFile>;
+
+export const MoveDataRecordFile = z.object({
+  sourceFolderId: dataRecordIdSchema,
+  targetFolderId: dataRecordIdSchema,
+  fileId: fileIdSchema,
+});
+export type MoveDataRecordFile = z.infer<typeof MoveDataRecordFile>;
+
+export const PatchDataRecordFolder = z.object({
+  name: z.string().min(1).max(255),
+});
+export type PatchDataRecordFolder = z.infer<typeof PatchDataRecordFolder>;
+
+type IBaseEntityType = z.infer<typeof IBaseEntity>;
+
+export interface BaseDataRecordStructure extends IBaseEntityType {
+  name: string;
+  type: DataRecordType;
+  parentId: string | null;
+  dataRoomId: string;
+  dataRecordFiles?: DataRecordFileZod[] | undefined;
+  data?: BaseDataRecordStructure[] | undefined;
+}
+
+export const DataRecordStructureZod: z.ZodType<BaseDataRecordStructure> = z
+  .lazy(() =>
+    IBaseEntity.extend({
+      name: z.string().min(1).max(255),
+      type: z.nativeEnum(DataRecordType),
+      parentId: z.string().nullable(),
+      dataRoomId: z.string(),
+      dataRecordFiles: z.array(DataRecordFileZod).optional(),
+      data: z.array(z.lazy(() => DataRecordStructureZod)).optional(),
+      isPasswordProtected: z.boolean(),
+    }),
+  )
+  .openapi({
+    example: {
+      createdAt: '2025-01-01T19:31:04.725Z',
+      updatedAt: '2025-01-01T19:50:28.979Z',
+      deletedAt: null,
+      id: 'data_record_01jghnk8wxeb6sc3aqphtdjk9e',
+      name: 'Folder 1 Updated',
+      type: 'FOLDER',
+      parentId: null,
+      dataRoomId: 'data_room_01jghn6n7mep5a5q0t60ndzya6',
+      dataRecordFiles: [
+        {
+          createdAt: '2025-01-01T21:55:45.048Z',
+          updatedAt: '2025-01-01T21:55:45.048Z',
+          deletedAt: null,
+          id: 'data_record_file_01jghxw5ryfrev868psy5m2kkd',
+          dataRecordId: 'data_record_01jghnk8wxeb6sc3aqphtdjk9e',
+          fileId: 'file_01jghxv0eae8rttq5rw2arry34',
+          file: {
+            createdAt: '2025-01-01T21:55:06.528Z',
+            updatedAt: '2025-01-01T21:55:06.528Z',
+            deletedAt: null,
+            id: 'file_01jghxv0eae8rttq5rw2arry34',
+            tid: null,
+            url: 'https://dalmoredatafactory.blob.core.windows.net/api-files-public-dev/1735768506533.trade_01jghn5866f3ev3xe7a82ykqbn.test.pdf',
+            fileType: 'application/pdf',
+            fileName: 'test.pdf',
+            name: 'test',
+            category: 'test',
+            label: 'label',
+            extractedData: null,
+            targetTable: 'TRADES',
+            targetId: 'trade_01jghn5866f3ev3xe7a82ykqbn',
+            linkedFrom: null,
+            accountId: 'account_01jghn57a5e0wvz5q4t9a9fzj5',
+            userId: 'user_01jghn57pgfpsvqczcvz6pmv50',
+            __entity: 'File',
+          },
+          __entity: 'DataRecordFile',
+        },
+      ],
+      __entity: 'DataRecord',
+      data: [
+        {
+          createdAt: '2025-01-01T19:32:13.779Z',
+          updatedAt: '2025-01-01T19:32:13.779Z',
+          deletedAt: null,
+          id: 'data_record_01jghnncbmfkpre0ybqv0n8017',
+          name: 'Folder 1.1',
+          type: 'FOLDER',
+          parentId: 'data_record_01jghnk8wxeb6sc3aqphtdjk9e',
+          dataRoomId: 'data_room_01jghn6n7mep5a5q0t60ndzya6',
+          dataRecordFiles: [],
+          __entity: 'DataRecord',
+          data: [
+            {
+              createdAt: '2025-01-01T20:42:54.458Z',
+              updatedAt: '2025-01-01T20:42:54.458Z',
+              deletedAt: null,
+              id: 'data_record_01jghspsmgff8a6sjc7b78s1dx',
+              name: 'Folder 1.2',
+              type: 'FOLDER',
+              parentId: 'data_record_01jghnncbmfkpre0ybqv0n8017',
+              dataRoomId: 'data_room_01jghn6n7mep5a5q0t60ndzya6',
+              dataRecordFiles: [],
+              __entity: 'DataRecord',
+              data: [],
+            },
+          ],
+        },
+      ],
+    },
+  });
+export type DataRecordStructureZod = z.infer<typeof DataRecordStructureZod>;
+
+export const DataRecordsFilters = z.object({
+  search: z.string().max(50).optional(),
+  parentId: dataRecordIdSchema.optional(),
+  dataRoomId: z.lazy(() => dataRoomIdSchema).optional(),
+  status: z.nativeEnum(BaseStatus).optional(),
+});
+export type DataRecordsFilters = z.infer<typeof DataRecordsFilters>;
+
+export const FolderSummaryZod = DataRecordZod.extend({
+  childCount: z.number(),
+  fileCount: z.number(),
+  descendantCount: z.number(),
+});
+export type FolderSummaryZod = z.infer<typeof FolderSummaryZod>;
+
+export const NavigationContextZod = z.object({
+  isRoot: z.boolean(),
+  depth: z.number(),
+  hasChildren: z.boolean(),
+  currentPath: z.string(),
+  parentPath: z.string(),
+  context: z.object({
+    dataRoomName: z.string(),
+    currentFolderName: z.string(),
+    parentFolderName: z.string().nullable(),
+  }),
+});
+export type NavigationContextZod = z.infer<typeof NavigationContextZod>;
+
+export const NavigationSummaryZod = z
+  .object({
+    currentFolder: FolderSummaryZod,
+    parentFolder: FolderSummaryZod.nullable(),
+    siblings: z.array(FolderSummaryZod),
+    children: z.array(FolderSummaryZod),
+    totalDescendants: z.number(),
+    navigation: NavigationContextZod,
+  })
+  .openapi({
+    example: {
+      currentFolder: {
+        id: 'data_record_01jgjdkne6fbf9bwerypvkd2b5',
+        name: 'Folder 1',
+        type: 'FOLDER',
+        parentId: null,
+        dataRoomId: 'data_room_01jgjdk1zse759qsb8ma5w9q42',
+        childCount: 2,
+        fileCount: 0,
+        descendantCount: 3,
+        dataRecordFiles: [],
+      },
+      parentFolder: null,
+      siblings: [],
+      children: [],
+      totalDescendants: 3,
+      navigation: {
+        isRoot: true,
+        depth: 0,
+        hasChildren: true,
+        currentPath: 'Folder 1',
+        parentPath: '',
+        context: {
+          dataRoomName: 'Test Data Room',
+          currentFolderName: 'Folder 1',
+          parentFolderName: null,
+        },
+      },
+    },
+  });
+export type NavigationSummaryZod = z.infer<typeof NavigationSummaryZod>;

package/src/common/types/data-room.types.ts

@@ -0,0 +1,242 @@
+import { z } from 'zod';
+import {
+  AccountZod,
+  ComplianceReview,
+  IPaginationMeta,
+  PaginationOptionsZod,
+  UrlSchema,
+} from './common.types';
+import { TypeID } from 'typeid-js';
+import { accountIdSchema } from './account.types';
+import { IBaseEntity } from './entity.types';
+import { DataRecordStructureZod, DataRecordZod } from './data-record.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { PasswordSchema } from './password.type';
+extendZodWithOpenApi(z);
+
+export const dataRoomIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'data_room';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid data_room ID format. Must be a valid TypeID with "data_room" prefix.',
+  },
+);
+
+const dataRoomsInclude = z.enum(['dataRecords', 'account']);
+
+/**
+ * @description Query parameters for including related entities
+ * @example in contract us as -> query: z.object({}).merge(DataRoomsIncludeQuery),
+ */
+export const DataRoomsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          dataRoomsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${dataRoomsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${dataRoomsInclude.options.join(',')}`,
+    }),
+});
+export interface DataRoomsIncludeQuery
+  extends z.infer<typeof DataRoomsIncludeQuery> {}
+
+export const DataRoomZod = IBaseEntity.extend({
+  name: z.string(),
+  accountId: accountIdSchema,
+  account: AccountZod.optional().nullable(),
+  dataRecords: z.array(z.lazy(() => DataRecordZod)).openapi({
+    example: [
+      {
+        id: 'data_record_01jghnncbmfkpre0ybqv0n8017',
+        name: 'Record 1',
+        type: 'FOLDER',
+        parentId: null,
+        children: [],
+        dataRecordFiles: [],
+        dataRoomId: 'data_room_01jghn6n7mep5a5q0t60ndzya6',
+      },
+    ],
+  }),
+});
+export type DataRoomZod = z.infer<typeof DataRoomZod>;
+
+export const IPaginatedDataRooms = z.object({
+  items: z.array(DataRoomZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedDataRooms = z.infer<typeof IPaginatedDataRooms>;
+
+export const DataRoomApprovalsZod = z.object({
+  accountName: z.string(),
+  accountId: accountIdSchema,
+  pendingFilesCount: z.number(),
+});
+export type DataRoomApprovalsZod = z.infer<typeof DataRoomApprovalsZod>;
+
+export const PostDataRoom = z.object({
+  name: z.string().min(2).max(50),
+});
+export type PostDataRoom = z.infer<typeof PostDataRoom>;
+
+export const DeleteDataRoom = z.object({
+  dataRoomId: dataRoomIdSchema,
+  force: z.boolean().default(false),
+});
+export type DeleteDataRoom = z.infer<typeof DeleteDataRoom>;
+
+export const DataRoomsFilters = z.object({
+  search: z.string().max(50).optional(),
+  accountId: accountIdSchema.optional(),
+});
+export type DataRoomsFilters = z.infer<typeof DataRoomsFilters>;
+
+export const InvestorDataRoomsFilters = DataRoomsFilters.omit({
+  accountId: true,
+});
+export type InvestorDataRoomsFilters = z.infer<typeof InvestorDataRoomsFilters>;
+
+export const DataRoomStructureZod = IBaseEntity.extend({
+  name: z.string().min(1).max(255),
+  accountId: accountIdSchema,
+  dataRecords: z.array(DataRecordStructureZod).openapi({
+    example: [
+      {
+        id: 'data_record_01jghnncbmfkpre0ybqv0n8017',
+        name: 'Record 1',
+        type: 'FOLDER',
+        parentId: null,
+        dataRoomId: 'data_room_01jghn6n7mep5a5q0t60ndzya6',
+        data: [
+          {
+            id: 'data_record_01jghnncbmfkpre0ybqv0n53322',
+            name: 'Record 2',
+            type: 'FOLDER',
+            parentId: 'data_record_01jghnncbmfkpre0ybqv0n8017',
+            dataRoomId: 'data_room_01jghn6n7mep5a5q0t60ndzya6',
+            data: [],
+          },
+        ],
+      },
+    ],
+  }),
+  isPasswordProtected: z.boolean(),
+});
+export type DataRoomStructureZod = z.infer<typeof DataRoomStructureZod>;
+
+export const DataRoomFilesSummaryFilterZod = z.object({
+  accountId: accountIdSchema.optional(),
+  status: z.nativeEnum(ComplianceReview),
+});
+
+export type DataRoomFilesSummaryFilterZod = z.infer<
+  typeof DataRoomFilesSummaryFilterZod
+>;
+
+export const DataRoomFileSummary = z.object({
+  fileId: z.string(),
+  fileName: z.string(),
+  fileType: z.string(),
+  complianceReview: z.nativeEnum(ComplianceReview),
+  account: z.object({
+    id: z.string(),
+    name: z.string(),
+  }),
+  dataRoom: z.object({
+    id: z.string(),
+    name: z.string(),
+  }),
+  structure: z.object({
+    path: z.string(),
+  }),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export type DataRoomFileSummary = z.infer<typeof DataRoomFileSummary>;
+
+export const IPaginatedDataRoomFilesSummaryZod = z.object({
+  items: z.array(DataRoomFileSummary),
+  meta: IPaginationMeta,
+});
+export type IPaginatedDataRoomFilesSummaryZod = z.infer<
+  typeof IPaginatedDataRoomFilesSummaryZod
+>;
+
+export const DataRoomsQueryZod = PaginationOptionsZod.and(DataRoomsFilters).and(
+  DataRoomsIncludeQuery,
+);
+
+export type DataRoomsQueryZod = z.infer<typeof DataRoomsQueryZod>;
+
+export const PublicDataRoomFiltersZod = PaginationOptionsZod.merge(
+  DataRoomsFilters,
+)
+  .merge(DataRoomsIncludeQuery)
+  .extend({
+    url: UrlSchema,
+  });
+
+export type PublicDataRoomFiltersZod = z.infer<typeof PublicDataRoomFiltersZod>;
+
+export const PatchDataRoomZod = PostDataRoom.extend({
+  isPasswordProtected: z.boolean().optional(),
+  password: PasswordSchema.optional(),
+}).refine(
+  (data) => {
+    if (data.isPasswordProtected) {
+      return data.password !== undefined;
+    }
+    return true;
+  },
+  {
+    message: 'Password is required when password protection is enabled',
+    path: ['password'],
+  },
+);
+export type PatchDataRoomZod = z.infer<typeof PatchDataRoomZod>;
+
+export const DataRoomPasswordQueryZod = z.object({
+  password: z.string().min(6).optional().openapi({
+    example: 'Secretpassword6#',
+  }),
+});
+export type DataRoomPasswordQueryZod = z.infer<typeof DataRoomPasswordQueryZod>;
+
+export const GetDataRoomQueryZod = DataRoomsIncludeQuery.merge(
+  DataRoomPasswordQueryZod,
+);
+export type GetDataRoomQueryZod = z.infer<typeof GetDataRoomQueryZod>;
+
+export const DataRoomZodWithoutPassword = IBaseEntity.extend({
+  name: z.string(),
+  accountId: accountIdSchema,
+  account: AccountZod.optional().nullable(),
+  dataRecords: z.array(z.any()).optional().nullable(),
+  isPasswordProtected: z.boolean(),
+});
+export type DataRoomZodWithoutPassword = z.infer<
+  typeof DataRoomZodWithoutPassword
+>;
+export const IPaginatedDataRoomsWithoutPassword = z.object({
+  items: z.array(DataRoomZodWithoutPassword),
+  meta: IPaginationMeta,
+});
+export type IPaginatedDataRoomsWithoutPassword = z.infer<
+  typeof IPaginatedDataRoomsWithoutPassword
+>;

package/src/common/types/default-theme-config.types.ts

@@ -0,0 +1,87 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { IPaginationMeta } from './common.types';
+import { ITheme, themeIdSchema } from './site-settings.types';
+import { emailThemeIdSchema, IEmailTheme } from './email-theme.types';
+import { IBaseEntity } from './entity.types';
+
+extendZodWithOpenApi(z);
+
+export const defaultThemeConfigIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'default_theme_config';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid default theme config ID format. Must be a valid TypeID with "default_theme_config" prefix. Example: default_theme_config_01j5y5ghx5fg68d663j1fvy2x7`,
+  },
+);
+
+export const IDefaultThemeConfig = IBaseEntity.extend({
+  id: defaultThemeConfigIdSchema,
+  name: z.string().nullable(),
+  themeId: z.lazy(() => themeIdSchema),
+  theme: z
+    .lazy(() => ITheme)
+    .nullable()
+    .optional(),
+  emailThemeId: z.lazy(() => emailThemeIdSchema),
+  emailTheme: z
+    .lazy(() => IEmailTheme)
+    .nullable()
+    .optional(),
+  enabled: z.boolean(),
+});
+
+export type IDefaultThemeConfig = z.infer<typeof IDefaultThemeConfig>;
+
+export const GetDefaultThemeConfig = z.object({
+  id: defaultThemeConfigIdSchema,
+  name: z.string().nullable(),
+  siteThemeName: z.string().nullable(),
+  siteThemeId: z.string(),
+  emailThemeName: z.string().nullable(),
+  emailThemeId: z.string(),
+  enabled: z.boolean(),
+  primaryColor: z.string().nullable(),
+  primaryTextColor: z.string().nullable(),
+  secondaryColor: z.string().nullable(),
+  secondaryTextColor: z.string().nullable(),
+});
+
+export type GetDefaultThemeConfig = z.infer<typeof GetDefaultThemeConfig>;
+
+export const IPaginatedDefaultThemeConfigsZod = z.object({
+  items: z.array(GetDefaultThemeConfig),
+  meta: IPaginationMeta,
+});
+
+export type IPaginatedDefaultThemeConfigsZod = z.infer<
+  typeof IPaginatedDefaultThemeConfigsZod
+>;
+
+export const PostDefaultThemeConfigZod = z.object({
+  name: z.string().min(1).max(60),
+  siteThemeId: z.lazy(() => themeIdSchema),
+  emailThemeId: z.lazy(() => emailThemeIdSchema),
+});
+
+export type PostDefaultThemeConfigZod = z.infer<
+  typeof PostDefaultThemeConfigZod
+>;
+
+export const PatchDefaultThemeConfigZod = z.object({
+  name: z.string().min(1).max(60).optional(),
+  themeId: z.lazy(() => themeIdSchema).optional(),
+  emailThemeId: z.lazy(() => emailThemeIdSchema).optional(),
+  enabled: z.boolean().optional(),
+});
+
+export type PatchDefaultThemeConfigZod = z.infer<
+  typeof PatchDefaultThemeConfigZod
+>;

package/src/common/types/disbursement-adjustment.types.ts

@@ -0,0 +1,32 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+
+export const disbursementAdjustmentIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'disbursement_adjustment';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid disbursement adjustment ID format. Must be a valid TypeID with "disbursement_adjustment" prefix.',
+  },
+);
+
+export enum DisbursementAdjustmentType {
+  COMISSION = 'COMISSION',
+  DISBURSEMENT_FEE = 'DISBURSEMENT_FEE',
+  REFUND_POOL = 'REFUND_POOL',
+}
+
+export const PostDisbursementAdjustmentZod = z.object({
+  type: z.nativeEnum(DisbursementAdjustmentType),
+  value: z.number().max(10000000000),
+  description: z.string().max(50),
+});
+export type PostDisbursementAdjustmentZod = z.infer<
+  typeof PostDisbursementAdjustmentZod
+>;