feat: wip

packages/trpc/server/document-router/router.ts

@@ -70,20 +70,24 @@ export const documentRouter = router({
     .input(ZCreateDocumentMutationSchema)
     .mutation(async ({ input, ctx }) => {
       try {
-        const { title, documentDataId } = input;
+        const { title, documentDataId, teamId } = input;
 
-        const { remaining } = await getServerLimits({ email: ctx.user.email });
+        // Teams bypass document limits.
+        if (teamId !== undefined) {
+          const { remaining } = await getServerLimits({ email: ctx.user.email });
 
-        if (remaining.documents <= 0) {
-          throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message:
-              'You have reached your document limit for this month. Please upgrade your plan.',
-          });
+          if (remaining.documents <= 0) {
+            throw new TRPCError({
+              code: 'BAD_REQUEST',
+              message:
+                'You have reached your document limit for this month. Please upgrade your plan.',
+            });
+          }
         }
 
         return await createDocument({
           userId: ctx.user.id,
+          teamId,
           title,
           documentDataId,
         });

packages/trpc/server/document-router/schema.ts

@@ -17,6 +17,7 @@ export type TGetDocumentByTokenQuerySchema = z.infer<typeof ZGetDocumentByTokenQ
 export const ZCreateDocumentMutationSchema = z.object({
   title: z.string().min(1),
   documentDataId: z.string().min(1),
+  teamId: z.number().optional(),
 });
 
 export type TCreateDocumentMutationSchema = z.infer<typeof ZCreateDocumentMutationSchema>;

packages/trpc/server/router.ts

@@ -6,6 +6,7 @@ import { profileRouter } from './profile-router/router';
 import { recipientRouter } from './recipient-router/router';
 import { shareLinkRouter } from './share-link-router/router';
 import { singleplayerRouter } from './singleplayer-router/router';
+import { teamRouter } from './team-router/router';
 import { templateRouter } from './template-router/router';
 import { router } from './trpc';
 import { twoFactorAuthenticationRouter } from './two-factor-authentication-router/router';
@@ -19,8 +20,9 @@ export const appRouter = router({
   admin: adminRouter,
   shareLink: shareLinkRouter,
   singleplayer: singleplayerRouter,
-  twoFactorAuthentication: twoFactorAuthenticationRouter,
+  team: teamRouter,
   template: templateRouter,
+  twoFactorAuthentication: twoFactorAuthenticationRouter,
 });
 
 export type AppRouter = typeof appRouter;

packages/trpc/server/team-router/router.ts

@@ -0,0 +1,479 @@
+import { AppError } from '@documenso/lib/errors/app-error';
+import { acceptTeamInvitation } from '@documenso/lib/server-only/team/accept-team-invitation';
+import { addTeamEmailVerification } from '@documenso/lib/server-only/team/add-team-email-verification';
+import { createTeam } from '@documenso/lib/server-only/team/create-team';
+import { createTeamPendingCheckoutSession } from '@documenso/lib/server-only/team/create-team-checkout-session';
+import { createTeamMemberInvites } from '@documenso/lib/server-only/team/create-team-member-invites';
+import { deleteTeam } from '@documenso/lib/server-only/team/delete-team';
+import { deleteTeamEmail } from '@documenso/lib/server-only/team/delete-team-email';
+import { deleteTeamEmailVerification } from '@documenso/lib/server-only/team/delete-team-email-verification';
+import { deleteTeamMemberInvitations } from '@documenso/lib/server-only/team/delete-team-invitations';
+import { deleteTeamMembers } from '@documenso/lib/server-only/team/delete-team-members';
+import { deleteTeamPending } from '@documenso/lib/server-only/team/delete-team-pending';
+import { deleteTeamTransferRequest } from '@documenso/lib/server-only/team/delete-team-transfer-request';
+import { findTeamInvoices } from '@documenso/lib/server-only/team/find-team-invoices';
+import { findTeamMemberInvites } from '@documenso/lib/server-only/team/find-team-member-invites';
+import { findTeamMembers } from '@documenso/lib/server-only/team/find-team-members';
+import { findTeams } from '@documenso/lib/server-only/team/find-teams';
+import { findTeamsPending } from '@documenso/lib/server-only/team/find-teams-pending';
+import { getTeamEmailByEmail } from '@documenso/lib/server-only/team/get-team-email-by-email';
+import { getTeamInvitations } from '@documenso/lib/server-only/team/get-team-invitations';
+import { getTeamMembers } from '@documenso/lib/server-only/team/get-team-members';
+import { getTeamById, getTeams } from '@documenso/lib/server-only/team/get-teams';
+import { leaveTeam } from '@documenso/lib/server-only/team/leave-team';
+import { requestTeamOwnershipTransfer } from '@documenso/lib/server-only/team/request-team-ownership-transfer';
+import { resendTeamEmailVerification } from '@documenso/lib/server-only/team/resend-team-email-verification';
+import { resendTeamMemberInvitation } from '@documenso/lib/server-only/team/resend-team-member-invitation';
+import { updateTeam } from '@documenso/lib/server-only/team/update-team';
+import { updateTeamEmail } from '@documenso/lib/server-only/team/update-team-email';
+import { updateTeamMember } from '@documenso/lib/server-only/team/update-team-member';
+
+import { authenticatedProcedure, router } from '../trpc';
+import {
+  ZAcceptTeamInvitationMutationSchema,
+  ZAddTeamEmailVerificationMutationSchema,
+  ZCreateTeamMemberInvitesMutationSchema,
+  ZCreateTeamMutationSchema,
+  ZCreateTeamPendingCheckoutMutationSchema,
+  ZDeleteTeamEmailMutationSchema,
+  ZDeleteTeamEmailVerificationMutationSchema,
+  ZDeleteTeamMemberInvitationsMutationSchema,
+  ZDeleteTeamMembersMutationSchema,
+  ZDeleteTeamMutationSchema,
+  ZDeleteTeamPendingMutationSchema,
+  ZDeleteTeamTransferRequestMutationSchema,
+  ZFindTeamInvoicesQuerySchema,
+  ZFindTeamMemberInvitesQuerySchema,
+  ZFindTeamMembersQuerySchema,
+  ZFindTeamsPendingQuerySchema,
+  ZFindTeamsQuerySchema,
+  ZGetTeamMembersQuerySchema,
+  ZGetTeamQuerySchema,
+  ZLeaveTeamMutationSchema,
+  ZRequestTeamOwnerhsipTransferMutationSchema,
+  ZResendTeamEmailVerificationMutationSchema,
+  ZResendTeamMemberInvitationMutationSchema,
+  ZUpdateTeamEmailMutationSchema,
+  ZUpdateTeamMemberMutationSchema,
+  ZUpdateTeamMutationSchema,
+} from './schema';
+
+export const teamRouter = router({
+  acceptTeamInvitation: authenticatedProcedure
+    .input(ZAcceptTeamInvitationMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await acceptTeamInvitation({
+          teamId: input.teamId,
+          userId: ctx.user.id,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  addTeamEmailVerification: authenticatedProcedure
+    .input(ZAddTeamEmailVerificationMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await addTeamEmailVerification({
+          teamId: input.teamId,
+          userId: ctx.user.id,
+          data: {
+            email: input.email,
+            name: input.name,
+          },
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  createTeam: authenticatedProcedure
+    .input(ZCreateTeamMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        const { name, url } = input;
+
+        return await createTeam({
+          userId: ctx.user.id,
+          name,
+          teamUrl: url,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  createTeamMemberInvites: authenticatedProcedure
+    .input(ZCreateTeamMemberInvitesMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await createTeamMemberInvites({
+          userId: ctx.user.id,
+          userName: ctx.user.name ?? '',
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  createTeamPendingCheckout: authenticatedProcedure
+    .input(ZCreateTeamPendingCheckoutMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await createTeamPendingCheckoutSession({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  deleteTeam: authenticatedProcedure
+    .input(ZDeleteTeamMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await deleteTeam({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  deleteTeamEmail: authenticatedProcedure
+    .input(ZDeleteTeamEmailMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await deleteTeamEmail({
+          teamId: input.teamId,
+          userId: ctx.user.id,
+          userEmail: ctx.user.email,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  deleteTeamEmailVerification: authenticatedProcedure
+    .input(ZDeleteTeamEmailVerificationMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await deleteTeamEmailVerification({ teamId: input.teamId, userId: ctx.user.id });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  deleteTeamMemberInvitations: authenticatedProcedure
+    .input(ZDeleteTeamMemberInvitationsMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await deleteTeamMemberInvitations({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  deleteTeamMembers: authenticatedProcedure
+    .input(ZDeleteTeamMembersMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await deleteTeamMembers({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  deleteTeamPending: authenticatedProcedure
+    .input(ZDeleteTeamPendingMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await deleteTeamPending({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  deleteTeamTransferRequest: authenticatedProcedure
+    .input(ZDeleteTeamTransferRequestMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await deleteTeamTransferRequest({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  findTeamInvoices: authenticatedProcedure
+    .input(ZFindTeamInvoicesQuerySchema)
+    .query(async ({ input, ctx }) => {
+      try {
+        return await findTeamInvoices({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  findTeamMemberInvites: authenticatedProcedure
+    .input(ZFindTeamMemberInvitesQuerySchema)
+    .query(async ({ input, ctx }) => {
+      try {
+        return await findTeamMemberInvites({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  findTeamMembers: authenticatedProcedure
+    .input(ZFindTeamMembersQuerySchema)
+    .query(async ({ input, ctx }) => {
+      try {
+        return await findTeamMembers({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  findTeams: authenticatedProcedure.input(ZFindTeamsQuerySchema).query(async ({ input, ctx }) => {
+    try {
+      return await findTeams({
+        userId: ctx.user.id,
+        ...input,
+      });
+    } catch (err) {
+      console.error(err);
+
+      throw AppError.parseErrorToTRPCError(err);
+    }
+  }),
+
+  findTeamsPending: authenticatedProcedure
+    .input(ZFindTeamsPendingQuerySchema)
+    .query(async ({ input, ctx }) => {
+      try {
+        return await findTeamsPending({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  getTeam: authenticatedProcedure.input(ZGetTeamQuerySchema).query(async ({ input, ctx }) => {
+    try {
+      return await getTeamById({ teamId: input.teamId, userId: ctx.user.id });
+    } catch (err) {
+      console.error(err);
+
+      throw AppError.parseErrorToTRPCError(err);
+    }
+  }),
+
+  getTeamEmailByEmail: authenticatedProcedure.query(async ({ ctx }) => {
+    try {
+      return await getTeamEmailByEmail({ email: ctx.user.email });
+    } catch (err) {
+      console.error(err);
+
+      throw AppError.parseErrorToTRPCError(err);
+    }
+  }),
+
+  getTeamInvitations: authenticatedProcedure.query(async ({ ctx }) => {
+    try {
+      return await getTeamInvitations({ email: ctx.user.email });
+    } catch (err) {
+      console.error(err);
+
+      throw AppError.parseErrorToTRPCError(err);
+    }
+  }),
+
+  getTeamMembers: authenticatedProcedure
+    .input(ZGetTeamMembersQuerySchema)
+    .query(async ({ input, ctx }) => {
+      try {
+        return await getTeamMembers({ teamId: input.teamId, userId: ctx.user.id });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  getTeams: authenticatedProcedure.query(async ({ ctx }) => {
+    try {
+      return await getTeams({ userId: ctx.user.id });
+    } catch (err) {
+      console.error(err);
+
+      throw AppError.parseErrorToTRPCError(err);
+    }
+  }),
+
+  leaveTeam: authenticatedProcedure
+    .input(ZLeaveTeamMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await leaveTeam({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  updateTeam: authenticatedProcedure
+    .input(ZUpdateTeamMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await updateTeam({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  updateTeamEmail: authenticatedProcedure
+    .input(ZUpdateTeamEmailMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await updateTeamEmail({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  updateTeamMember: authenticatedProcedure
+    .input(ZUpdateTeamMemberMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await updateTeamMember({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  requestTeamOwnershipTransfer: authenticatedProcedure
+    .input(ZRequestTeamOwnerhsipTransferMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        return await requestTeamOwnershipTransfer({
+          userId: ctx.user.id,
+          userName: ctx.user.name ?? '',
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  resendTeamEmailVerification: authenticatedProcedure
+    .input(ZResendTeamEmailVerificationMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        await resendTeamEmailVerification({
+          userId: ctx.user.id,
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+
+  resendTeamMemberInvitation: authenticatedProcedure
+    .input(ZResendTeamMemberInvitationMutationSchema)
+    .mutation(async ({ input, ctx }) => {
+      try {
+        await resendTeamMemberInvitation({
+          userId: ctx.user.id,
+          userName: ctx.user.name ?? '',
+          ...input,
+        });
+      } catch (err) {
+        console.error(err);
+
+        throw AppError.parseErrorToTRPCError(err);
+      }
+    }),
+});

packages/trpc/server/team-router/schema.ts

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+
+import { TeamMemberRole } from '@documenso/prisma/client';
+
+const GenericFindQuerySchema = z.object({
+  term: z.string().optional(),
+  page: z.number().optional(),
+  perPage: z.number().optional(),
+});
+
+export const ZAcceptTeamInvitationMutationSchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZAddTeamEmailVerificationMutationSchema = z.object({
+  teamId: z.number(),
+  name: z.string().trim().min(1, { message: 'Please enter a valid name.' }),
+  email: z.string().trim().email().min(1, 'Please enter a valid email.'),
+});
+
+export const ZCreateTeamMutationSchema = z.object({
+  name: z.string().min(1),
+  url: z.string().min(1), // Todo: Teams - Apply lowercase, disallow certain symbols, disallow profanity.
+});
+
+export const ZCreateTeamMemberInvitesMutationSchema = z.object({
+  teamId: z.number(),
+  invitations: z.array(
+    z.object({
+      email: z.string().email(),
+      role: z.nativeEnum(TeamMemberRole),
+    }),
+  ),
+});
+
+export const ZCreateTeamPendingCheckoutMutationSchema = z.object({
+  pendingTeamId: z.number(),
+});
+
+export const ZDeleteTeamEmailMutationSchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZDeleteTeamEmailVerificationMutationSchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZDeleteTeamMembersMutationSchema = z.object({
+  teamId: z.number(),
+  teamMemberIds: z.array(z.number()),
+});
+
+export const ZDeleteTeamMemberInvitationsMutationSchema = z.object({
+  teamId: z.number(),
+  invitationIds: z.array(z.number()),
+});
+
+export const ZDeleteTeamMutationSchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZDeleteTeamPendingMutationSchema = z.object({
+  pendingTeamId: z.number(),
+});
+
+export const ZDeleteTeamTransferRequestMutationSchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZFindTeamInvoicesQuerySchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZFindTeamMemberInvitesQuerySchema = GenericFindQuerySchema.extend({
+  teamId: z.number(),
+});
+
+export const ZFindTeamMembersQuerySchema = GenericFindQuerySchema.extend({
+  teamId: z.number(),
+});
+
+export const ZFindTeamsQuerySchema = GenericFindQuerySchema;
+
+export const ZFindTeamsPendingQuerySchema = GenericFindQuerySchema;
+
+export const ZGetTeamQuerySchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZGetTeamMembersQuerySchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZLeaveTeamMutationSchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZUpdateTeamMutationSchema = z.object({
+  teamId: z.number(),
+  data: z.object({
+    // Todo: Teams
+    name: z.string().min(1),
+    url: z.string().min(1), // Todo: Apply regex. Todo: lowercase, etc
+  }),
+});
+
+export const ZUpdateTeamEmailMutationSchema = z.object({
+  teamId: z.number(),
+  data: z.object({
+    name: z.string().min(1),
+  }),
+});
+
+export const ZUpdateTeamMemberMutationSchema = z.object({
+  teamId: z.number(),
+  teamMemberId: z.number(),
+  data: z.object({
+    role: z.nativeEnum(TeamMemberRole),
+  }),
+});
+
+export const ZRequestTeamOwnerhsipTransferMutationSchema = z.object({
+  teamId: z.number(),
+  newOwnerUserId: z.number(),
+});
+
+export const ZResendTeamEmailVerificationMutationSchema = z.object({
+  teamId: z.number(),
+});
+
+export const ZResendTeamMemberInvitationMutationSchema = z.object({
+  teamId: z.number(),
+  invitationId: z.number(),
+});
+
+export type TAddTeamEmailVerificationMutationSchema = z.infer<
+  typeof ZAddTeamEmailVerificationMutationSchema
+>;
+export type TCreateTeamMutationSchema = z.infer<typeof ZCreateTeamMutationSchema>;
+export type TCreateTeamMemberInvitesMutationSchema = z.infer<
+  typeof ZCreateTeamMemberInvitesMutationSchema
+>;
+export type TCreateTeamPendingCheckoutMutationSchema = z.infer<
+  typeof ZCreateTeamPendingCheckoutMutationSchema
+>;
+export type TDeleteTeamEmailMutationSchema = z.infer<typeof ZDeleteTeamEmailMutationSchema>;
+export type TDeleteTeamMembersMutationSchema = z.infer<typeof ZDeleteTeamMembersMutationSchema>;
+export type TDeleteTeamMutationSchema = z.infer<typeof ZDeleteTeamMutationSchema>;
+export type TDeleteTeamPendingMutationSchema = z.infer<typeof ZDeleteTeamPendingMutationSchema>;
+export type TDeleteTeamTransferRequestMutationSchema = z.infer<
+  typeof ZDeleteTeamTransferRequestMutationSchema
+>;
+export type TFindTeamMemberInvitesQuerySchema = z.infer<typeof ZFindTeamMembersQuerySchema>;
+export type TFindTeamMembersQuerySchema = z.infer<typeof ZFindTeamMembersQuerySchema>;
+export type TFindTeamsQuerySchema = z.infer<typeof ZFindTeamsQuerySchema>;
+export type TFindTeamsPendingQuerySchema = z.infer<typeof ZFindTeamsPendingQuerySchema>;
+export type TGetTeamQuerySchema = z.infer<typeof ZGetTeamQuerySchema>;
+export type TGetTeamMembersQuerySchema = z.infer<typeof ZGetTeamMembersQuerySchema>;
+export type TLeaveTeamMutationSchema = z.infer<typeof ZLeaveTeamMutationSchema>;
+export type TUpdateTeamMutationSchema = z.infer<typeof ZUpdateTeamMutationSchema>;
+export type TUpdateTeamEmailMutationSchema = z.infer<typeof ZUpdateTeamEmailMutationSchema>;
+export type TRequestTeamOwnerhsipTransferMutationSchema = z.infer<
+  typeof ZRequestTeamOwnerhsipTransferMutationSchema
+>;
+export type TResendTeamEmailVerificationMutationSchema = z.infer<
+  typeof ZResendTeamEmailVerificationMutationSchema
+>;
+export type TResendTeamMemberInvitationMutationSchema = z.infer<
+  typeof ZResendTeamMemberInvitationMutationSchema
+>;