@dalmore/api-contracts 0.0.0-dev.dc7fdf8 → 0.0.0-dev.ddf366c

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

@@ -1,325 +0,0 @@
-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/common/types/data-room.types.ts

@@ -1,242 +0,0 @@
-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/common/types/default-theme-config.types.ts

@@ -1,87 +0,0 @@
-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/common/types/disbursement-adjustment.types.ts

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