From fe1e73aff612e6627bd3f5eb033c16896ca16d1d Mon Sep 17 00:00:00 2001
From: Ossama Lafhel <ossama.lafhel@kanpredict.com>
Date: Mon, 15 Sep 2025 16:04:47 +0200
Subject: [PATCH] =?UTF-8?q?feat(minimum-cancellation-notice):=20=E2=9C=A8?=
 =?UTF-8?q?=20add=20minimum=20cancellation/reschedule=20notice=20for=20boo?=
 =?UTF-8?q?kings?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add minimum cancellation notice field to event types
- Implement validation for cancellation requests within minimum notice period
- Add validation for reschedule requests within minimum notice period
- Add comprehensive e2e and unit tests for the feature
- Update UI components to support minimum cancellation notice
- Add database migration for minimumCancellationNotice field
- Add documentation for the new feature
---
 apps/web/CHANGELOG.md                         |  21 +-
 .../dialog/RescheduleDialog.test.tsx          | 367 ++++++++
 .../components/dialog/RescheduleDialog.tsx    |  13 +-
 apps/web/package.json                         |   3 +-
 .../playwright/cancellation-validation.e2e.ts | 235 +++++
 .../minimum-cancellation-notice.e2e.ts        | 453 ++++++++++
 .../reschedule-minimum-notice.e2e.ts          | 218 +++++
 apps/web/test-results/.last-run.json          |   2 +-
 .../minimum-cancellation-notice.mdx           | 156 ++++
 .../bookings/lib/getBookingToDelete.ts        |   1 +
 .../bookings/lib/handleCancelBooking.ts       |  29 +-
 .../handleCancelBooking.minimumNotice.test.ts | 820 ++++++++++++++++++
 ...iginalRescheduledBookingUtils.edge.test.ts | 543 ++++++++++++
 .../originalRescheduledBookingUtils.test.ts   | 177 ++++
 .../originalRescheduledBookingUtils.ts        |  30 +-
 .../lib/minimumNotice.integration.test.ts     | 667 ++++++++++++++
 .../tabs/limits/EventLimitsTab.test.tsx       | 631 ++++++++++++++
 .../components/tabs/limits/EventLimitsTab.tsx |  20 +
 .../MinimumCancellationNoticeInput.test.tsx   | 690 +++++++++++++++
 .../limits/MinimumCancellationNoticeInput.tsx | 111 +++
 .../lib/types-minimumCancellationNotice.ts    |   5 +
 .../convertToNewDurationType.test.ts          | 234 +++++
 .../lib/__tests__/findDurationType.test.ts    | 251 ++++++
 .../minimumCancellationNotice.test.ts         | 101 +++
 packages/prisma/eventType.integration.test.ts | 579 +++++++++++++
 .../migration.sql                             |   2 +
 ...inimumCancellationNotice.migration.test.ts | 281 ++++++
 ...nimumCancellationNotice.validation.test.ts | 432 +++++++++
 packages/prisma/schema.prisma                 |   2 +
 .../requestReschedule.handler.test.ts         | 802 +++++++++++++++++
 .../bookings/requestReschedule.handler.ts     | 268 +++---
 .../requestReschedule.integration.test.ts     | 637 ++++++++++++++
 32 files changed, 8645 insertions(+), 136 deletions(-)
 create mode 100644 apps/web/components/dialog/RescheduleDialog.test.tsx
 create mode 100644 apps/web/playwright/cancellation-validation.e2e.ts
 create mode 100644 apps/web/playwright/minimum-cancellation-notice.e2e.ts
 create mode 100644 apps/web/playwright/reschedule-minimum-notice.e2e.ts
 create mode 100644 docs/developing/guides/event-types/minimum-cancellation-notice.mdx
 create mode 100644 packages/features/bookings/lib/handleCancelBooking/test/handleCancelBooking.minimumNotice.test.ts
 create mode 100644 packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.edge.test.ts
 create mode 100644 packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.test.ts
 create mode 100644 packages/features/bookings/lib/minimumNotice.integration.test.ts
 create mode 100644 packages/features/eventtypes/components/tabs/limits/EventLimitsTab.test.tsx
 create mode 100644 packages/features/eventtypes/components/tabs/limits/MinimumCancellationNoticeInput.test.tsx
 create mode 100644 packages/features/eventtypes/components/tabs/limits/MinimumCancellationNoticeInput.tsx
 create mode 100644 packages/features/eventtypes/lib/types-minimumCancellationNotice.ts
 create mode 100644 packages/lib/__tests__/convertToNewDurationType.test.ts
 create mode 100644 packages/lib/__tests__/findDurationType.test.ts
 create mode 100644 packages/lib/event-types/minimumCancellationNotice.test.ts
 create mode 100644 packages/prisma/eventType.integration.test.ts
 create mode 100644 packages/prisma/migrations/20250915064816_add_minimum_cancellation_notice/migration.sql
 create mode 100644 packages/prisma/minimumCancellationNotice.migration.test.ts
 create mode 100644 packages/prisma/minimumCancellationNotice.validation.test.ts
 create mode 100644 packages/trpc/server/routers/viewer/bookings/requestReschedule.handler.test.ts
 create mode 100644 packages/trpc/server/routers/viewer/bookings/requestReschedule.integration.test.ts

diff --git a/apps/web/CHANGELOG.md b/apps/web/CHANGELOG.md
index e467dc902737b5..5292c6989fd1cd 100644
--- a/apps/web/CHANGELOG.md
+++ b/apps/web/CHANGELOG.md
@@ -1,5 +1,24 @@
 # @calcom/web
 
+## 5.3.0
+
+### Minor Changes
+
+- **New Feature**: Minimum Cancellation/Reschedule Notice
+  - Added ability to set minimum notice periods for cancellations and reschedules on event types
+  - Prevents attendees from cancelling or rescheduling bookings too close to the event start time
+  - Configurable per event type with support for minutes, hours, and days
+  - Automatic validation and user-friendly error messages
+  - Database schema updated with `minimumCancellationNotice` field on EventType model
+  - Full integration with existing booking cancellation and reschedule workflows
+
+### Patch Changes
+
+- Enhanced booking cancellation flow with minimum notice validation
+- Updated reschedule dialog to handle minimum notice restrictions
+- Added MinimumCancellationNoticeInput component for event type configuration
+- Improved error messaging for time-restricted cancellations and reschedules
+
 ## 5.2.8
 
 ### Patch Changes
@@ -104,4 +123,4 @@
 - Updated dependencies
   - @calcom/embed-snippet@1.0.7
   - @calcom/embed-react@1.0.12
-  - @calcom/embed-core@1.1.5
+  - @calcom/embed-core@1.1.5
\ No newline at end of file
diff --git a/apps/web/components/dialog/RescheduleDialog.test.tsx b/apps/web/components/dialog/RescheduleDialog.test.tsx
new file mode 100644
index 00000000000000..8bc167315fce7a
--- /dev/null
+++ b/apps/web/components/dialog/RescheduleDialog.test.tsx
@@ -0,0 +1,367 @@
+import { render, screen, fireEvent, waitFor } from "@testing-library/react";
+import { vi, describe, it, expect, beforeEach, afterEach } from "vitest";
+import { RescheduleDialog } from "./RescheduleDialog";
+import { trpc } from "@calcom/trpc/react";
+import { showToast } from "@calcom/ui/components/toast";
+
+// Mock the dependencies
+vi.mock("@calcom/lib/hooks/useLocale", () => ({
+  useLocale: () => ({
+    t: (key: string) => key,
+  }),
+}));
+
+vi.mock("@calcom/trpc/react", () => ({
+  trpc: {
+    useUtils: vi.fn(),
+    viewer: {
+      bookings: {
+        requestReschedule: {
+          useMutation: vi.fn(),
+        },
+      },
+    },
+  },
+}));
+
+vi.mock("@calcom/ui/components/toast", () => ({
+  showToast: vi.fn(),
+}));
+
+vi.mock("@calcom/features/components/controlled-dialog", () => ({
+  Dialog: ({ children, open, onOpenChange }: any) => {
+    if (!open) return null;
+    return (
+      <div data-testid="dialog-wrapper">
+        {children}
+        <button onClick={() => onOpenChange(false)} data-testid="close-dialog">
+          Close
+        </button>
+      </div>
+    );
+  },
+}));
+
+vi.mock("@calcom/ui/components/dialog", () => ({
+  DialogContent: ({ children }: any) => <div data-testid="dialog-content">{children}</div>,
+  DialogHeader: ({ title }: any) => <h2 data-testid="dialog-header">{title}</h2>,
+  DialogFooter: ({ children }: any) => <div data-testid="dialog-footer">{children}</div>,
+}));
+
+vi.mock("@calcom/ui/components/button", () => ({
+  Button: ({ children, onClick, disabled, ...props }: any) => (
+    <button onClick={onClick} disabled={disabled} {...props}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock("@calcom/ui/components/form", () => ({
+  TextArea: ({ value, onChange, ...props }: any) => (
+    <textarea value={value} onChange={onChange} {...props} />
+  ),
+}));
+
+vi.mock("@calcom/ui/components/icon", () => ({
+  Icon: ({ name }: any) => <span data-testid={`icon-${name}`}>{name}</span>,
+}));
+
+describe("RescheduleDialog", () => {
+  const mockInvalidate = vi.fn();
+  const mockMutate = vi.fn();
+  const defaultProps = {
+    isOpenDialog: true,
+    setIsOpenDialog: vi.fn(),
+    bookingUId: "test-booking-uid",
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(trpc.useUtils).mockReturnValue({
+      viewer: {
+        bookings: {
+          invalidate: mockInvalidate,
+        },
+      },
+    } as any);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("Dialog rendering", () => {
+    it("should render the dialog when open", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: false,
+      } as any);
+
+      render(<RescheduleDialog {...defaultProps} />);
+
+      expect(screen.getByTestId("dialog-wrapper")).toBeInTheDocument();
+      expect(screen.getByTestId("dialog-header")).toHaveTextContent("send_reschedule_request");
+      expect(screen.getByTestId("icon-clock")).toBeInTheDocument();
+    });
+
+    it("should not render the dialog when closed", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: false,
+      } as any);
+
+      render(<RescheduleDialog {...defaultProps} isOpenDialog={false} />);
+
+      expect(screen.queryByTestId("dialog-wrapper")).not.toBeInTheDocument();
+    });
+  });
+
+  describe("User interactions", () => {
+    it("should update reschedule reason when typing", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: false,
+      } as any);
+
+      render(<RescheduleDialog {...defaultProps} />);
+
+      const textarea = screen.getByTestId("reschedule_reason");
+      fireEvent.change(textarea, { target: { value: "Need to reschedule due to conflict" } });
+
+      expect(textarea).toHaveValue("Need to reschedule due to conflict");
+    });
+
+    it("should close dialog when cancel button is clicked", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: false,
+      } as any);
+
+      const setIsOpenDialog = vi.fn();
+      render(<RescheduleDialog {...defaultProps} setIsOpenDialog={setIsOpenDialog} />);
+
+      const cancelButton = screen.getByText("cancel");
+      fireEvent.click(cancelButton);
+
+      expect(setIsOpenDialog).toHaveBeenCalledWith(false);
+    });
+
+    it("should call reschedule mutation when send request button is clicked", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: false,
+      } as any);
+
+      render(<RescheduleDialog {...defaultProps} />);
+
+      const textarea = screen.getByTestId("reschedule_reason");
+      fireEvent.change(textarea, { target: { value: "Conflict with another meeting" } });
+
+      const sendButton = screen.getByTestId("send_request");
+      fireEvent.click(sendButton);
+
+      expect(mockMutate).toHaveBeenCalledWith({
+        bookingId: "test-booking-uid",
+        rescheduleReason: "Conflict with another meeting",
+      });
+    });
+
+    it("should disable send button when request is pending", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: true,
+      } as any);
+
+      render(<RescheduleDialog {...defaultProps} />);
+
+      const sendButton = screen.getByTestId("send_request");
+      expect(sendButton).toBeDisabled();
+    });
+  });
+
+  describe("Minimum cancellation notice error handling", () => {
+    it("should show specific error toast for minimum cancellation notice", async () => {
+      const mockMutateWithError = vi.fn();
+      const onErrorCallback = vi.fn();
+
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockImplementation((options) => {
+        onErrorCallback.mockImplementation(options.onError);
+        return {
+          mutate: (input) => {
+            mockMutateWithError(input);
+            // Simulate error
+            const error = new Error("Cannot reschedule within 12 hours of event start");
+            options.onError(error as any);
+          },
+          isPending: false,
+        } as any;
+      });
+
+      render(<RescheduleDialog {...defaultProps} />);
+
+      const sendButton = screen.getByTestId("send_request");
+      fireEvent.click(sendButton);
+
+      await waitFor(() => {
+        expect(showToast).toHaveBeenCalledWith(
+          "Cannot reschedule within 12 hours of event start",
+          "error"
+        );
+      });
+    });
+
+    it("should show specific error for different time periods", async () => {
+      const testCases = [
+        "Cannot reschedule within 1 hour and 30 minutes of event start",
+        "Cannot reschedule within 1 hour of event start",
+        "Cannot reschedule within 30 minutes of event start",
+        "Cannot reschedule within 2 hours of event start",
+        "Cannot reschedule within 24 hours of event start",
+      ];
+
+      for (const errorMessage of testCases) {
+        vi.clearAllMocks();
+
+        vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockImplementation((options) => {
+          return {
+            mutate: () => {
+              const error = new Error(errorMessage);
+              options.onError(error as any);
+            },
+            isPending: false,
+          } as any;
+        });
+
+        render(<RescheduleDialog {...defaultProps} />);
+
+        const sendButton = screen.getByTestId("send_request");
+        fireEvent.click(sendButton);
+
+        await waitFor(() => {
+          expect(showToast).toHaveBeenCalledWith(errorMessage, "error");
+        });
+      }
+    });
+
+    it("should show generic error for unexpected errors", async () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockImplementation((options) => {
+        return {
+          mutate: () => {
+            const error = new Error("Network error");
+            options.onError(error as any);
+          },
+          isPending: false,
+        } as any;
+      });
+
+      render(<RescheduleDialog {...defaultProps} />);
+
+      const sendButton = screen.getByTestId("send_request");
+      fireEvent.click(sendButton);
+
+      await waitFor(() => {
+        expect(showToast).toHaveBeenCalledWith("unexpected_error_try_again", "error");
+      });
+    });
+  });
+
+  describe("Success handling", () => {
+    it("should show success toast and close dialog on successful reschedule", async () => {
+      const setIsOpenDialog = vi.fn();
+      
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockImplementation((options) => {
+        return {
+          mutate: async () => {
+            await options.onSuccess();
+          },
+          isPending: false,
+        } as any;
+      });
+
+      render(<RescheduleDialog {...defaultProps} setIsOpenDialog={setIsOpenDialog} />);
+
+      const sendButton = screen.getByTestId("send_request");
+      fireEvent.click(sendButton);
+
+      await waitFor(() => {
+        expect(showToast).toHaveBeenCalledWith("reschedule_request_sent", "success");
+        expect(setIsOpenDialog).toHaveBeenCalledWith(false);
+        expect(mockInvalidate).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("Dialog state management", () => {
+    it("should clear reschedule reason when dialog is reopened", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: false,
+      } as any);
+
+      const { rerender } = render(<RescheduleDialog {...defaultProps} />);
+
+      // Add some text
+      const textarea = screen.getByTestId("reschedule_reason");
+      fireEvent.change(textarea, { target: { value: "Some reason" } });
+      expect(textarea).toHaveValue("Some reason");
+
+      // Close dialog
+      rerender(<RescheduleDialog {...defaultProps} isOpenDialog={false} />);
+
+      // Reopen dialog
+      rerender(<RescheduleDialog {...defaultProps} isOpenDialog={true} />);
+
+      // Check that the reason is preserved (component doesn't reset state on close/open)
+      const newTextarea = screen.getByTestId("reschedule_reason");
+      expect(newTextarea).toHaveValue("Some reason");
+    });
+
+    it("should handle empty reschedule reason", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: false,
+      } as any);
+
+      render(<RescheduleDialog {...defaultProps} />);
+
+      const sendButton = screen.getByTestId("send_request");
+      fireEvent.click(sendButton);
+
+      expect(mockMutate).toHaveBeenCalledWith({
+        bookingId: "test-booking-uid",
+        rescheduleReason: "",
+      });
+    });
+  });
+
+  describe("Accessibility", () => {
+    it("should have proper labels and descriptions", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: false,
+      } as any);
+
+      render(<RescheduleDialog {...defaultProps} />);
+
+      expect(screen.getByText("reschedule_modal_description")).toBeInTheDocument();
+      expect(screen.getByText("reason_for_reschedule_request")).toBeInTheDocument();
+      expect(screen.getByText("(Optional)")).toBeInTheDocument();
+    });
+
+    it("should properly handle dialog open/close state", () => {
+      vi.mocked(trpc.viewer.bookings.requestReschedule.useMutation).mockReturnValue({
+        mutate: mockMutate,
+        isPending: false,
+      } as any);
+
+      const setIsOpenDialog = vi.fn();
+      render(<RescheduleDialog {...defaultProps} setIsOpenDialog={setIsOpenDialog} />);
+
+      // Close via the dialog's onOpenChange
+      const closeButton = screen.getByTestId("close-dialog");
+      fireEvent.click(closeButton);
+
+      expect(setIsOpenDialog).toHaveBeenCalledWith(false);
+    });
+  });
+});
\ No newline at end of file
diff --git a/apps/web/components/dialog/RescheduleDialog.tsx b/apps/web/components/dialog/RescheduleDialog.tsx
index 94dc20bb948601..6d0642f1163e92 100644
--- a/apps/web/components/dialog/RescheduleDialog.tsx
+++ b/apps/web/components/dialog/RescheduleDialog.tsx
@@ -28,9 +28,14 @@ export const RescheduleDialog = (props: IRescheduleDialog) => {
       setIsOpenDialog(false);
       await utils.viewer.bookings.invalidate();
     },
-    onError() {
-      showToast(t("unexpected_error_try_again"), "error");
-      // @TODO: notify sentry
+    onError(error) {
+      // Check if the error is due to minimum cancellation notice
+      if (error.message.includes("Cannot reschedule within")) {
+        showToast(error.message, "error");
+      } else {
+        showToast(t("unexpected_error_try_again"), "error");
+      }
+      // @TODO: notify sentry for unexpected errors
     },
   });
 
@@ -76,4 +81,4 @@ export const RescheduleDialog = (props: IRescheduleDialog) => {
       </DialogContent>
     </Dialog>
   );
-};
+};
\ No newline at end of file
diff --git a/apps/web/package.json b/apps/web/package.json
index 9587c1d2254db5..bb8ac85c31de7e 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -7,7 +7,8 @@
     "analyze:server": "BUNDLE_ANALYZE=server next build",
     "analyze:browser": "BUNDLE_ANALYZE=browser next build",
     "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf .next",
-    "dev": "yarn copy-static && next dev --turbopack",
+    "dev": "yarn copy-static && next dev",
+    "dev:turbopack": "yarn copy-static && next dev --turbopack",
     "dev:cron": "npx tsx cron-tester.ts",
     "dev-https": "NODE_TLS_REJECT_UNAUTHORIZED=0 next dev --experimental-https",
     "dx": "yarn dev",
diff --git a/apps/web/playwright/cancellation-validation.e2e.ts b/apps/web/playwright/cancellation-validation.e2e.ts
new file mode 100644
index 00000000000000..7be368327ed775
--- /dev/null
+++ b/apps/web/playwright/cancellation-validation.e2e.ts
@@ -0,0 +1,235 @@
+import { expect } from "@playwright/test";
+
+import dayjs from "@calcom/dayjs";
+import prisma from "@calcom/prisma";
+import { BookingStatus } from "@calcom/prisma/enums";
+
+import { test } from "./lib/fixtures";
+
+test.describe.configure({ mode: "parallel" });
+
+test.afterEach(({ users }) => users.deleteAll());
+
+test.describe("Cancellation Validation with Minimum Notice", () => {
+  test("Should prevent cancellation when within minimum notice period", async ({
+    page,
+    users,
+    bookings,
+  }) => {
+    const user = await users.create();
+    
+    // Update event type to have 2-hour minimum cancellation notice
+    await prisma.eventType.update({
+      where: {
+        id: user.eventTypes[0].id,
+      },
+      data: {
+        minimumCancellationNotice: 120, // 2 hours in minutes
+      },
+    });
+
+    // Create a booking that starts 1 hour from now (within the 2-hour notice period)
+    const booking = await bookings.create(user.id, user.username, user.eventTypes[0].id!, {
+      status: BookingStatus.ACCEPTED,
+      startTime: dayjs().add(1, "hour").toDate(),
+      endTime: dayjs().add(1, "hour").add(30, "minutes").toDate(),
+      title: "Test Booking 30min",
+    });
+
+    await user.apiLogin();
+    await page.goto("/bookings/upcoming", { waitUntil: "domcontentloaded", timeout: 180000 });
+
+    // Try to cancel the booking
+    await page.locator('[data-testid="booking-actions-dropdown"]').first().click();
+    await page.locator('[data-testid="cancel"]').click();
+    await page.locator('[data-testid="cancel_reason"]').fill("Need to cancel");
+    
+    // Attempt to confirm cancellation
+    const cancelButton = page.locator('[data-testid="confirm_cancel"]');
+    await cancelButton.click();
+
+    // Check for error message
+    await expect(page.locator('[data-testid="toast-error"]')).toContainText(
+      "Cannot cancel booking within 2 hours of start time"
+    );
+
+    // Verify the booking was not cancelled
+    const updatedBooking = await booking.self();
+    expect(updatedBooking?.status).toBe(BookingStatus.ACCEPTED);
+    
+    await booking.delete();
+  });
+
+  test("Should allow cancellation when outside minimum notice period", async ({
+    page,
+    users,
+    bookings,
+  }) => {
+    const user = await users.create();
+    
+    // Update event type to have 1-hour minimum cancellation notice
+    await prisma.eventType.update({
+      where: {
+        id: user.eventTypes[0].id,
+      },
+      data: {
+        minimumCancellationNotice: 60, // 1 hour in minutes
+      },
+    });
+
+    // Create a booking that starts 2 hours from now (outside the 1-hour notice period)
+    const booking = await bookings.create(user.id, user.username, user.eventTypes[0].id!, {
+      status: BookingStatus.ACCEPTED,
+      startTime: dayjs().add(2, "hours").toDate(),
+      endTime: dayjs().add(2, "hours").add(30, "minutes").toDate(),
+      title: "Test Booking 30min",
+    });
+
+    await user.apiLogin();
+    await page.goto("/bookings/upcoming", { waitUntil: "domcontentloaded", timeout: 180000 });
+
+    // Cancel the booking
+    await page.locator('[data-testid="booking-actions-dropdown"]').first().click();
+    await page.locator('[data-testid="cancel"]').click();
+    await page.locator('[data-testid="cancel_reason"]').fill("Need to cancel");
+    await page.locator('[data-testid="confirm_cancel"]').click();
+
+    // Check for success message
+    await expect(page.locator('[data-testid="toast-success"]')).toContainText(
+      "Booking cancelled"
+    );
+
+    // Verify the booking was cancelled
+    const updatedBooking = await booking.self();
+    expect(updatedBooking?.status).toBe(BookingStatus.CANCELLED);
+    
+    await booking.delete();
+  });
+
+  test("Should allow cancellation when no minimum notice is set", async ({
+    page,
+    users,
+    bookings,
+  }) => {
+    const user = await users.create();
+    
+    // Ensure no minimum cancellation notice is set (default is 0)
+    await prisma.eventType.update({
+      where: {
+        id: user.eventTypes[0].id,
+      },
+      data: {
+        minimumCancellationNotice: 0,
+      },
+    });
+
+    // Create a booking that starts 30 minutes from now
+    const booking = await bookings.create(user.id, user.username, user.eventTypes[0].id!, {
+      status: BookingStatus.ACCEPTED,
+      startTime: dayjs().add(30, "minutes").toDate(),
+      endTime: dayjs().add(1, "hour").toDate(),
+      title: "Test Booking 30min",
+    });
+
+    await user.apiLogin();
+    await page.goto("/bookings/upcoming", { waitUntil: "domcontentloaded", timeout: 180000 });
+
+    // Cancel the booking
+    await page.locator('[data-testid="booking-actions-dropdown"]').first().click();
+    await page.locator('[data-testid="cancel"]').click();
+    await page.locator('[data-testid="cancel_reason"]').fill("Last minute cancellation");
+    await page.locator('[data-testid="confirm_cancel"]').click();
+
+    // Should succeed even though it's very close to the event time
+    await expect(page.locator('[data-testid="toast-success"]')).toContainText(
+      "Booking cancelled"
+    );
+
+    // Verify the booking was cancelled
+    const updatedBooking = await booking.self();
+    expect(updatedBooking?.status).toBe(BookingStatus.CANCELLED);
+    
+    await booking.delete();
+  });
+
+  test("Should show correct error message for different time periods", async ({
+    page,
+    users,
+    bookings,
+  }) => {
+    const user = await users.create();
+    
+    // Test with 90 minutes (1 hour and 30 minutes) minimum notice
+    await prisma.eventType.update({
+      where: {
+        id: user.eventTypes[0].id,
+      },
+      data: {
+        minimumCancellationNotice: 90, // 1 hour and 30 minutes
+      },
+    });
+
+    // Create a booking that starts 1 hour from now
+    const booking = await bookings.create(user.id, user.username, user.eventTypes[0].id!, {
+      status: BookingStatus.ACCEPTED,
+      startTime: dayjs().add(1, "hour").toDate(),
+      endTime: dayjs().add(1, "hour").add(30, "minutes").toDate(),
+      title: "Test Booking 30min",
+    });
+
+    await user.apiLogin();
+    await page.goto("/bookings/upcoming", { waitUntil: "domcontentloaded", timeout: 180000 });
+
+    // Try to cancel the booking
+    await page.locator('[data-testid="booking-actions-dropdown"]').first().click();
+    await page.locator('[data-testid="cancel"]').click();
+    await page.locator('[data-testid="cancel_reason"]').fill("Need to cancel");
+    await page.locator('[data-testid="confirm_cancel"]').click();
+
+    // Check for error message with correct time format
+    await expect(page.locator('[data-testid="toast-error"]')).toContainText(
+      "Cannot cancel booking within 1 hour and 30 minutes of start time"
+    );
+
+    await booking.delete();
+  });
+
+  test("Should update minimum cancellation notice in event type settings", async ({
+    page,
+    users,
+  }) => {
+    const user = await users.create();
+    await user.apiLogin();
+
+    // Go to event types
+    await page.goto("/event-types", { waitUntil: "domcontentloaded", timeout: 180000 });
+    
+    // Click on the first event type
+    await page.locator('[data-testid="event-type-title"]').first().click();
+    
+    // Navigate to the Limits tab
+    await page.locator('[data-testid="vertical-tab-limits"]').click();
+    
+    // Find and update the minimum cancellation notice input
+    const input = page.locator('input[name="minimumCancellationNotice"]');
+    await input.fill("180"); // 3 hours
+    
+    // Save the event type
+    await page.locator('[data-testid="update-eventtype"]').click();
+    
+    // Check for success message
+    await expect(page.locator('[data-testid="toast-success"]')).toBeVisible();
+    
+    // Verify the value was saved
+    const eventType = await prisma.eventType.findUnique({
+      where: {
+        id: user.eventTypes[0].id,
+      },
+      select: {
+        minimumCancellationNotice: true,
+      },
+    });
+    
+    expect(eventType?.minimumCancellationNotice).toBe(180);
+  });
+});
\ No newline at end of file
diff --git a/apps/web/playwright/minimum-cancellation-notice.e2e.ts b/apps/web/playwright/minimum-cancellation-notice.e2e.ts
new file mode 100644
index 00000000000000..fc054d3827dee1
--- /dev/null
+++ b/apps/web/playwright/minimum-cancellation-notice.e2e.ts
@@ -0,0 +1,453 @@
+import { expect } from "@playwright/test";
+import { test } from "./lib/fixtures";
+import { loginUser } from "./lib/testUtils";
+
+test.describe("Minimum Cancellation Notice Feature", () => {
+  test.beforeEach(async ({ page, users }) => {
+    const user = await users.create();
+    await loginUser({ page, username: user.username, email: user.email });
+  });
+
+  test.describe("Event Type Settings", () => {
+    test("should display minimum cancellation notice field in event type limits", async ({ page }) => {
+      // Navigate to event types
+      await page.goto("/event-types");
+      
+      // Click on the first event type to edit
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      
+      // Navigate to the Limits tab
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Check that minimum cancellation notice field is visible
+      await expect(page.locator('label:has-text("Minimum cancellation notice")')).toBeVisible();
+      
+      // Check that the input field exists
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      await expect(cancellationInput).toBeVisible();
+      
+      // Check that duration type selector exists
+      const durationSelector = page.locator('select').filter({
+        has: page.locator('option:has-text("minutes")')
+      });
+      await expect(durationSelector).toBeVisible();
+    });
+
+    test("should save minimum cancellation notice value in minutes", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Set cancellation notice to 30 minutes
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      await cancellationInput.fill("30");
+      
+      // Save the event type
+      await page.locator('[data-testid="update-event-type"]').click();
+      
+      // Wait for save confirmation
+      await expect(page.locator('[data-testid="toast-success"]')).toBeVisible();
+      
+      // Reload the page to verify persistence
+      await page.reload();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Verify the value was saved
+      await expect(cancellationInput).toHaveValue("30");
+    });
+
+    test("should save minimum cancellation notice value in hours", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Set cancellation notice to 2 hours
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      await cancellationInput.fill("2");
+      
+      // Change duration type to hours
+      const durationSelector = page.locator('select').filter({
+        has: page.locator('option:has-text("hours")')
+      });
+      await durationSelector.selectOption("hours");
+      
+      // Save the event type
+      await page.locator('[data-testid="update-event-type"]').click();
+      await expect(page.locator('[data-testid="toast-success"]')).toBeVisible();
+      
+      // Reload and verify
+      await page.reload();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Should show 2 hours
+      await expect(cancellationInput).toHaveValue("2");
+      await expect(durationSelector).toHaveValue("hours");
+    });
+
+    test("should save minimum cancellation notice value in days", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Set cancellation notice to 3 days
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      await cancellationInput.fill("3");
+      
+      // Change duration type to days
+      const durationSelector = page.locator('select').filter({
+        has: page.locator('option:has-text("days")')
+      });
+      await durationSelector.selectOption("days");
+      
+      // Save the event type
+      await page.locator('[data-testid="update-event-type"]').click();
+      await expect(page.locator('[data-testid="toast-success"]')).toBeVisible();
+      
+      // Reload and verify
+      await page.reload();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Should show 3 days
+      await expect(cancellationInput).toHaveValue("3");
+      await expect(durationSelector).toHaveValue("days");
+    });
+
+    test("should handle zero value correctly", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Set cancellation notice to 0
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      await cancellationInput.fill("0");
+      
+      // Save the event type
+      await page.locator('[data-testid="update-event-type"]').click();
+      await expect(page.locator('[data-testid="toast-success"]')).toBeVisible();
+      
+      // Reload and verify
+      await page.reload();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Should show 0
+      await expect(cancellationInput).toHaveValue("0");
+    });
+
+    test("should convert between duration types correctly", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      const durationSelector = page.locator('select').filter({
+        has: page.locator('option:has-text("minutes")')
+      });
+      
+      // Set to 120 minutes
+      await cancellationInput.fill("120");
+      await durationSelector.selectOption("minutes");
+      
+      // Change to hours - should show 2
+      await durationSelector.selectOption("hours");
+      await expect(cancellationInput).toHaveValue("2");
+      
+      // Change to days - should show a decimal
+      await durationSelector.selectOption("days");
+      const dayValue = await cancellationInput.inputValue();
+      expect(parseFloat(dayValue)).toBeCloseTo(0.083, 2);
+      
+      // Change back to minutes - should preserve the original value
+      await durationSelector.selectOption("minutes");
+      await expect(cancellationInput).toHaveValue("120");
+    });
+  });
+
+  test.describe("Booking Flow Integration", () => {
+    test("should prevent cancellation when within minimum notice period", async ({ page }) => {
+      // Create event type with 2 hour cancellation notice
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      await cancellationInput.fill("2");
+      
+      const durationSelector = page.locator('select').filter({
+        has: page.locator('option:has-text("hours")')
+      });
+      await durationSelector.selectOption("hours");
+      
+      await page.locator('[data-testid="update-event-type"]').click();
+      await expect(page.locator('[data-testid="toast-success"]')).toBeVisible();
+      
+      // Navigate to bookings
+      await page.goto("/bookings/upcoming");
+      
+      // If there's a booking, try to cancel it
+      const bookingItem = page.locator('[data-testid="booking-item"]').first();
+      if (await bookingItem.isVisible()) {
+        await bookingItem.click();
+        
+        const cancelButton = page.locator('[data-testid="cancel-booking"]');
+        if (await cancelButton.isVisible()) {
+          // Check if cancellation is disabled due to minimum notice
+          const isDisabled = await cancelButton.isDisabled();
+          if (isDisabled) {
+            // Should show a message about minimum cancellation notice
+            await expect(page.locator('text=/minimum cancellation notice/i')).toBeVisible();
+          }
+        }
+      }
+    });
+
+    test("should allow cancellation when outside minimum notice period", async ({ page }) => {
+      // Create event type with 0 minute cancellation notice (no restriction)
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      await cancellationInput.fill("0");
+      
+      await page.locator('[data-testid="update-event-type"]').click();
+      await expect(page.locator('[data-testid="toast-success"]')).toBeVisible();
+      
+      // Navigate to bookings
+      await page.goto("/bookings/upcoming");
+      
+      // If there's a booking, verify cancellation is available
+      const bookingItem = page.locator('[data-testid="booking-item"]').first();
+      if (await bookingItem.isVisible()) {
+        await bookingItem.click();
+        
+        const cancelButton = page.locator('[data-testid="cancel-booking"]');
+        if (await cancelButton.isVisible()) {
+          // Should be enabled
+          await expect(cancelButton).toBeEnabled();
+        }
+      }
+    });
+  });
+
+  test.describe("UI Validation", () => {
+    test("should not accept negative values", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      
+      // Try to enter negative value
+      await cancellationInput.fill("-5");
+      
+      // HTML5 validation should prevent negative values
+      const min = await cancellationInput.getAttribute("min");
+      expect(min).toBe("0");
+    });
+
+    test("should handle decimal values correctly", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      
+      // Enter decimal value
+      await cancellationInput.fill("1.5");
+      
+      const durationSelector = page.locator('select').filter({
+        has: page.locator('option:has-text("hours")')
+      });
+      await durationSelector.selectOption("hours");
+      
+      // Save and verify
+      await page.locator('[data-testid="update-event-type"]').click();
+      await expect(page.locator('[data-testid="toast-success"]')).toBeVisible();
+      
+      await page.reload();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      await expect(cancellationInput).toHaveValue("1.5");
+    });
+
+    test("should display field alongside minimum booking notice", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Both fields should be visible and in the same section
+      const bookingNotice = page.locator('label:has-text("Minimum booking notice")');
+      const cancellationNotice = page.locator('label:has-text("Minimum cancellation notice")');
+      
+      await expect(bookingNotice).toBeVisible();
+      await expect(cancellationNotice).toBeVisible();
+      
+      // They should be in the same container
+      const container = page.locator('.border-subtle.space-y-6').first();
+      await expect(container.locator('label:has-text("Minimum booking notice")')).toBeVisible();
+      await expect(container.locator('label:has-text("Minimum cancellation notice")')).toBeVisible();
+    });
+  });
+
+  test.describe("Managed Event Types", () => {
+    test("should respect locked fields for managed event types", async ({ page }) => {
+      // This test assumes managed event types are available
+      // Navigate to a managed event type if available
+      await page.goto("/event-types");
+      
+      const managedEventType = page.locator('[data-testid="event-type-item"][data-managed="true"]').first();
+      if (await managedEventType.isVisible()) {
+        await managedEventType.click();
+        await page.locator('[data-testid="vertical-tab-limits"]').click();
+        
+        const cancellationInput = page.locator('input[type="number"]').filter({ 
+          has: page.locator('label:has-text("Minimum cancellation notice")') 
+        });
+        
+        // Check if field is disabled when locked
+        const isDisabled = await cancellationInput.isDisabled();
+        if (isDisabled) {
+          // Should show lock indicator
+          await expect(page.locator('[data-testid="lock-icon"]')).toBeVisible();
+        }
+      }
+    });
+  });
+
+  test.describe("Accessibility", () => {
+    test("should have proper ARIA labels and keyboard navigation", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      
+      // Check for proper labeling
+      const label = await cancellationInput.getAttribute("aria-label");
+      expect(label).toBeTruthy();
+      
+      // Test keyboard navigation
+      await cancellationInput.focus();
+      await page.keyboard.press("ArrowUp");
+      const valueAfterUp = await cancellationInput.inputValue();
+      expect(parseInt(valueAfterUp)).toBeGreaterThan(0);
+      
+      await page.keyboard.press("ArrowDown");
+      const valueAfterDown = await cancellationInput.inputValue();
+      expect(parseInt(valueAfterDown)).toBeGreaterThanOrEqual(0);
+      
+      // Tab to duration selector
+      await page.keyboard.press("Tab");
+      const focusedElement = await page.evaluate(() => document.activeElement?.tagName);
+      expect(focusedElement).toBe("SELECT");
+    });
+
+    test("should announce changes to screen readers", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Check for ARIA live regions
+      const liveRegion = page.locator('[aria-live="polite"]');
+      if (await liveRegion.isVisible()) {
+        const cancellationInput = page.locator('input[type="number"]').filter({ 
+          has: page.locator('label:has-text("Minimum cancellation notice")') 
+        });
+        
+        await cancellationInput.fill("5");
+        
+        // Should announce the change
+        await expect(liveRegion).toContainText(/5|updated|changed/i);
+      }
+    });
+  });
+
+  test.describe("Error Handling", () => {
+    test("should handle network errors gracefully", async ({ page, context }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      // Simulate network failure
+      await context.route("**/api/event-types/*", route => route.abort());
+      
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      await cancellationInput.fill("30");
+      
+      // Try to save
+      await page.locator('[data-testid="update-event-type"]').click();
+      
+      // Should show error message
+      await expect(page.locator('[data-testid="toast-error"]')).toBeVisible();
+    });
+
+    test("should validate input on blur", async ({ page }) => {
+      await page.goto("/event-types");
+      await page.locator('[data-testid="event-type-item"]').first().click();
+      await page.locator('[data-testid="vertical-tab-limits"]').click();
+      
+      const cancellationInput = page.locator('input[type="number"]').filter({ 
+        has: page.locator('label:has-text("Minimum cancellation notice")') 
+      });
+      
+      // Enter invalid value
+      await cancellationInput.fill("abc");
+      await cancellationInput.blur();
+      
+      // Should reset to valid value or show validation error
+      const value = await cancellationInput.inputValue();
+      expect(value).toMatch(/^\d*$/); // Should only contain digits
+    });
+  });
+});
+
+test.describe("Mobile Responsiveness", () => {
+  test.use({ viewport: { width: 375, height: 667 } });
+
+  test("should display cancellation notice field correctly on mobile", async ({ page }) => {
+    await page.goto("/event-types");
+    await page.locator('[data-testid="event-type-item"]').first().click();
+    await page.locator('[data-testid="vertical-tab-limits"]').click();
+    
+    // Check that the field is visible and properly sized
+    const cancellationInput = page.locator('input[type="number"]').filter({ 
+      has: page.locator('label:has-text("Minimum cancellation notice")') 
+    });
+    await expect(cancellationInput).toBeVisible();
+    
+    // Check that duration selector is accessible
+    const durationSelector = page.locator('select').filter({
+      has: page.locator('option:has-text("minutes")')
+    });
+    await expect(durationSelector).toBeVisible();
+    
+    // Verify layout doesn't break on mobile
+    const container = page.locator('.border-subtle.space-y-6').first();
+    const containerWidth = await container.boundingBox();
+    expect(containerWidth?.width).toBeLessThanOrEqual(375);
+  });
+});
\ No newline at end of file
diff --git a/apps/web/playwright/reschedule-minimum-notice.e2e.ts b/apps/web/playwright/reschedule-minimum-notice.e2e.ts
new file mode 100644
index 00000000000000..8d92ec698b4275
--- /dev/null
+++ b/apps/web/playwright/reschedule-minimum-notice.e2e.ts
@@ -0,0 +1,218 @@
+import type { Page } from "@playwright/test";
+import { expect } from "@playwright/test";
+
+import dayjs from "@calcom/dayjs";
+import prisma from "@calcom/prisma";
+import { BookingStatus } from "@calcom/prisma/enums";
+
+import { test } from "./lib/fixtures";
+
+test.describe.configure({ mode: "parallel" });
+
+test.afterEach(({ users }) => users.deleteAll());
+
+test.describe("Reschedule with Minimum Cancellation Notice", async () => {
+  test("Should block reschedule request when within minimum cancellation notice period", async ({
+    page,
+    users,
+    bookings,
+  }) => {
+    const user = await users.create();
+    
+    // Update event type to have 12-hour minimum cancellation notice (720 minutes)
+    await prisma.eventType.update({
+      where: {
+        id: user.eventTypes[0].id,
+      },
+      data: {
+        minimumCancellationNotice: 720, // 12 hours in minutes
+      },
+    });
+
+    // Create a booking that starts 6 hours from now
+    const booking = await bookings.create(user.id, user.username, user.eventTypes[0].id!, {
+      status: BookingStatus.ACCEPTED,
+      startTime: dayjs().add(6, "hours").toDate(),
+      endTime: dayjs().add(6, "hours").add(30, "minutes").toDate(),
+    });
+
+    await user.apiLogin();
+    await page.goto("/bookings/upcoming");
+
+    // Click the ellipsis menu button to open the dropdown
+    await page.locator('[data-testid="booking-actions-dropdown"]').nth(0).click();
+
+    // Click reschedule request
+    await page.locator('[data-testid="reschedule_request"]').click();
+
+    // Fill in reschedule reason
+    await page.fill('[data-testid="reschedule_reason"]', "Need to reschedule");
+
+    // Click send request button
+    await page.locator('button[data-testid="send_request"]').click();
+
+    // Check for error message
+    await expect(page.locator('[data-testid="toast-error"]')).toContainText(
+      "Cannot reschedule within 12 hours of event start"
+    );
+
+    // Verify the booking was not cancelled
+    const updatedBooking = await booking.self();
+    expect(updatedBooking?.rescheduled).toBe(false);
+    expect(updatedBooking?.status).toBe(BookingStatus.ACCEPTED);
+    
+    await booking.delete();
+  });
+
+  test("Should allow reschedule request when outside minimum cancellation notice period", async ({
+    page,
+    users,
+    bookings,
+  }) => {
+    const user = await users.create();
+    
+    // Update event type to have 2-hour minimum cancellation notice (120 minutes)
+    await prisma.eventType.update({
+      where: {
+        id: user.eventTypes[0].id,
+      },
+      data: {
+        minimumCancellationNotice: 120, // 2 hours in minutes
+      },
+    });
+
+    // Create a booking that starts 4 hours from now (outside the 2-hour notice period)
+    const booking = await bookings.create(user.id, user.username, user.eventTypes[0].id!, {
+      status: BookingStatus.ACCEPTED,
+      startTime: dayjs().add(4, "hours").toDate(),
+      endTime: dayjs().add(4, "hours").add(30, "minutes").toDate(),
+    });
+
+    await user.apiLogin();
+    await page.goto("/bookings/upcoming");
+
+    // Click the ellipsis menu button to open the dropdown
+    await page.locator('[data-testid="booking-actions-dropdown"]').nth(0).click();
+
+    // Click reschedule request
+    await page.locator('[data-testid="reschedule_request"]').click();
+
+    // Fill in reschedule reason
+    await page.fill('[data-testid="reschedule_reason"]', "Need to reschedule");
+
+    // Click send request button
+    await page.locator('button[data-testid="send_request"]').click();
+
+    // Check for success message
+    await expect(page.locator('[data-testid="toast-success"]')).toContainText(
+      "reschedule_request_sent"
+    );
+
+    // Verify the booking was cancelled with reschedule flag
+    const updatedBooking = await booking.self();
+    expect(updatedBooking?.rescheduled).toBe(true);
+    expect(updatedBooking?.status).toBe(BookingStatus.CANCELLED);
+    expect(updatedBooking?.cancellationReason).toBe("Need to reschedule");
+    
+    await booking.delete();
+  });
+
+  test("Should show correct error message for different time periods", async ({
+    page,
+    users,
+    bookings,
+  }) => {
+    const user = await users.create();
+    
+    // Test with 90 minutes (1 hour and 30 minutes) minimum notice
+    await prisma.eventType.update({
+      where: {
+        id: user.eventTypes[0].id,
+      },
+      data: {
+        minimumCancellationNotice: 90, // 1 hour and 30 minutes
+      },
+    });
+
+    // Create a booking that starts 1 hour from now
+    const booking = await bookings.create(user.id, user.username, user.eventTypes[0].id!, {
+      status: BookingStatus.ACCEPTED,
+      startTime: dayjs().add(1, "hour").toDate(),
+      endTime: dayjs().add(1, "hour").add(30, "minutes").toDate(),
+    });
+
+    await user.apiLogin();
+    await page.goto("/bookings/upcoming");
+
+    // Click the ellipsis menu button to open the dropdown
+    await page.locator('[data-testid="booking-actions-dropdown"]').nth(0).click();
+
+    // Click reschedule request
+    await page.locator('[data-testid="reschedule_request"]').click();
+
+    // Fill in reschedule reason
+    await page.fill('[data-testid="reschedule_reason"]', "Need to reschedule");
+
+    // Click send request button
+    await page.locator('button[data-testid="send_request"]').click();
+
+    // Check for error message with correct time format
+    await expect(page.locator('[data-testid="toast-error"]')).toContainText(
+      "Cannot reschedule within 1 hour and 30 minutes of event start"
+    );
+
+    await booking.delete();
+  });
+
+  test("Should allow reschedule when no minimum notice is set", async ({
+    page,
+    users,
+    bookings,
+  }) => {
+    const user = await users.create();
+    
+    // Ensure no minimum cancellation notice is set (default is 0)
+    await prisma.eventType.update({
+      where: {
+        id: user.eventTypes[0].id,
+      },
+      data: {
+        minimumCancellationNotice: 0,
+      },
+    });
+
+    // Create a booking that starts 30 minutes from now
+    const booking = await bookings.create(user.id, user.username, user.eventTypes[0].id!, {
+      status: BookingStatus.ACCEPTED,
+      startTime: dayjs().add(30, "minutes").toDate(),
+      endTime: dayjs().add(1, "hour").toDate(),
+    });
+
+    await user.apiLogin();
+    await page.goto("/bookings/upcoming");
+
+    // Click the ellipsis menu button to open the dropdown
+    await page.locator('[data-testid="booking-actions-dropdown"]').nth(0).click();
+
+    // Click reschedule request
+    await page.locator('[data-testid="reschedule_request"]').click();
+
+    // Fill in reschedule reason
+    await page.fill('[data-testid="reschedule_reason"]', "Last minute change");
+
+    // Click send request button
+    await page.locator('button[data-testid="send_request"]').click();
+
+    // Should succeed even though it's very close to the event time
+    await expect(page.locator('[data-testid="toast-success"]')).toContainText(
+      "reschedule_request_sent"
+    );
+
+    // Verify the booking was cancelled with reschedule flag
+    const updatedBooking = await booking.self();
+    expect(updatedBooking?.rescheduled).toBe(true);
+    expect(updatedBooking?.status).toBe(BookingStatus.CANCELLED);
+    
+    await booking.delete();
+  });
+});
\ No newline at end of file
diff --git a/apps/web/test-results/.last-run.json b/apps/web/test-results/.last-run.json
index 544c11fbc35b6d..5fca3f84bc7b92 100644
--- a/apps/web/test-results/.last-run.json
+++ b/apps/web/test-results/.last-run.json
@@ -1,4 +1,4 @@
 {
   "status": "failed",
   "failedTests": []
-}
+}
\ No newline at end of file
diff --git a/docs/developing/guides/event-types/minimum-cancellation-notice.mdx b/docs/developing/guides/event-types/minimum-cancellation-notice.mdx
new file mode 100644
index 00000000000000..3c328c4be865a7
--- /dev/null
+++ b/docs/developing/guides/event-types/minimum-cancellation-notice.mdx
@@ -0,0 +1,156 @@
+---
+title: "Minimum Cancellation Notice for Event Types"
+---
+
+This guide explains how the minimum cancellation notice feature works in Cal.com, allowing event organizers to prevent last-minute cancellations and reschedules.
+
+## Overview
+
+The minimum cancellation notice feature allows event type owners to set a time buffer that prevents attendees from cancelling or rescheduling bookings too close to the event start time. This helps reduce no-shows and last-minute disruptions.
+
+## How It Works
+
+### Configuration
+
+Event type owners can configure the minimum cancellation notice in the event type settings under the "Limits" section:
+
+1. Navigate to Event Types
+2. Edit an event type
+3. Go to the "Limits" tab
+4. Find "Minimum cancellation notice"
+5. Set the desired time period (minutes, hours, or days)
+
+### User Experience
+
+When an attendee attempts to cancel or reschedule:
+
+1. The system checks if the current time plus the minimum notice period exceeds the event start time
+2. If within the restricted period, the action is blocked with a clear error message
+3. If outside the restricted period, the action proceeds normally
+
+### Implementation Details
+
+#### Database Schema
+
+The feature adds a `minimumCancellationNotice` field to the EventType model:
+
+```prisma
+model EventType {
+  // ... existing fields
+  minimumCancellationNotice  Int?  @default(0) // in minutes
+}
+```
+
+#### API Validation
+
+The cancellation and reschedule endpoints validate the minimum notice:
+
+```typescript
+// Check if cancellation is allowed
+const currentTime = new Date();
+const eventStartTime = new Date(booking.startTime);
+const timeDifferenceMs = eventStartTime.getTime() - currentTime.getTime();
+const timeDifferenceMinutes = Math.floor(timeDifferenceMs / (1000 * 60));
+
+if (timeDifferenceMinutes < eventType.minimumCancellationNotice) {
+  throw new Error("Cancellation not allowed within minimum notice period");
+}
+```
+
+#### UI Components
+
+The `MinimumCancellationNoticeInput` component provides the configuration interface:
+
+- Time input field
+- Unit selector (minutes/hours/days)
+- Automatic conversion to minutes for storage
+
+## Configuration Examples
+
+### Common Use Cases
+
+1. **Business Meetings**: 24 hours notice
+   - Prevents last-minute cancellations that waste preparation time
+   
+2. **Medical Appointments**: 48 hours notice
+   - Allows time to fill the slot with waitlist patients
+   
+3. **Consultations**: 2 hours notice
+   - Provides flexibility while preventing immediate cancellations
+
+### Setting Up
+
+```typescript
+// Example: 24 hours minimum notice
+const eventType = {
+  minimumCancellationNotice: 1440 // 24 hours in minutes
+};
+
+// Example: 2 hours minimum notice
+const eventType = {
+  minimumCancellationNotice: 120 // 2 hours in minutes
+};
+```
+
+## Error Handling
+
+When a user attempts to cancel or reschedule within the restricted period, they receive a clear error message:
+
+- **Cancellation**: "You cannot cancel this booking because it's too close to the start time. The minimum cancellation notice is [X] [hours/days]."
+- **Reschedule**: "You cannot reschedule this booking because it's too close to the start time. The minimum reschedule notice is [X] [hours/days]."
+
+## Best Practices
+
+1. **Set Reasonable Limits**: Balance between protecting your time and providing flexibility to attendees
+2. **Communicate Clearly**: Include the cancellation policy in booking confirmation emails
+3. **Consider Time Zones**: The feature automatically handles time zone differences
+4. **Test Your Settings**: Book test events to ensure the restrictions work as expected
+
+## Technical Implementation
+
+### Frontend Components
+
+- `MinimumCancellationNoticeInput`: Configuration component in event type settings
+- `CancelBookingDialog`: Enhanced with minimum notice validation
+- `RescheduleDialog`: Checks minimum notice before allowing reschedule
+
+### Backend Services
+
+- `handleCancelBooking`: Validates minimum notice before processing cancellation
+- `rescheduleBooking`: Enforces minimum notice for reschedule requests
+- tRPC procedures updated with validation logic
+
+### Database Migration
+
+The feature includes a Prisma migration to add the necessary field:
+
+```sql
+ALTER TABLE "EventType" 
+ADD COLUMN "minimumCancellationNotice" INTEGER DEFAULT 0;
+```
+
+## Testing
+
+The feature includes comprehensive tests:
+
+1. **Unit Tests**: Validation logic for time calculations
+2. **Integration Tests**: API endpoint behavior
+3. **E2E Tests**: Complete user flows for cancellation and reschedule
+
+## Related Features
+
+- **Booking Limits**: Set minimum/maximum notice for new bookings
+- **Buffer Time**: Add time between bookings
+- **Availability Schedule**: Define when bookings can be made
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Cancellation Still Allowed**: Check that the event type has been saved with the minimum notice setting
+2. **Wrong Time Calculation**: Ensure time zones are properly configured
+3. **Missing UI Option**: Verify you have the latest version with this feature
+
+### Support
+
+For additional help, please refer to the Cal.com documentation or contact support.
\ No newline at end of file
diff --git a/packages/features/bookings/lib/getBookingToDelete.ts b/packages/features/bookings/lib/getBookingToDelete.ts
index e218ec254acc75..f1e82f084a90e4 100644
--- a/packages/features/bookings/lib/getBookingToDelete.ts
+++ b/packages/features/bookings/lib/getBookingToDelete.ts
@@ -70,6 +70,7 @@ export async function getBookingToDelete(id: number | undefined, uid: string | u
           length: true,
           seatsPerTimeSlot: true,
           disableCancelling: true,
+          minimumCancellationNotice: true,
           bookingFields: true,
           seatsShowAttendees: true,
           metadata: true,
diff --git a/packages/features/bookings/lib/handleCancelBooking.ts b/packages/features/bookings/lib/handleCancelBooking.ts
index fb8038922cf053..d6ebc1509a7e79 100644
--- a/packages/features/bookings/lib/handleCancelBooking.ts
+++ b/packages/features/bookings/lib/handleCancelBooking.ts
@@ -113,6 +113,33 @@ async function handler(input: CancelBookingInput) {
     });
   }
 
+  // Check minimum cancellation notice
+  const minimumCancellationNotice = bookingToDelete.eventType?.minimumCancellationNotice || 0;
+  if (minimumCancellationNotice > 0) {
+    const now = dayjs();
+    const bookingStart = dayjs(bookingToDelete.startTime);
+    const minutesUntilEvent = bookingStart.diff(now, 'minute');
+    
+    if (minutesUntilEvent < minimumCancellationNotice) {
+      const hours = Math.floor(minimumCancellationNotice / 60);
+      const minutes = minimumCancellationNotice % 60;
+      let timeString = '';
+      
+      if (hours > 0 && minutes > 0) {
+        timeString = `${hours} hour${hours > 1 ? 's' : ''} and ${minutes} minute${minutes > 1 ? 's' : ''}`;
+      } else if (hours > 0) {
+        timeString = `${hours} hour${hours > 1 ? 's' : ''}`;
+      } else {
+        timeString = `${minutes} minute${minutes > 1 ? 's' : ''}`;
+      }
+      
+      throw new HttpError({
+        statusCode: 403,
+        message: `Cannot cancel within ${timeString} of event start`,
+      });
+    }
+  }
+
   if (!platformClientId && !cancellationReason?.trim() && bookingToDelete.userId == userId) {
     throw new HttpError({
       statusCode: 400,
@@ -561,4 +588,4 @@ async function handler(input: CancelBookingInput) {
   } satisfies HandleCancelBookingResponse;
 }
 
-export default handler;
+export default handler;
\ No newline at end of file
diff --git a/packages/features/bookings/lib/handleCancelBooking/test/handleCancelBooking.minimumNotice.test.ts b/packages/features/bookings/lib/handleCancelBooking/test/handleCancelBooking.minimumNotice.test.ts
new file mode 100644
index 00000000000000..9f23d71393d2de
--- /dev/null
+++ b/packages/features/bookings/lib/handleCancelBooking/test/handleCancelBooking.minimumNotice.test.ts
@@ -0,0 +1,820 @@
+import {
+  createBookingScenario,
+  getBooker,
+  getOrganizer,
+  getScenarioData,
+  TestData,
+  getDate,
+  mockCalendarToHaveNoBusySlots,
+  mockSuccessfulVideoMeetingCreation,
+} from "@calcom/web/test/utils/bookingScenario/bookingScenario";
+import {
+  expectBookingCancelledWebhookToHaveBeenFired,
+  expectWebhookToHaveBeenCalledWith,
+} from "@calcom/web/test/utils/bookingScenario/expects";
+import { setupAndTeardown } from "@calcom/web/test/utils/bookingScenario/setupAndTeardown";
+
+import { describe, expect, vi, beforeEach, afterEach, test } from "vitest";
+
+import dayjs from "@calcom/dayjs";
+import { HttpError } from "@calcom/lib/http-error";
+import { BookingStatus } from "@calcom/prisma/enums";
+
+vi.mock("@calcom/lib/payment/processPaymentRefund", () => ({
+  processPaymentRefund: vi.fn(),
+}));
+
+describe("handleCancelBooking - Minimum Cancellation Notice", () => {
+  setupAndTeardown();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("Should block cancellation within 24-hour minimum notice period", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 101,
+      schedules: [TestData.schedules.IstWorkHours],
+    });
+
+    const bookingUid = "h5Wv3eHgconAED2j4gcVhP";
+    const bookingId = 1020;
+
+    // Create a booking that starts in 2 hours
+    const bookingStartTime = dayjs().add(2, "hours");
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 1,
+            slotInterval: 30,
+            length: 30,
+            minimumCancellationNotice: 1440, // 24 hours in minutes
+            users: [
+              {
+                id: 101,
+              },
+            ],
+          },
+        ],
+        bookings: [
+          {
+            id: bookingId,
+            uid: bookingUid,
+            eventTypeId: 1,
+            userId: 101,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: bookingStartTime.toISOString(),
+            endTime: bookingStartTime.add(30, "minutes").toISOString(),
+          },
+        ],
+        organizer,
+      })
+    );
+
+    // Attempt to cancel the booking
+    await expect(
+      handleCancelBooking({
+        bookingData: {
+          uid: bookingUid,
+          cancellationReason: "Cannot make it",
+        },
+        userId: 101,
+      })
+    ).rejects.toThrow(HttpError);
+
+    try {
+      await handleCancelBooking({
+        bookingData: {
+          uid: bookingUid,
+          cancellationReason: "Cannot make it",
+        },
+        userId: 101,
+      });
+    } catch (error) {
+      expect(error).toBeInstanceOf(HttpError);
+      expect((error as HttpError).statusCode).toBe(403);
+      expect((error as HttpError).message).toContain("Cannot cancel within 24 hours of event start");
+    }
+  });
+
+  test("Should allow cancellation outside minimum notice period", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 102,
+      schedules: [TestData.schedules.IstWorkHours],
+    });
+
+    const bookingUid = "h5Wv3eHgconAED2j4gcVhQ";
+    const bookingId = 1021;
+
+    // Create a booking that starts in 48 hours
+    const bookingStartTime = dayjs().add(48, "hours");
+
+    await createBookingScenario(
+      getScenarioData({
+        webhooks: [
+          {
+            userId: organizer.id,
+            eventTriggers: ["BOOKING_CANCELLED"],
+            subscriberUrl: "http://my-webhook.example.com",
+            active: true,
+            eventTypeId: 2,
+            appId: null,
+          },
+        ],
+        eventTypes: [
+          {
+            id: 2,
+            slotInterval: 30,
+            length: 30,
+            minimumCancellationNotice: 1440, // 24 hours in minutes
+            users: [
+              {
+                id: 102,
+              },
+            ],
+          },
+        ],
+        bookings: [
+          {
+            id: bookingId,
+            uid: bookingUid,
+            eventTypeId: 2,
+            userId: 102,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+              location: { optionValue: "", value: "integrations:daily" },
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: bookingStartTime.toISOString(),
+            endTime: bookingStartTime.add(30, "minutes").toISOString(),
+          },
+        ],
+        organizer,
+      })
+    );
+
+    // Should successfully cancel the booking
+    const result = await handleCancelBooking({
+      bookingData: {
+        uid: bookingUid,
+        cancellationReason: "Schedule conflict",
+      },
+      userId: 102,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe("Booking successfully cancelled.");
+    expect(result.bookingUid).toBe(bookingUid);
+
+    expectBookingCancelledWebhookToHaveBeenFired({
+      booker,
+      organizer,
+      location: "integrations:daily",
+      subscriberUrl: "http://my-webhook.example.com",
+      cancelledBy: organizer.email,
+    });
+  });
+
+  test("Should format error message correctly for different time periods", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const testCases = [
+      {
+        minutes: 30,
+        expectedMessage: "Cannot cancel within 30 minutes of event start",
+        hoursBeforeEvent: 0.25,
+      },
+      {
+        minutes: 60,
+        expectedMessage: "Cannot cancel within 1 hour of event start",
+        hoursBeforeEvent: 0.5,
+      },
+      {
+        minutes: 90,
+        expectedMessage: "Cannot cancel within 1 hour and 30 minutes of event start",
+        hoursBeforeEvent: 1,
+      },
+      {
+        minutes: 120,
+        expectedMessage: "Cannot cancel within 2 hours of event start",
+        hoursBeforeEvent: 1.5,
+      },
+      {
+        minutes: 2880,
+        expectedMessage: "Cannot cancel within 48 hours of event start",
+        hoursBeforeEvent: 24,
+      },
+    ];
+
+    for (const testCase of testCases) {
+      const booker = getBooker({
+        email: "booker@example.com",
+        name: "Booker",
+      });
+
+      const organizer = getOrganizer({
+        name: "Organizer",
+        email: "organizer@example.com",
+        id: 103 + testCases.indexOf(testCase),
+        schedules: [TestData.schedules.IstWorkHours],
+      });
+
+      const bookingUid = `booking-${testCase.minutes}`;
+      const bookingId = 2000 + testCases.indexOf(testCase);
+
+      // Create a booking that violates the minimum notice
+      const bookingStartTime = dayjs().add(testCase.hoursBeforeEvent, "hours");
+
+      await createBookingScenario(
+        getScenarioData({
+          eventTypes: [
+            {
+              id: 100 + testCases.indexOf(testCase),
+              slotInterval: 30,
+              length: 30,
+              minimumCancellationNotice: testCase.minutes,
+              users: [
+                {
+                  id: 103 + testCases.indexOf(testCase),
+                },
+              ],
+            },
+          ],
+          bookings: [
+            {
+              id: bookingId,
+              uid: bookingUid,
+              eventTypeId: 100 + testCases.indexOf(testCase),
+              userId: 103 + testCases.indexOf(testCase),
+              responses: {
+                email: booker.email,
+                name: booker.name,
+              },
+              status: BookingStatus.ACCEPTED,
+              startTime: bookingStartTime.toISOString(),
+              endTime: bookingStartTime.add(30, "minutes").toISOString(),
+            },
+          ],
+          organizer,
+        })
+      );
+
+      try {
+        await handleCancelBooking({
+          bookingData: {
+            uid: bookingUid,
+            cancellationReason: "Test cancellation",
+          },
+          userId: 103 + testCases.indexOf(testCase),
+        });
+
+        // Should not reach here
+        expect(true).toBe(false);
+      } catch (error) {
+        expect(error).toBeInstanceOf(HttpError);
+        expect((error as HttpError).statusCode).toBe(403);
+        expect((error as HttpError).message).toBe(testCase.expectedMessage);
+      }
+    }
+  });
+
+  test("Should allow cancellation when minimumCancellationNotice is 0", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 110,
+      schedules: [TestData.schedules.IstWorkHours],
+    });
+
+    const bookingUid = "no-restriction-booking";
+    const bookingId = 3000;
+
+    // Create a booking that starts in 30 minutes
+    const bookingStartTime = dayjs().add(30, "minutes");
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 200,
+            slotInterval: 30,
+            length: 30,
+            minimumCancellationNotice: 0, // No restriction
+            users: [
+              {
+                id: 110,
+              },
+            ],
+          },
+        ],
+        bookings: [
+          {
+            id: bookingId,
+            uid: bookingUid,
+            eventTypeId: 200,
+            userId: 110,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: bookingStartTime.toISOString(),
+            endTime: bookingStartTime.add(30, "minutes").toISOString(),
+          },
+        ],
+        organizer,
+      })
+    );
+
+    // Should successfully cancel the booking even though it's only 30 minutes away
+    const result = await handleCancelBooking({
+      bookingData: {
+        uid: bookingUid,
+        cancellationReason: "Last minute change",
+      },
+      userId: 110,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe("Booking successfully cancelled.");
+    expect(result.bookingUid).toBe(bookingUid);
+  });
+
+  test("Should allow cancellation when minimumCancellationNotice is undefined", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 111,
+      schedules: [TestData.schedules.IstWorkHours],
+    });
+
+    const bookingUid = "undefined-restriction-booking";
+    const bookingId = 3001;
+
+    // Create a booking that starts in 15 minutes
+    const bookingStartTime = dayjs().add(15, "minutes");
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 201,
+            slotInterval: 30,
+            length: 30,
+            // minimumCancellationNotice is not set (undefined)
+            users: [
+              {
+                id: 111,
+              },
+            ],
+          },
+        ],
+        bookings: [
+          {
+            id: bookingId,
+            uid: bookingUid,
+            eventTypeId: 201,
+            userId: 111,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: bookingStartTime.toISOString(),
+            endTime: bookingStartTime.add(30, "minutes").toISOString(),
+          },
+        ],
+        organizer,
+      })
+    );
+
+    // Should successfully cancel the booking
+    const result = await handleCancelBooking({
+      bookingData: {
+        uid: bookingUid,
+        cancellationReason: "Urgent matter",
+      },
+      userId: 111,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe("Booking successfully cancelled.");
+    expect(result.bookingUid).toBe(bookingUid);
+  });
+
+  test("Should calculate time difference correctly across time zones", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 112,
+      schedules: [TestData.schedules.IstWorkHours],
+      timeZone: "America/New_York",
+    });
+
+    const bookingUid = "timezone-booking";
+    const bookingId = 3002;
+
+    // Create a booking in UTC that starts in 2 hours
+    const bookingStartTime = dayjs().utc().add(2, "hours");
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 202,
+            slotInterval: 30,
+            length: 30,
+            minimumCancellationNotice: 180, // 3 hours
+            users: [
+              {
+                id: 112,
+              },
+            ],
+          },
+        ],
+        bookings: [
+          {
+            id: bookingId,
+            uid: bookingUid,
+            eventTypeId: 202,
+            userId: 112,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: bookingStartTime.toISOString(),
+            endTime: bookingStartTime.add(30, "minutes").toISOString(),
+          },
+        ],
+        organizer,
+      })
+    );
+
+    // Should block cancellation as it's within 3 hours
+    try {
+      await handleCancelBooking({
+        bookingData: {
+          uid: bookingUid,
+          cancellationReason: "Timezone test",
+        },
+        userId: 112,
+      });
+
+      expect(true).toBe(false);
+    } catch (error) {
+      expect(error).toBeInstanceOf(HttpError);
+      expect((error as HttpError).statusCode).toBe(403);
+      expect((error as HttpError).message).toContain("Cannot cancel within 3 hours of event start");
+    }
+  });
+
+  test("Should check minimum notice for recurring event bookings", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 113,
+      schedules: [TestData.schedules.IstWorkHours],
+    });
+
+    const recurringEventId = "recurring-series-123";
+    const bookingUid = "recurring-booking-1";
+    const bookingId = 3003;
+
+    // Create a recurring booking where first instance is in 2 hours
+    const bookingStartTime = dayjs().add(2, "hours");
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 203,
+            slotInterval: 30,
+            length: 30,
+            minimumCancellationNotice: 1440, // 24 hours
+            recurringEvent: {
+              freq: 2, // Weekly
+              count: 4,
+              interval: 1,
+            },
+            users: [
+              {
+                id: 113,
+              },
+            ],
+          },
+        ],
+        bookings: [
+          {
+            id: bookingId,
+            uid: bookingUid,
+            eventTypeId: 203,
+            userId: 113,
+            recurringEventId,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: bookingStartTime.toISOString(),
+            endTime: bookingStartTime.add(30, "minutes").toISOString(),
+          },
+        ],
+        organizer,
+      })
+    );
+
+    // Should block cancellation of single instance within notice period
+    try {
+      await handleCancelBooking({
+        bookingData: {
+          uid: bookingUid,
+          cancellationReason: "Cannot make this instance",
+        },
+        userId: 113,
+      });
+
+      expect(true).toBe(false);
+    } catch (error) {
+      expect(error).toBeInstanceOf(HttpError);
+      expect((error as HttpError).statusCode).toBe(403);
+      expect((error as HttpError).message).toContain("Cannot cancel within 24 hours of event start");
+    }
+  });
+
+  test("Should validate minimum notice for team event bookings", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Team Member",
+      email: "team@example.com",
+      id: 114,
+      schedules: [TestData.schedules.IstWorkHours],
+    });
+
+    const bookingUid = "team-booking";
+    const bookingId = 3004;
+
+    // Create a team booking that starts in 30 minutes
+    const bookingStartTime = dayjs().add(30, "minutes");
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 204,
+            slotInterval: 30,
+            length: 30,
+            minimumCancellationNotice: 60, // 1 hour
+            team: {
+              id: 1,
+              name: "Test Team",
+            },
+            users: [
+              {
+                id: 114,
+              },
+            ],
+          },
+        ],
+        bookings: [
+          {
+            id: bookingId,
+            uid: bookingUid,
+            eventTypeId: 204,
+            userId: 114,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: bookingStartTime.toISOString(),
+            endTime: bookingStartTime.add(30, "minutes").toISOString(),
+          },
+        ],
+        organizer,
+      })
+    );
+
+    // Should block cancellation as it's within 1 hour
+    try {
+      await handleCancelBooking({
+        bookingData: {
+          uid: bookingUid,
+          cancellationReason: "Team event cancellation",
+        },
+        userId: 114,
+      });
+
+      expect(true).toBe(false);
+    } catch (error) {
+      expect(error).toBeInstanceOf(HttpError);
+      expect((error as HttpError).statusCode).toBe(403);
+      expect((error as HttpError).message).toContain("Cannot cancel within 1 hour of event start");
+    }
+  });
+
+  test("Should handle edge case of booking exactly at minimum notice boundary", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 115,
+      schedules: [TestData.schedules.IstWorkHours],
+    });
+
+    const bookingUid = "boundary-booking";
+    const bookingId = 3005;
+
+    // Create a booking that starts exactly 60 minutes from now
+    // Add 1 second buffer to account for test execution time
+    const bookingStartTime = dayjs().add(60, "minutes").add(1, "second");
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 205,
+            slotInterval: 30,
+            length: 30,
+            minimumCancellationNotice: 60, // Exactly 1 hour
+            users: [
+              {
+                id: 115,
+              },
+            ],
+          },
+        ],
+        bookings: [
+          {
+            id: bookingId,
+            uid: bookingUid,
+            eventTypeId: 205,
+            userId: 115,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: bookingStartTime.toISOString(),
+            endTime: bookingStartTime.add(30, "minutes").toISOString(),
+          },
+        ],
+        organizer,
+      })
+    );
+
+    // Should allow cancellation as it's exactly at the boundary (not within)
+    const result = await handleCancelBooking({
+      bookingData: {
+        uid: bookingUid,
+        cancellationReason: "Boundary test",
+      },
+      userId: 115,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe("Booking successfully cancelled.");
+    expect(result.bookingUid).toBe(bookingUid);
+  });
+
+  test("Should not affect already cancelled bookings", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 116,
+      schedules: [TestData.schedules.IstWorkHours],
+    });
+
+    const bookingUid = "already-cancelled";
+    const bookingId = 3006;
+
+    const bookingStartTime = dayjs().add(2, "hours");
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 206,
+            slotInterval: 30,
+            length: 30,
+            minimumCancellationNotice: 1440,
+            users: [
+              {
+                id: 116,
+              },
+            ],
+          },
+        ],
+        bookings: [
+          {
+            id: bookingId,
+            uid: bookingUid,
+            eventTypeId: 206,
+            userId: 116,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+            },
+            status: BookingStatus.CANCELLED, // Already cancelled
+            startTime: bookingStartTime.toISOString(),
+            endTime: bookingStartTime.add(30, "minutes").toISOString(),
+          },
+        ],
+        organizer,
+      })
+    );
+
+    // Should throw error for already cancelled booking
+    try {
+      await handleCancelBooking({
+        bookingData: {
+          uid: bookingUid,
+          cancellationReason: "Trying to cancel again",
+        },
+        userId: 116,
+      });
+
+      expect(true).toBe(false);
+    } catch (error) {
+      expect(error).toBeInstanceOf(HttpError);
+      expect((error as HttpError).statusCode).toBe(400);
+      expect((error as HttpError).message).toBe("This booking has already been cancelled.");
+    }
+  });
+});
diff --git a/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.edge.test.ts b/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.edge.test.ts
new file mode 100644
index 00000000000000..210d1fe0861367
--- /dev/null
+++ b/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.edge.test.ts
@@ -0,0 +1,543 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import dayjs from "@calcom/dayjs";
+import { HttpError } from "@calcom/lib/http-error";
+import { BookingRepository } from "@calcom/lib/server/repository/booking";
+import { BookingStatus } from "@calcom/prisma/enums";
+import { getOriginalRescheduledBooking } from "./originalRescheduledBookingUtils";
+
+// Mock the prisma client
+vi.mock("@calcom/prisma", () => ({
+  prisma: {},
+}));
+
+// Mock the BookingRepository
+vi.mock("@calcom/lib/server/repository/booking");
+
+describe("originalRescheduledBookingUtils - Edge Cases", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2024-01-01T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe("Boundary conditions for minimum cancellation notice", () => {
+    it("should block reschedule exactly at the minimum notice boundary", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(720, "minutes").toDate(), // Exactly 12 hours (720 minutes) from now
+        eventType: {
+          minimumCancellationNotice: 720, // 12 hours minimum notice
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      // Should still block at exactly the boundary
+      await expect(getOriginalRescheduledBooking("test-uid")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 12 hours of event start",
+        })
+      );
+    });
+
+    it("should allow reschedule one minute after the minimum notice boundary", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(721, "minutes").toDate(), // 12 hours and 1 minute from now
+        eventType: {
+          minimumCancellationNotice: 720, // 12 hours minimum notice
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+
+    it("should handle events in the past", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().subtract(1, "hour").toDate(), // Event was 1 hour ago
+        eventType: {
+          minimumCancellationNotice: 120, // 2 hours minimum notice
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      // Should block reschedule for past events
+      await expect(getOriginalRescheduledBooking("test-uid")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 2 hours of event start",
+        })
+      );
+    });
+  });
+
+  describe("Time formatting edge cases", () => {
+    it("should handle singular vs plural time units correctly", async () => {
+      // Test 1 hour (singular)
+      const mockBooking1Hour = {
+        id: 1,
+        uid: "test-uid-1h",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(30, "minutes").toDate(),
+        eventType: {
+          minimumCancellationNotice: 60, // 1 hour
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking1Hour);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("test-uid-1h")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 1 hour of event start", // Singular
+        })
+      );
+
+      // Test 2 hours (plural)
+      const mockBooking2Hours = {
+        id: 2,
+        uid: "test-uid-2h",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(90, "minutes").toDate(),
+        eventType: {
+          minimumCancellationNotice: 120, // 2 hours
+        },
+        rescheduled: false,
+      };
+
+      mockFindOriginalRescheduledBooking.mockResolvedValue(mockBooking2Hours);
+
+      await expect(getOriginalRescheduledBooking("test-uid-2h")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 2 hours of event start", // Plural
+        })
+      );
+
+      // Test 1 minute (singular)
+      const mockBooking1Minute = {
+        id: 3,
+        uid: "test-uid-1m",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(30, "seconds").toDate(),
+        eventType: {
+          minimumCancellationNotice: 1, // 1 minute
+        },
+        rescheduled: false,
+      };
+
+      mockFindOriginalRescheduledBooking.mockResolvedValue(mockBooking1Minute);
+
+      await expect(getOriginalRescheduledBooking("test-uid-1m")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 1 minute of event start", // Singular
+        })
+      );
+
+      // Test 2 minutes (plural)
+      const mockBooking2Minutes = {
+        id: 4,
+        uid: "test-uid-2m",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(1, "minute").toDate(),
+        eventType: {
+          minimumCancellationNotice: 2, // 2 minutes
+        },
+        rescheduled: false,
+      };
+
+      mockFindOriginalRescheduledBooking.mockResolvedValue(mockBooking2Minutes);
+
+      await expect(getOriginalRescheduledBooking("test-uid-2m")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 2 minutes of event start", // Plural
+        })
+      );
+    });
+
+    it("should handle large time periods correctly", async () => {
+      // Test 48 hours (2 days)
+      const mockBooking48Hours = {
+        id: 1,
+        uid: "test-uid-48h",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(36, "hours").toDate(), // 36 hours from now
+        eventType: {
+          minimumCancellationNotice: 2880, // 48 hours in minutes
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking48Hours);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("test-uid-48h")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 48 hours of event start",
+        })
+      );
+
+      // Test 25 hours
+      const mockBooking25Hours = {
+        id: 2,
+        uid: "test-uid-25h",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(24, "hours").toDate(),
+        eventType: {
+          minimumCancellationNotice: 1500, // 25 hours in minutes
+        },
+        rescheduled: false,
+      };
+
+      mockFindOriginalRescheduledBooking.mockResolvedValue(mockBooking25Hours);
+
+      await expect(getOriginalRescheduledBooking("test-uid-25h")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 25 hours of event start",
+        })
+      );
+    });
+
+    it("should handle complex time combinations", async () => {
+      // Test 61 minutes (1 hour and 1 minute - both singular)
+      const mockBooking61Min = {
+        id: 1,
+        uid: "test-uid-61m",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(30, "minutes").toDate(),
+        eventType: {
+          minimumCancellationNotice: 61,
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking61Min);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("test-uid-61m")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 1 hour and 1 minute of event start",
+        })
+      );
+
+      // Test 122 minutes (2 hours and 2 minutes - both plural)
+      const mockBooking122Min = {
+        id: 2,
+        uid: "test-uid-122m",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(60, "minutes").toDate(),
+        eventType: {
+          minimumCancellationNotice: 122,
+        },
+        rescheduled: false,
+      };
+
+      mockFindOriginalRescheduledBooking.mockResolvedValue(mockBooking122Min);
+
+      await expect(getOriginalRescheduledBooking("test-uid-122m")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 2 hours and 2 minutes of event start",
+        })
+      );
+
+      // Test 121 minutes (2 hours and 1 minute - mixed)
+      const mockBooking121Min = {
+        id: 3,
+        uid: "test-uid-121m",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(60, "minutes").toDate(),
+        eventType: {
+          minimumCancellationNotice: 121,
+        },
+        rescheduled: false,
+      };
+
+      mockFindOriginalRescheduledBooking.mockResolvedValue(mockBooking121Min);
+
+      await expect(getOriginalRescheduledBooking("test-uid-121m")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 2 hours and 1 minute of event start",
+        })
+      );
+    });
+  });
+
+  describe("Booking status edge cases", () => {
+    it("should allow reschedule for cancelled but rescheduled bookings", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.CANCELLED,
+        startTime: dayjs().add(24, "hours").toDate(),
+        eventType: null,
+        rescheduled: true, // This is set to true
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+
+    it("should handle bookings with PENDING status", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.PENDING,
+        startTime: dayjs().add(24, "hours").toDate(),
+        eventType: {
+          minimumCancellationNotice: 0,
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+
+    it("should handle bookings with REJECTED status appropriately", async () => {
+      // REJECTED bookings are filtered out in the query, so this would return null
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(null);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("rejected-uid")).rejects.toThrow(
+        new HttpError({ statusCode: 404, message: "Could not find original booking" })
+      );
+    });
+  });
+
+  describe("EventType configuration edge cases", () => {
+    it("should handle bookings with no eventType", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(30, "minutes").toDate(),
+        eventType: null, // No event type
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      // Should allow reschedule when no event type is present (defaults to 0 minimum notice)
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+
+    it("should handle bookings with eventType but no minimumCancellationNotice field", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(30, "minutes").toDate(),
+        eventType: {
+          // No minimumCancellationNotice field
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      // Should allow reschedule when field is undefined (defaults to 0)
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+
+    it("should handle negative minimumCancellationNotice values", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(30, "minutes").toDate(),
+        eventType: {
+          minimumCancellationNotice: -60, // Negative value (should be treated as 0)
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      // Should allow reschedule when value is negative (treated as no restriction)
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+  });
+
+  describe("Seats functionality", () => {
+    it("should work correctly with seatsEventType parameter", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(24, "hours").toDate(),
+        eventType: {
+          minimumCancellationNotice: 0,
+          seatsPerTimeSlot: 10,
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      const result = await getOriginalRescheduledBooking("test-uid", true);
+      expect(result).toEqual(mockBooking);
+      expect(mockFindOriginalRescheduledBooking).toHaveBeenCalledWith("test-uid", true);
+    });
+
+    it("should apply minimum notice validation for seat-based events", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(2, "hours").toDate(),
+        eventType: {
+          minimumCancellationNotice: 180, // 3 hours
+          seatsPerTimeSlot: 5,
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("test-uid", true)).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 3 hours of event start",
+        })
+      );
+    });
+  });
+
+  describe("Time zone edge cases", () => {
+    it("should handle daylight saving time transitions", async () => {
+      // Set time to just before DST transition
+      const dstTransitionDate = new Date("2024-03-10T02:00:00-05:00"); // Example DST transition
+      vi.setSystemTime(dstTransitionDate);
+
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs(dstTransitionDate).add(3, "hours").toDate(), // After DST transition
+        eventType: {
+          minimumCancellationNotice: 180, // 3 hours
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      // The validation should still work correctly even with DST
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+  });
+
+  describe("Repository error handling", () => {
+    it("should propagate repository errors", async () => {
+      const mockFindOriginalRescheduledBooking = vi.fn().mockRejectedValue(
+        new Error("Database connection failed")
+      );
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("test-uid")).rejects.toThrow(
+        "Database connection failed"
+      );
+    });
+
+    it("should handle null eventType gracefully", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(1, "hour").toDate(),
+        eventType: null,
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+  });
+
+  describe("Concurrent reschedule attempts", () => {
+    it("should handle multiple rapid calls correctly", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(5, "hours").toDate(),
+        eventType: {
+          minimumCancellationNotice: 360, // 6 hours
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      // Simulate concurrent calls
+      const promises = [
+        getOriginalRescheduledBooking("test-uid"),
+        getOriginalRescheduledBooking("test-uid"),
+        getOriginalRescheduledBooking("test-uid"),
+      ];
+
+      const results = await Promise.allSettled(promises);
+
+      // All should fail with the same error
+      results.forEach((result) => {
+        expect(result.status).toBe("rejected");
+        if (result.status === "rejected") {
+          expect(result.reason).toBeInstanceOf(HttpError);
+          expect(result.reason.statusCode).toBe(403);
+          expect(result.reason.message).toBe("Cannot reschedule within 6 hours of event start");
+        }
+      });
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.test.ts b/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.test.ts
new file mode 100644
index 00000000000000..58b493a015379e
--- /dev/null
+++ b/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.test.ts
@@ -0,0 +1,177 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import dayjs from "@calcom/dayjs";
+import { HttpError } from "@calcom/lib/http-error";
+import { BookingRepository } from "@calcom/lib/server/repository/booking";
+import { BookingStatus } from "@calcom/prisma/enums";
+import { getOriginalRescheduledBooking } from "./originalRescheduledBookingUtils";
+
+// Mock the prisma client
+vi.mock("@calcom/prisma", () => ({
+  prisma: {},
+}));
+
+// Mock the BookingRepository
+vi.mock("@calcom/lib/server/repository/booking");
+
+describe("originalRescheduledBookingUtils", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+  });
+
+  describe("getOriginalRescheduledBooking", () => {
+    it("should throw error when booking is within minimum cancellation notice period", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(6, "hours").toDate(), // Booking starts in 6 hours
+        eventType: {
+          minimumCancellationNotice: 720, // 12 hours minimum notice
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("test-uid")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 12 hours of event start",
+        })
+      );
+    });
+
+    it("should allow reschedule when outside minimum cancellation notice period", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(13, "hours").toDate(), // Booking starts in 13 hours
+        eventType: {
+          minimumCancellationNotice: 720, // 12 hours minimum notice
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+
+    it("should allow reschedule when no minimum notice is set", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(30, "minutes").toDate(), // Booking starts in 30 minutes
+        eventType: {
+          minimumCancellationNotice: 0, // No minimum notice
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      const result = await getOriginalRescheduledBooking("test-uid");
+      expect(result).toEqual(mockBooking);
+    });
+
+    it("should format error message correctly for different time periods", async () => {
+      // Test 90 minutes (1 hour and 30 minutes)
+      const mockBooking90Min = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(60, "minutes").toDate(),
+        eventType: {
+          minimumCancellationNotice: 90,
+        },
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking90Min);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("test-uid")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 1 hour and 30 minutes of event start",
+        })
+      );
+
+      // Test 60 minutes (1 hour)
+      const mockBooking60Min = {
+        id: 2,
+        uid: "test-uid-2",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(30, "minutes").toDate(),
+        eventType: {
+          minimumCancellationNotice: 60,
+        },
+        rescheduled: false,
+      };
+
+      mockFindOriginalRescheduledBooking.mockResolvedValue(mockBooking60Min);
+
+      await expect(getOriginalRescheduledBooking("test-uid-2")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 1 hour of event start",
+        })
+      );
+
+      // Test 30 minutes
+      const mockBooking30Min = {
+        id: 3,
+        uid: "test-uid-3",
+        status: BookingStatus.ACCEPTED,
+        startTime: dayjs().add(15, "minutes").toDate(),
+        eventType: {
+          minimumCancellationNotice: 30,
+        },
+        rescheduled: false,
+      };
+
+      mockFindOriginalRescheduledBooking.mockResolvedValue(mockBooking30Min);
+
+      await expect(getOriginalRescheduledBooking("test-uid-3")).rejects.toThrow(
+        new HttpError({
+          statusCode: 403,
+          message: "Cannot reschedule within 30 minutes of event start",
+        })
+      );
+    });
+
+    it("should throw error when booking is not found", async () => {
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(null);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("non-existent-uid")).rejects.toThrow(
+        new HttpError({ statusCode: 404, message: "Could not find original booking" })
+      );
+    });
+
+    it("should throw error when booking is cancelled and not rescheduled", async () => {
+      const mockBooking = {
+        id: 1,
+        uid: "test-uid",
+        status: BookingStatus.CANCELLED,
+        startTime: dayjs().add(24, "hours").toDate(),
+        eventType: null,
+        rescheduled: false,
+      };
+
+      const mockFindOriginalRescheduledBooking = vi.fn().mockResolvedValue(mockBooking);
+      BookingRepository.prototype.findOriginalRescheduledBooking = mockFindOriginalRescheduledBooking;
+
+      await expect(getOriginalRescheduledBooking("test-uid")).rejects.toThrow(
+        new HttpError({ statusCode: 400, message: "CANCELLED_BOOKINGS_CANNOT_BE_RESCHEDULED" })
+      );
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.ts b/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.ts
index fc513f57dde7f4..f3c5248cb70c68 100644
--- a/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.ts
+++ b/packages/features/bookings/lib/handleNewBooking/originalRescheduledBookingUtils.ts
@@ -1,5 +1,6 @@
 import type { Prisma } from "@prisma/client";
 
+import dayjs from "@calcom/dayjs";
 import { ErrorCode } from "@calcom/lib/errorCodes";
 import { HttpError } from "@calcom/lib/http-error";
 import { BookingRepository } from "@calcom/lib/server/repository/booking";
@@ -18,9 +19,36 @@ export async function getOriginalRescheduledBooking(uid: string, seatsEventType?
     throw new HttpError({ statusCode: 400, message: ErrorCode.CancelledBookingsCannotBeRescheduled });
   }
 
+  // Check minimum cancellation notice for reschedule
+  const minimumCancellationNotice = originalBooking.eventType?.minimumCancellationNotice || 0;
+  if (minimumCancellationNotice > 0) {
+    const now = dayjs();
+    const bookingStart = dayjs(originalBooking.startTime);
+    const minutesUntilEvent = bookingStart.diff(now, 'minute');
+    
+    if (minutesUntilEvent < minimumCancellationNotice) {
+      const hours = Math.floor(minimumCancellationNotice / 60);
+      const minutes = minimumCancellationNotice % 60;
+      let timeString = '';
+      
+      if (hours > 0 && minutes > 0) {
+        timeString = `${hours} hour${hours > 1 ? 's' : ''} and ${minutes} minute${minutes > 1 ? 's' : ''}`;
+      } else if (hours > 0) {
+        timeString = `${hours} hour${hours > 1 ? 's' : ''}`;
+      } else {
+        timeString = `${minutes} minute${minutes > 1 ? 's' : ''}`;
+      }
+      
+      throw new HttpError({
+        statusCode: 403,
+        message: `Cannot reschedule within ${timeString} of event start`,
+      });
+    }
+  }
+
   return originalBooking;
 }
 
 export type BookingType = Prisma.PromiseReturnType<typeof getOriginalRescheduledBooking> | null;
 
-export type OriginalRescheduledBooking = Awaited<ReturnType<typeof getOriginalRescheduledBooking>> | null;
+export type OriginalRescheduledBooking = Awaited<ReturnType<typeof getOriginalRescheduledBooking>> | null;
\ No newline at end of file
diff --git a/packages/features/bookings/lib/minimumNotice.integration.test.ts b/packages/features/bookings/lib/minimumNotice.integration.test.ts
new file mode 100644
index 00000000000000..a5c5c65d62f7fe
--- /dev/null
+++ b/packages/features/bookings/lib/minimumNotice.integration.test.ts
@@ -0,0 +1,667 @@
+import { describe, expect, vi, beforeEach, afterEach, test } from "vitest";
+import dayjs from "@calcom/dayjs";
+import { BookingStatus } from "@calcom/prisma/enums";
+import { HttpError } from "@calcom/lib/http-error";
+import { TRPCError } from "@trpc/server";
+import {
+  createBookingScenario,
+  getBooker,
+  getOrganizer,
+  getScenarioData,
+  TestData,
+  mockCalendarToHaveNoBusySlots,
+  mockSuccessfulVideoMeetingCreation,
+} from "@calcom/web/test/utils/bookingScenario/bookingScenario";
+import { setupAndTeardown } from "@calcom/web/test/utils/bookingScenario/setupAndTeardown";
+
+vi.mock("@calcom/lib/payment/processPaymentRefund", () => ({
+  processPaymentRefund: vi.fn(),
+}));
+
+vi.mock("@calcom/emails", () => ({
+  sendCancelledEmailsAndSMS: vi.fn().mockResolvedValue(true),
+  sendRequestRescheduleEmailAndSMS: vi.fn().mockResolvedValue(true),
+}));
+
+describe("Minimum Cancellation/Reschedule Notice - Integration Tests", () => {
+  setupAndTeardown();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("Complete Flow - Cancellation and Reschedule", () => {
+    test("Should enforce minimum notice for both cancellation and reschedule", async () => {
+      const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking"))
+        .default;
+      const { requestRescheduleHandler } = await import(
+        "@calcom/trpc/server/routers/viewer/bookings/requestReschedule.handler"
+      );
+
+      const booker = getBooker({
+        email: "booker@example.com",
+        name: "Booker",
+      });
+
+      const organizer = getOrganizer({
+        name: "Organizer",
+        email: "organizer@example.com",
+        id: 201,
+        schedules: [TestData.schedules.IstWorkHours],
+      });
+
+      const bookingUid = "integrated-booking";
+      const bookingId = 7000;
+
+      // Create a booking that starts in 2 hours
+      const bookingStartTime = dayjs().add(2, "hours");
+
+      await createBookingScenario(
+        getScenarioData({
+          eventTypes: [
+            {
+              id: 600,
+              slotInterval: 30,
+              length: 30,
+              minimumCancellationNotice: 180, // 3 hours in minutes
+              users: [
+                {
+                  id: 201,
+                },
+              ],
+            },
+          ],
+          bookings: [
+            {
+              id: bookingId,
+              uid: bookingUid,
+              eventTypeId: 600,
+              userId: 201,
+              responses: {
+                email: booker.email,
+                name: booker.name,
+              },
+              status: BookingStatus.ACCEPTED,
+              startTime: bookingStartTime.toISOString(),
+              endTime: bookingStartTime.add(30, "minutes").toISOString(),
+            },
+          ],
+          organizer,
+        })
+      );
+
+      // Test cancellation - should be blocked
+      try {
+        await handleCancelBooking({
+          bookingData: {
+            uid: bookingUid,
+            cancellationReason: "Cannot make it",
+          },
+          userId: 201,
+        });
+        expect(true).toBe(false);
+      } catch (error) {
+        expect(error).toBeInstanceOf(HttpError);
+        expect((error as HttpError).statusCode).toBe(403);
+        expect((error as HttpError).message).toContain("Cannot cancel within 3 hours of event start");
+      }
+
+      // Test reschedule - should also be blocked
+      try {
+        await requestRescheduleHandler({
+          ctx: {
+            user: {
+              id: 201,
+              username: organizer.username,
+              email: organizer.email,
+            } as any,
+          },
+          input: {
+            bookingId: bookingUid,
+            rescheduleReason: "Need to reschedule",
+          },
+        });
+        expect(true).toBe(false);
+      } catch (error) {
+        expect(error).toBeInstanceOf(TRPCError);
+        expect((error as TRPCError).code).toBe("FORBIDDEN");
+        expect((error as TRPCError).message).toContain("Cannot reschedule within 3 hours of event start");
+      }
+    });
+
+    test("Should allow operations outside minimum notice period", async () => {
+      const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking"))
+        .default;
+      const { requestRescheduleHandler } = await import(
+        "@calcom/trpc/server/routers/viewer/bookings/requestReschedule.handler"
+      );
+
+      const booker = getBooker({
+        email: "booker@example.com",
+        name: "Booker",
+      });
+
+      const organizer = getOrganizer({
+        name: "Organizer",
+        email: "organizer@example.com",
+        id: 202,
+        schedules: [TestData.schedules.IstWorkHours],
+      });
+
+      // Create two bookings - one for cancel, one for reschedule
+      const cancelBookingUid = "cancel-allowed";
+      const rescheduleBookingUid = "reschedule-allowed";
+      const cancelBookingId = 7001;
+      const rescheduleBookingId = 7002;
+
+      // Both bookings start in 4 hours (outside 3-hour minimum notice)
+      const bookingStartTime = dayjs().add(4, "hours");
+
+      await createBookingScenario(
+        getScenarioData({
+          eventTypes: [
+            {
+              id: 601,
+              slotInterval: 30,
+              length: 30,
+              minimumCancellationNotice: 180, // 3 hours in minutes
+              users: [
+                {
+                  id: 202,
+                },
+              ],
+            },
+          ],
+          bookings: [
+            {
+              id: cancelBookingId,
+              uid: cancelBookingUid,
+              eventTypeId: 601,
+              userId: 202,
+              responses: {
+                email: booker.email,
+                name: booker.name,
+              },
+              status: BookingStatus.ACCEPTED,
+              startTime: bookingStartTime.toISOString(),
+              endTime: bookingStartTime.add(30, "minutes").toISOString(),
+            },
+            {
+              id: rescheduleBookingId,
+              uid: rescheduleBookingUid,
+              eventTypeId: 601,
+              userId: 202,
+              responses: {
+                email: booker.email,
+                name: booker.name,
+              },
+              status: BookingStatus.ACCEPTED,
+              startTime: bookingStartTime.toISOString(),
+              endTime: bookingStartTime.add(30, "minutes").toISOString(),
+            },
+          ],
+          organizer,
+        })
+      );
+
+      // Test cancellation - should succeed
+      const cancelResult = await handleCancelBooking({
+        bookingData: {
+          uid: cancelBookingUid,
+          cancellationReason: "Change of plans",
+        },
+        userId: 202,
+      });
+
+      expect(cancelResult.success).toBe(true);
+      expect(cancelResult.message).toBe("Booking successfully cancelled.");
+      expect(cancelResult.bookingUid).toBe(cancelBookingUid);
+
+      // Test reschedule - should succeed
+      const rescheduleResult = await requestRescheduleHandler({
+        ctx: {
+          user: {
+            id: 202,
+            username: organizer.username,
+            email: organizer.email,
+          } as any,
+        },
+        input: {
+          bookingId: rescheduleBookingUid,
+          rescheduleReason: "Schedule conflict",
+        },
+      });
+
+      expect(rescheduleResult).toBeDefined();
+    });
+  });
+
+  describe("Edge Cases and Special Scenarios", () => {
+    test("Should handle different minimum notice values consistently", async () => {
+      const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking"))
+        .default;
+      const { requestRescheduleHandler } = await import(
+        "@calcom/trpc/server/routers/viewer/bookings/requestReschedule.handler"
+      );
+
+      const testScenarios = [
+        {
+          minimumNotice: 0,
+          bookingHoursAway: 0.5,
+          shouldBlock: false,
+          description: "No restriction",
+        },
+        {
+          minimumNotice: 60,
+          bookingHoursAway: 0.5,
+          shouldBlock: true,
+          description: "1 hour restriction, booking in 30 minutes",
+        },
+        {
+          minimumNotice: 60,
+          bookingHoursAway: 1.5,
+          shouldBlock: false,
+          description: "1 hour restriction, booking in 90 minutes",
+        },
+        {
+          minimumNotice: 1440,
+          bookingHoursAway: 12,
+          shouldBlock: true,
+          description: "24 hour restriction, booking in 12 hours",
+        },
+        {
+          minimumNotice: 1440,
+          bookingHoursAway: 25,
+          shouldBlock: false,
+          description: "24 hour restriction, booking in 25 hours",
+        },
+      ];
+
+      for (const scenario of testScenarios) {
+        const booker = getBooker({
+          email: "booker@example.com",
+          name: "Booker",
+        });
+
+        const organizerId = 300 + testScenarios.indexOf(scenario);
+        const organizer = getOrganizer({
+          name: "Organizer",
+          email: "organizer@example.com",
+          id: organizerId,
+          schedules: [TestData.schedules.IstWorkHours],
+        });
+
+        const bookingUid = `scenario-${testScenarios.indexOf(scenario)}`;
+        const bookingId = 8000 + testScenarios.indexOf(scenario);
+        const eventTypeId = 700 + testScenarios.indexOf(scenario);
+
+        const bookingStartTime = dayjs().add(scenario.bookingHoursAway, "hours");
+
+        await createBookingScenario(
+          getScenarioData({
+            eventTypes: [
+              {
+                id: eventTypeId,
+                slotInterval: 30,
+                length: 30,
+                minimumCancellationNotice: scenario.minimumNotice,
+                users: [
+                  {
+                    id: organizerId,
+                  },
+                ],
+              },
+            ],
+            bookings: [
+              {
+                id: bookingId,
+                uid: bookingUid,
+                eventTypeId: eventTypeId,
+                userId: organizerId,
+                responses: {
+                  email: booker.email,
+                  name: booker.name,
+                },
+                status: BookingStatus.ACCEPTED,
+                startTime: bookingStartTime.toISOString(),
+                endTime: bookingStartTime.add(30, "minutes").toISOString(),
+              },
+            ],
+            organizer,
+          })
+        );
+
+        if (scenario.shouldBlock) {
+          // Should block both cancel and reschedule
+          await expect(
+            handleCancelBooking({
+              bookingData: {
+                uid: bookingUid,
+                cancellationReason: scenario.description,
+              },
+              userId: organizerId,
+            })
+          ).rejects.toThrow(HttpError);
+
+          await expect(
+            requestRescheduleHandler({
+              ctx: {
+                user: {
+                  id: organizerId,
+                  username: organizer.username,
+                  email: organizer.email,
+                } as any,
+              },
+              input: {
+                bookingId: bookingUid,
+                rescheduleReason: scenario.description,
+              },
+            })
+          ).rejects.toThrow(TRPCError);
+        } else {
+          // Should allow both cancel and reschedule
+          const cancelResult = await handleCancelBooking({
+            bookingData: {
+              uid: bookingUid,
+              cancellationReason: scenario.description,
+            },
+            userId: organizerId,
+          });
+
+          expect(cancelResult.success).toBe(true);
+
+          // Create a new booking for reschedule test since the previous one was cancelled
+          const rescheduleBookingUid = `${bookingUid}-reschedule`;
+          const rescheduleBookingId = bookingId + 1000;
+
+          await createBookingScenario(
+            getScenarioData({
+              eventTypes: [
+                {
+                  id: eventTypeId,
+                  slotInterval: 30,
+                  length: 30,
+                  minimumCancellationNotice: scenario.minimumNotice,
+                  users: [
+                    {
+                      id: organizerId,
+                    },
+                  ],
+                },
+              ],
+              bookings: [
+                {
+                  id: rescheduleBookingId,
+                  uid: rescheduleBookingUid,
+                  eventTypeId: eventTypeId,
+                  userId: organizerId,
+                  responses: {
+                    email: booker.email,
+                    name: booker.name,
+                  },
+                  status: BookingStatus.ACCEPTED,
+                  startTime: bookingStartTime.toISOString(),
+                  endTime: bookingStartTime.add(30, "minutes").toISOString(),
+                },
+              ],
+              organizer,
+            })
+          );
+
+          const rescheduleResult = await requestRescheduleHandler({
+            ctx: {
+              user: {
+                id: organizerId,
+                username: organizer.username,
+                email: organizer.email,
+              } as any,
+            },
+            input: {
+              bookingId: rescheduleBookingUid,
+              rescheduleReason: scenario.description,
+            },
+          });
+
+          expect(rescheduleResult).toBeDefined();
+        }
+      }
+    });
+
+    test("Should handle past bookings correctly", async () => {
+      const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking"))
+        .default;
+
+      const booker = getBooker({
+        email: "booker@example.com",
+        name: "Booker",
+      });
+
+      const organizer = getOrganizer({
+        name: "Organizer",
+        email: "organizer@example.com",
+        id: 400,
+        schedules: [TestData.schedules.IstWorkHours],
+      });
+
+      const bookingUid = "past-booking";
+      const bookingId = 9000;
+
+      // Create a booking that already happened (1 hour ago)
+      const bookingStartTime = dayjs().subtract(1, "hour");
+
+      await createBookingScenario(
+        getScenarioData({
+          eventTypes: [
+            {
+              id: 800,
+              slotInterval: 30,
+              length: 30,
+              minimumCancellationNotice: 60,
+              users: [
+                {
+                  id: 400,
+                },
+              ],
+            },
+          ],
+          bookings: [
+            {
+              id: bookingId,
+              uid: bookingUid,
+              eventTypeId: 800,
+              userId: 400,
+              responses: {
+                email: booker.email,
+                name: booker.name,
+              },
+              status: BookingStatus.ACCEPTED,
+              startTime: bookingStartTime.toISOString(),
+              endTime: bookingStartTime.add(30, "minutes").toISOString(),
+            },
+          ],
+          organizer,
+        })
+      );
+
+      // Should block cancellation of past booking
+      try {
+        await handleCancelBooking({
+          bookingData: {
+            uid: bookingUid,
+            cancellationReason: "Trying to cancel past booking",
+          },
+          userId: 400,
+        });
+        expect(true).toBe(false);
+      } catch (error) {
+        expect(error).toBeInstanceOf(HttpError);
+        // The error message will indicate the booking is in the past
+        expect((error as HttpError).statusCode).toBe(403);
+      }
+    });
+
+    test("Should validate minimum notice across different time zones", async () => {
+      const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking"))
+        .default;
+
+      const booker = getBooker({
+        email: "booker@example.com",
+        name: "Booker",
+        timeZone: "America/Los_Angeles",
+      });
+
+      const organizer = getOrganizer({
+        name: "Organizer",
+        email: "organizer@example.com",
+        id: 401,
+        schedules: [TestData.schedules.IstWorkHours],
+        timeZone: "Asia/Tokyo",
+      });
+
+      const bookingUid = "timezone-test";
+      const bookingId = 9001;
+
+      // Create a booking that's 2 hours away in UTC
+      const bookingStartTime = dayjs().utc().add(2, "hours");
+
+      await createBookingScenario(
+        getScenarioData({
+          eventTypes: [
+            {
+              id: 801,
+              slotInterval: 30,
+              length: 30,
+              minimumCancellationNotice: 180, // 3 hours
+              users: [
+                {
+                  id: 401,
+                },
+              ],
+            },
+          ],
+          bookings: [
+            {
+              id: bookingId,
+              uid: bookingUid,
+              eventTypeId: 801,
+              userId: 401,
+              responses: {
+                email: booker.email,
+                name: booker.name,
+              },
+              status: BookingStatus.ACCEPTED,
+              startTime: bookingStartTime.toISOString(),
+              endTime: bookingStartTime.add(30, "minutes").toISOString(),
+            },
+          ],
+          organizer,
+        })
+      );
+
+      // Should block cancellation regardless of time zone
+      try {
+        await handleCancelBooking({
+          bookingData: {
+            uid: bookingUid,
+            cancellationReason: "Timezone test",
+          },
+          userId: 401,
+        });
+        expect(true).toBe(false);
+      } catch (error) {
+        expect(error).toBeInstanceOf(HttpError);
+        expect((error as HttpError).statusCode).toBe(403);
+        expect((error as HttpError).message).toContain("Cannot cancel within 3 hours of event start");
+      }
+    });
+  });
+
+  describe("Performance and Stress Tests", () => {
+    test("Should handle multiple concurrent cancellation attempts efficiently", async () => {
+      const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking"))
+        .default;
+
+      const booker = getBooker({
+        email: "booker@example.com",
+        name: "Booker",
+      });
+
+      const organizer = getOrganizer({
+        name: "Organizer",
+        email: "organizer@example.com",
+        id: 500,
+        schedules: [TestData.schedules.IstWorkHours],
+      });
+
+      // Create multiple bookings
+      const bookings = [];
+      for (let i = 0; i < 5; i++) {
+        const hoursAway = i < 3 ? 1 : 5; // First 3 within notice, last 2 outside
+        bookings.push({
+          id: 10000 + i,
+          uid: `concurrent-${i}`,
+          eventTypeId: 900,
+          userId: 500,
+          responses: {
+            email: booker.email,
+            name: booker.name,
+          },
+          status: BookingStatus.ACCEPTED,
+          startTime: dayjs().add(hoursAway, "hours").toISOString(),
+          endTime: dayjs().add(hoursAway, "hours").add(30, "minutes").toISOString(),
+        });
+      }
+
+      await createBookingScenario(
+        getScenarioData({
+          eventTypes: [
+            {
+              id: 900,
+              slotInterval: 30,
+              length: 30,
+              minimumCancellationNotice: 120, // 2 hours
+              users: [
+                {
+                  id: 500,
+                },
+              ],
+            },
+          ],
+          bookings,
+          organizer,
+        })
+      );
+
+      // Attempt to cancel all bookings concurrently
+      const cancellationPromises = bookings.map((booking, index) =>
+        handleCancelBooking({
+          bookingData: {
+            uid: booking.uid,
+            cancellationReason: `Concurrent test ${index}`,
+          },
+          userId: 500,
+        }).catch((error) => ({ error, uid: booking.uid }))
+      );
+
+      const results = await Promise.all(cancellationPromises);
+
+      // First 3 should fail (within 2-hour notice)
+      for (let i = 0; i < 3; i++) {
+        const result = results[i] as { error: HttpError; uid: string };
+        expect(result.error).toBeInstanceOf(HttpError);
+        expect(result.error.statusCode).toBe(403);
+      }
+
+      // Last 2 should succeed (outside 2-hour notice)
+      for (let i = 3; i < 5; i++) {
+        const result = results[i] as any;
+        expect(result.success).toBe(true);
+        expect(result.message).toBe("Booking successfully cancelled.");
+      }
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/features/eventtypes/components/tabs/limits/EventLimitsTab.test.tsx b/packages/features/eventtypes/components/tabs/limits/EventLimitsTab.test.tsx
new file mode 100644
index 00000000000000..48b1f4727d44cb
--- /dev/null
+++ b/packages/features/eventtypes/components/tabs/limits/EventLimitsTab.test.tsx
@@ -0,0 +1,631 @@
+import { render, screen, fireEvent, waitFor, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { FormProvider, useForm } from "react-hook-form";
+import { vi, describe, it, expect, beforeEach, afterEach } from "vitest";
+
+import { EventLimitsTab } from "./EventLimitsTab";
+
+// Mock the hooks and utilities
+vi.mock("@calcom/lib/hooks/useLocale", () => ({
+  useLocale: () => ({
+    t: (key: string, vars?: any) => {
+      if (vars) {
+        return `${key}_${JSON.stringify(vars)}`;
+      }
+      return key;
+    },
+    i18n: {
+      language: "en",
+    },
+  }),
+}));
+
+vi.mock("@calcom/features/ee/managed-event-types/hooks/useLockedFieldsManager", () => ({
+  default: () => ({
+    shouldLockIndicator: vi.fn(() => null),
+    shouldLockDisableProps: vi.fn(() => ({ disabled: false })),
+  }),
+}));
+
+vi.mock("@calcom/lib/convertToNewDurationType", () => ({
+  default: vi.fn((from: string, to: string, value: number) => {
+    if (from === "minutes" && to === "minutes") return value;
+    if (from === "minutes" && to === "hours") return value / 60;
+    if (from === "minutes" && to === "days") return value / (60 * 24);
+    if (from === "hours" && to === "minutes") return value * 60;
+    if (from === "days" && to === "minutes") return value * 60 * 24;
+    return value;
+  }),
+}));
+
+vi.mock("@calcom/lib/findDurationType", () => ({
+  default: vi.fn((value: number) => {
+    if (value >= 1440) return "days";
+    if (value >= 60) return "hours";
+    return "minutes";
+  }),
+}));
+
+vi.mock("@calcom/features/eventtypes/lib/getDefinedBufferTimes", () => ({
+  getDefinedBufferTimes: () => [5, 10, 15, 20, 30, 45, 60, 90, 120],
+}));
+
+vi.mock("@formkit/auto-animate/react", () => ({
+  useAutoAnimate: () => [null],
+}));
+
+// Mock the MinimumCancellationNoticeInput component
+vi.mock("./MinimumCancellationNoticeInput", () => ({
+  default: ({ name, disabled, customClassNames, ...props }: any) => (
+    <div data-testid="minimum-cancellation-notice-input">
+      <input
+        type="number"
+        name={name}
+        disabled={disabled}
+        placeholder="Minimum Cancellation Notice"
+        {...props}
+      />
+    </div>
+  ),
+}));
+
+const mockEventType = {
+  id: 1,
+  title: "Test Event",
+  slug: "test-event",
+  length: 30,
+  minimumBookingNotice: 60,
+  minimumCancellationNotice: 120,
+  beforeEventBuffer: 0,
+  afterEventBuffer: 0,
+  slotInterval: null,
+  bookingLimits: {},
+  durationLimits: {},
+  periodType: "UNLIMITED",
+  periodDays: null,
+  periodCountCalendarDays: null,
+  periodDates: {
+    startDate: null,
+    endDate: null,
+  },
+  onlyShowFirstAvailableSlot: false,
+  offsetStart: 0,
+  maxActiveBookingsPerBooker: 0,
+};
+
+const TestWrapper = ({ 
+  children, 
+  defaultValues = {},
+  eventType = mockEventType,
+}: { 
+  children: React.ReactNode; 
+  defaultValues?: any;
+  eventType?: any;
+}) => {
+  const methods = useForm({
+    defaultValues: {
+      ...mockEventType,
+      ...defaultValues,
+    },
+  });
+
+  return (
+    <FormProvider {...methods}>
+      {children}
+    </FormProvider>
+  );
+};
+
+describe("EventLimitsTab", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("Minimum Cancellation Notice Integration", () => {
+    it("renders the minimum cancellation notice field", () => {
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      const cancellationInput = screen.getByTestId("minimum-cancellation-notice-input");
+      expect(cancellationInput).toBeInTheDocument();
+    });
+
+    it("renders minimum cancellation notice alongside minimum booking notice", () => {
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      // Both fields should be present
+      expect(screen.getByText("minimum_booking_notice")).toBeInTheDocument();
+      const cancellationInput = screen.getByTestId("minimum-cancellation-notice-input");
+      expect(cancellationInput).toBeInTheDocument();
+    });
+
+    it("positions cancellation notice field correctly in the UI", () => {
+      const { container } = render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      // Find the buffer and notice section
+      const bufferSection = container.querySelector(".border-subtle.space-y-6");
+      expect(bufferSection).toBeInTheDocument();
+
+      // Cancellation notice should be within this section
+      const cancellationInput = bufferSection?.querySelector('[data-testid="minimum-cancellation-notice-input"]');
+      expect(cancellationInput).toBeInTheDocument();
+    });
+
+    it("applies custom class names to cancellation notice field", () => {
+      const customClassNames = {
+        bufferAndNoticeSection: {
+          minimumNoticeInput: {
+            container: "custom-container",
+            input: "custom-input",
+            select: "custom-select",
+          },
+        },
+      };
+
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} customClassNames={customClassNames} />
+        </TestWrapper>
+      );
+
+      const cancellationInput = screen.getByTestId("minimum-cancellation-notice-input");
+      expect(cancellationInput).toBeInTheDocument();
+    });
+
+    it("respects locked field settings for cancellation notice", () => {
+      const mockLockedFieldsManager = {
+        shouldLockIndicator: vi.fn((field) => {
+          if (field === "minimumCancellationNotice") return " (Locked)";
+          return null;
+        }),
+        shouldLockDisableProps: vi.fn((field) => {
+          if (field === "minimumCancellationNotice") return { disabled: true };
+          return { disabled: false };
+        }),
+      };
+
+      vi.mocked(vi.importActual("@calcom/features/ee/managed-event-types/hooks/useLockedFieldsManager")).default = () => mockLockedFieldsManager;
+
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      const cancellationInput = within(screen.getByTestId("minimum-cancellation-notice-input")).getByRole("spinbutton");
+      expect(cancellationInput).toHaveAttribute("disabled");
+    });
+
+    it("initializes with correct default values", () => {
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 240 }}>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      const cancellationInput = screen.getByTestId("minimum-cancellation-notice-input");
+      expect(cancellationInput).toBeInTheDocument();
+    });
+  });
+
+  describe("Buffer Times", () => {
+    it("renders before and after buffer time selects", () => {
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      expect(screen.getByText("before_event")).toBeInTheDocument();
+      expect(screen.getByText("after_event")).toBeInTheDocument();
+    });
+
+    it("renders slot interval select", () => {
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      expect(screen.getByText("slot_interval")).toBeInTheDocument();
+    });
+  });
+
+  describe("Booking Limits", () => {
+    it("renders booking frequency limit toggle", () => {
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      expect(screen.getByText("limit_booking_frequency")).toBeInTheDocument();
+      expect(screen.getByText("limit_booking_frequency_description")).toBeInTheDocument();
+    });
+
+    it("shows interval limits when booking limits are enabled", async () => {
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper defaultValues={{ bookingLimits: {} }}>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      const toggle = screen.getByText("limit_booking_frequency").closest("div")?.querySelector("button[role='switch']");
+      if (toggle) {
+        await user.click(toggle);
+      }
+
+      await waitFor(() => {
+        expect(screen.getByText("add_limit")).toBeInTheDocument();
+      });
+    });
+  });
+
+  describe("Duration Limits", () => {
+    it("renders total duration limit toggle", () => {
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      expect(screen.getByText("limit_total_booking_duration")).toBeInTheDocument();
+      expect(screen.getByText("limit_total_booking_duration_description")).toBeInTheDocument();
+    });
+
+    it("shows duration limits when enabled", async () => {
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper defaultValues={{ durationLimits: {} }}>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      const toggle = screen.getByText("limit_total_booking_duration").closest("div")?.querySelector("button[role='switch']");
+      if (toggle) {
+        await user.click(toggle);
+      }
+
+      await waitFor(() => {
+        expect(screen.getByText("add_limit")).toBeInTheDocument();
+      });
+    });
+  });
+
+  describe("Future Booking Limits", () => {
+    it("renders future booking limit toggle", () => {
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      expect(screen.getByText("limit_future_bookings")).toBeInTheDocument();
+      expect(screen.getByText("limit_future_bookings_description")).toBeInTheDocument();
+    });
+
+    it("shows rolling and range options when enabled", async () => {
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper defaultValues={{ periodType: "UNLIMITED" }}>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      const toggle = screen.getByText("limit_future_bookings").closest("div")?.querySelector("button[role='switch']");
+      if (toggle) {
+        await user.click(toggle);
+      }
+
+      await waitFor(() => {
+        expect(screen.getByText("within_date_range")).toBeInTheDocument();
+      });
+    });
+  });
+
+  describe("First Available Slot", () => {
+    it("renders only show first available slot toggle", () => {
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      expect(screen.getByText("only_show_first_available_slot")).toBeInTheDocument();
+      expect(screen.getByText("only_show_first_available_slot_description")).toBeInTheDocument();
+    });
+
+    it("toggles first available slot setting", async () => {
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper defaultValues={{ onlyShowFirstAvailableSlot: false }}>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      const toggle = screen.getByText("only_show_first_available_slot").closest("div")?.querySelector("button[role='switch']");
+      if (toggle) {
+        await user.click(toggle);
+      }
+
+      // Toggle should update the value
+      await waitFor(() => {
+        expect(toggle).toHaveAttribute("data-state", "checked");
+      });
+    });
+  });
+
+  describe("Offset Start Times", () => {
+    it("renders offset toggle when offset value is greater than 0", () => {
+      render(
+        <TestWrapper defaultValues={{ offsetStart: 15 }}>
+          <EventLimitsTab eventType={{ ...mockEventType, offsetStart: 15 }} />
+        </TestWrapper>
+      );
+
+      expect(screen.getByText("offset_toggle")).toBeInTheDocument();
+      expect(screen.getByText("offset_toggle_description")).toBeInTheDocument();
+    });
+
+    it("does not render offset toggle when offset is 0", () => {
+      render(
+        <TestWrapper defaultValues={{ offsetStart: 0 }}>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      expect(screen.queryByText("offset_toggle")).not.toBeInTheDocument();
+    });
+
+    it("shows offset input when toggle is enabled", () => {
+      render(
+        <TestWrapper defaultValues={{ offsetStart: 15 }}>
+          <EventLimitsTab eventType={{ ...mockEventType, offsetStart: 15 }} />
+        </TestWrapper>
+      );
+
+      expect(screen.getByText("offset_start")).toBeInTheDocument();
+    });
+  });
+
+  describe("Form Value Updates", () => {
+    it("updates form values when minimum cancellation notice changes", async () => {
+      const user = userEvent.setup();
+      const onSubmit = vi.fn();
+      
+      const FormWrapper = ({ children }: { children: React.ReactNode }) => {
+        const methods = useForm({
+          defaultValues: {
+            ...mockEventType,
+            minimumCancellationNotice: 60,
+          },
+        });
+
+        return (
+          <FormProvider {...methods}>
+            <form onSubmit={methods.handleSubmit(onSubmit)}>
+              {children}
+              <button type="submit">Submit</button>
+            </form>
+          </FormProvider>
+        );
+      };
+
+      render(
+        <FormWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </FormWrapper>
+      );
+
+      const submitButton = screen.getByText("Submit");
+      await user.click(submitButton);
+
+      await waitFor(() => {
+        expect(onSubmit).toHaveBeenCalledWith(
+          expect.objectContaining({
+            minimumCancellationNotice: 60,
+          })
+        );
+      });
+    });
+  });
+
+  describe("Accessibility", () => {
+    it("has proper labels for all form fields", () => {
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      // Check for important labels
+      expect(screen.getByText("before_event")).toBeInTheDocument();
+      expect(screen.getByText("after_event")).toBeInTheDocument();
+      expect(screen.getByText("minimum_booking_notice")).toBeInTheDocument();
+      expect(screen.getByText("slot_interval")).toBeInTheDocument();
+    });
+
+    it("maintains focus management when toggling settings", async () => {
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      const toggle = screen.getByText("limit_booking_frequency").closest("div")?.querySelector("button[role='switch']");
+      if (toggle) {
+        await user.click(toggle);
+        // Focus should remain accessible
+        expect(toggle).toBeInTheDocument();
+      }
+    });
+  });
+
+  describe("Performance and Edge Cases", () => {
+    it("handles undefined event type gracefully", () => {
+      render(
+        <TestWrapper eventType={undefined}>
+          <EventLimitsTab eventType={undefined as any} />
+        </TestWrapper>
+      );
+
+      // Should render without crashing
+      expect(screen.getByText("minimum_booking_notice")).toBeInTheDocument();
+    });
+
+    it("handles missing form values gracefully", () => {
+      const incompleteEventType = {
+        id: 1,
+        title: "Test",
+      };
+
+      render(
+        <TestWrapper eventType={incompleteEventType}>
+          <EventLimitsTab eventType={incompleteEventType as any} />
+        </TestWrapper>
+      );
+
+      // Should render with defaults
+      expect(screen.getByText("minimum_booking_notice")).toBeInTheDocument();
+    });
+
+    it("handles recurring event type correctly", () => {
+      render(
+        <TestWrapper defaultValues={{ recurringEvent: { interval: 1, count: 5, freq: 2 } }}>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      // Should still render all fields
+      expect(screen.getByText("minimum_booking_notice")).toBeInTheDocument();
+      expect(screen.getByTestId("minimum-cancellation-notice-input")).toBeInTheDocument();
+    });
+  });
+
+  describe("Integration with Locked Fields", () => {
+    it("disables fields when locked by managed event types", () => {
+      const mockLockedFieldsManager = {
+        shouldLockIndicator: vi.fn(() => " 🔒"),
+        shouldLockDisableProps: vi.fn(() => ({ disabled: true })),
+      };
+
+      vi.mocked(vi.importActual("@calcom/features/ee/managed-event-types/hooks/useLockedFieldsManager")).default = () => mockLockedFieldsManager;
+
+      render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      // All toggles should be disabled
+      const switches = screen.getAllByRole("switch");
+      switches.forEach(switchElement => {
+        expect(switchElement).toHaveAttribute("disabled");
+      });
+    });
+
+    it("shows lock indicators for locked fields", () => {
+      const mockLockedFieldsManager = {
+        shouldLockIndicator: vi.fn((field) => {
+          const lockedFields = ["minimumBookingNotice", "minimumCancellationNotice", "beforeBufferTime"];
+          return lockedFields.includes(field) ? " 🔒" : null;
+        }),
+        shouldLockDisableProps: vi.fn(() => ({ disabled: false })),
+      };
+
+      vi.mocked(vi.importActual("@calcom/features/ee/managed-event-types/hooks/useLockedFieldsManager")).default = () => mockLockedFieldsManager;
+
+      const { container } = render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} />
+        </TestWrapper>
+      );
+
+      // Should have called shouldLockIndicator for fields
+      expect(mockLockedFieldsManager.shouldLockIndicator).toHaveBeenCalledWith("minimumBookingNotice");
+      expect(mockLockedFieldsManager.shouldLockIndicator).toHaveBeenCalledWith("minimumCancellationNotice");
+    });
+  });
+
+  describe("Custom Class Names", () => {
+    it("applies all custom class names correctly", () => {
+      const customClassNames = {
+        bufferAndNoticeSection: {
+          container: "custom-buffer-container",
+          beforeBufferSelect: {
+            container: "custom-before-buffer",
+            select: "custom-before-select",
+          },
+          afterBufferSelect: {
+            container: "custom-after-buffer",
+            select: "custom-after-select",
+          },
+          minimumNoticeInput: {
+            container: "custom-notice-container",
+            input: "custom-notice-input",
+            select: "custom-notice-select",
+          },
+          timeSlotIntervalSelect: {
+            container: "custom-slot-container",
+            select: "custom-slot-select",
+          },
+        },
+        bookingFrequencyLimit: {
+          container: "custom-booking-limit",
+          label: "custom-booking-label",
+        },
+        firstAvailableSlotOnly: {
+          container: "custom-first-slot",
+          label: "custom-first-label",
+        },
+        totalDurationLimit: {
+          container: "custom-duration-limit",
+          label: "custom-duration-label",
+        },
+        futureBookingLimit: {
+          container: "custom-future-limit",
+          label: "custom-future-label",
+        },
+        offsetStartTimes: {
+          container: "custom-offset",
+          label: "custom-offset-label",
+        },
+      };
+
+      const { container } = render(
+        <TestWrapper>
+          <EventLimitsTab eventType={mockEventType} customClassNames={customClassNames} />
+        </TestWrapper>
+      );
+
+      // Check for custom classes
+      expect(container.querySelector(".custom-buffer-container")).toBeInTheDocument();
+      expect(container.querySelector(".custom-booking-limit")).toBeInTheDocument();
+      expect(container.querySelector(".custom-first-slot")).toBeInTheDocument();
+      expect(container.querySelector(".custom-duration-limit")).toBeInTheDocument();
+      expect(container.querySelector(".custom-future-limit")).toBeInTheDocument();
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/features/eventtypes/components/tabs/limits/EventLimitsTab.tsx b/packages/features/eventtypes/components/tabs/limits/EventLimitsTab.tsx
index 4145e046e6c0b7..48849467513dd0 100644
--- a/packages/features/eventtypes/components/tabs/limits/EventLimitsTab.tsx
+++ b/packages/features/eventtypes/components/tabs/limits/EventLimitsTab.tsx
@@ -31,6 +31,7 @@ import {
 } from "@calcom/ui/components/form";
 
 import MaxActiveBookingsPerBookerController from "./MaxActiveBookingsPerBookerController";
+import MinimumCancellationNoticeInput from "./MinimumCancellationNoticeInput";
 
 type IPeriodType = (typeof PeriodType)[keyof typeof PeriodType];
 
@@ -521,6 +522,25 @@ export const EventLimitsTab = ({ eventType, customClassNames }: EventLimitsTabPr
               {...formMethods.register("minimumBookingNotice")}
             />
           </div>
+          <div
+            className={classNames(
+              "w-full",
+              customClassNames?.bufferAndNoticeSection?.minimumNoticeInput?.container
+            )}>
+            <Label
+              htmlFor="minimumCancellationNotice"
+              className={customClassNames?.bufferAndNoticeSection?.minimumNoticeInput?.label}>
+              {t("minimum_cancellation_notice")}
+              {shouldLockIndicator("minimumCancellationNotice")}
+            </Label>
+            <MinimumCancellationNoticeInput
+              customClassNames={customClassNames?.bufferAndNoticeSection?.minimumNoticeInput}
+              disabled={shouldLockDisableProps("minimumCancellationNotice").disabled}
+              {...formMethods.register("minimumCancellationNotice")}
+            />
+          </div>
+        </div>
+        <div className="flex flex-col space-y-4 lg:flex-row lg:space-x-4 lg:space-y-0">
           <div
             className={classNames(
               "w-full",
diff --git a/packages/features/eventtypes/components/tabs/limits/MinimumCancellationNoticeInput.test.tsx b/packages/features/eventtypes/components/tabs/limits/MinimumCancellationNoticeInput.test.tsx
new file mode 100644
index 00000000000000..1f4bf96aa36638
--- /dev/null
+++ b/packages/features/eventtypes/components/tabs/limits/MinimumCancellationNoticeInput.test.tsx
@@ -0,0 +1,690 @@
+import { render, screen, fireEvent, waitFor, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { FormProvider, useForm } from "react-hook-form";
+import { vi, describe, it, expect, beforeEach, afterEach } from "vitest";
+
+import MinimumCancellationNoticeInput from "./MinimumCancellationNoticeInput";
+
+// Mock the localization hook
+vi.mock("@calcom/lib/hooks/useLocale", () => ({
+  useLocale: () => ({
+    t: (key: string) => key,
+  }),
+}));
+
+// Mock the utility functions
+const mockConvertToNewDurationType = vi.fn((from: string, to: string, value: number) => {
+  if (from === "minutes" && to === "minutes") return value;
+  if (from === "minutes" && to === "hours") return value / 60;
+  if (from === "minutes" && to === "days") return value / (60 * 24);
+  if (from === "hours" && to === "minutes") return value * 60;
+  if (from === "days" && to === "minutes") return value * 60 * 24;
+  if (from === "hours" && to === "hours") return value;
+  if (from === "days" && to === "days") return value;
+  if (from === "hours" && to === "days") return value / 24;
+  if (from === "days" && to === "hours") return value * 24;
+  return value;
+});
+
+vi.mock("@calcom/lib/convertToNewDurationType", () => ({
+  default: mockConvertToNewDurationType,
+}));
+
+const mockFindDurationType = vi.fn((value: number) => {
+  if (value >= 1440) return "days";
+  if (value >= 60) return "hours";
+  return "minutes";
+});
+
+vi.mock("@calcom/lib/findDurationType", () => ({
+  default: mockFindDurationType,
+}));
+
+const TestWrapper = ({ 
+  children, 
+  defaultValues = {},
+  onSubmit = vi.fn()
+}: { 
+  children: React.ReactNode; 
+  defaultValues?: any;
+  onSubmit?: (data: any) => void;
+}) => {
+  const methods = useForm({
+    defaultValues: {
+      minimumCancellationNotice: 120,
+      ...defaultValues,
+    },
+  });
+
+  return (
+    <FormProvider {...methods}>
+      <form onSubmit={methods.handleSubmit(onSubmit)}>
+        {children}
+        <button type="submit">Submit</button>
+      </form>
+    </FormProvider>
+  );
+};
+
+describe("MinimumCancellationNoticeInput", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("Rendering", () => {
+    it("renders the minimum cancellation notice input field with label", () => {
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      expect(screen.getByLabelText("minimum_cancellation_notice")).toBeInTheDocument();
+      expect(screen.getByRole("spinbutton")).toBeInTheDocument();
+      expect(screen.getByRole("combobox")).toBeInTheDocument();
+    });
+
+    it("renders with required attribute on the input field", () => {
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveAttribute("required");
+    });
+
+    it("renders with placeholder text", () => {
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveAttribute("placeholder", "0");
+    });
+
+    it("renders hidden input field for form integration", () => {
+      const { container } = render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const hiddenInput = container.querySelector('input[type="hidden"]');
+      expect(hiddenInput).toBeInTheDocument();
+    });
+  });
+
+  describe("Initial Value Display", () => {
+    it("displays the correct initial value in hours when value is 120 minutes", () => {
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 120 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveValue(2); // 120 minutes = 2 hours
+    });
+
+    it("displays the correct initial value in days when value is 1440 minutes", () => {
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 1440 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveValue(1); // 1440 minutes = 1 day
+    });
+
+    it("displays the correct initial value in minutes when value is 30 minutes", () => {
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 30 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveValue(30); // 30 minutes stays as minutes
+    });
+
+    it("handles zero value correctly", () => {
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 0 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveValue(0);
+    });
+
+    it("handles undefined value correctly", () => {
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: undefined }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveValue(0);
+    });
+  });
+
+  describe("User Interactions", () => {
+    it("updates the value when user types a new number", async () => {
+      const user = userEvent.setup();
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      await user.clear(input);
+      await user.type(input, "5");
+      expect(input).toHaveValue(5);
+    });
+
+    it("handles negative values by enforcing minimum of 0", () => {
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      fireEvent.change(input, { target: { value: "-5" } });
+      expect(input).toHaveAttribute("min", "0");
+    });
+
+    it("handles decimal values correctly", async () => {
+      const user = userEvent.setup();
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      await user.clear(input);
+      await user.type(input, "3.5");
+      expect(input).toHaveValue(3.5);
+    });
+
+    it("handles empty value as 0", async () => {
+      const user = userEvent.setup();
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      await user.clear(input);
+      
+      // The component should treat empty as 0
+      await waitFor(() => {
+        expect(mockConvertToNewDurationType).toHaveBeenCalledWith(
+          expect.any(String),
+          "minutes",
+          0
+        );
+      });
+    });
+
+    it("handles very large values correctly", async () => {
+      const user = userEvent.setup();
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      await user.clear(input);
+      await user.type(input, "999999");
+      expect(input).toHaveValue(999999);
+    });
+  });
+
+  describe("Duration Type Selection", () => {
+    it("allows changing from minutes to hours", async () => {
+      const user = userEvent.setup();
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 30 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const select = screen.getByRole("combobox");
+      
+      // Simulate selecting hours option
+      await user.click(select);
+      
+      // The conversion should happen
+      await waitFor(() => {
+        expect(mockConvertToNewDurationType).toHaveBeenCalledWith(
+          "hours",
+          "minutes",
+          expect.any(Number)
+        );
+      });
+    });
+
+    it("allows changing from hours to days", async () => {
+      const user = userEvent.setup();
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 120 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const select = screen.getByRole("combobox");
+      
+      // Simulate selecting days option
+      await user.click(select);
+      
+      await waitFor(() => {
+        expect(mockConvertToNewDurationType).toHaveBeenCalled();
+      });
+    });
+
+    it("maintains value when switching between duration types", async () => {
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 60 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      
+      // Initially shows 1 hour
+      expect(input).toHaveValue(1);
+      
+      // Value in minutes should remain 60
+      expect(mockConvertToNewDurationType).toHaveBeenCalledWith(
+        expect.any(String),
+        "minutes",
+        expect.any(Number)
+      );
+    });
+
+    it("correctly identifies duration type for edge cases", () => {
+      // Test exactly 60 minutes (should be hours)
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 60 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+      
+      expect(mockFindDurationType).toHaveBeenCalledWith(60);
+      expect(mockFindDurationType).toHaveReturnedWith("hours");
+    });
+  });
+
+  describe("Disabled State", () => {
+    it("disables the input field when disabled prop is true", () => {
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" disabled />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      const select = screen.getByRole("combobox");
+      
+      expect(input).toBeDisabled();
+      expect(select).toHaveAttribute("aria-disabled", "true");
+    });
+
+    it("enables the input field when disabled prop is false", () => {
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" disabled={false} />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      const select = screen.getByRole("combobox");
+      
+      expect(input).not.toBeDisabled();
+      expect(select).not.toHaveAttribute("aria-disabled", "true");
+    });
+
+    it("prevents value changes when disabled", async () => {
+      const user = userEvent.setup();
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 60 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" disabled />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      const initialValue = input.getAttribute("value");
+      
+      await user.type(input, "999");
+      
+      expect(input.getAttribute("value")).toBe(initialValue);
+    });
+  });
+
+  describe("Custom Class Names", () => {
+    it("applies custom input class names", () => {
+      const customClassNames = {
+        input: "custom-input-class",
+      };
+
+      const { container } = render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput
+            name="minimumCancellationNotice"
+            customClassNames={customClassNames}
+          />
+        </TestWrapper>
+      );
+
+      const input = container.querySelector(".custom-input-class");
+      expect(input).toBeInTheDocument();
+    });
+
+    it("applies custom select class names", () => {
+      const customClassNames = {
+        select: "custom-select-class",
+      };
+
+      const { container } = render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput
+            name="minimumCancellationNotice"
+            customClassNames={customClassNames}
+          />
+        </TestWrapper>
+      );
+
+      const select = container.querySelector(".custom-select-class");
+      expect(select).toBeInTheDocument();
+    });
+
+    it("applies custom inner class names for select", () => {
+      const customClassNames = {
+        innerClassNames: {
+          control: "custom-control-class",
+        },
+      };
+
+      const { container } = render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput
+            name="minimumCancellationNotice"
+            customClassNames={customClassNames}
+          />
+        </TestWrapper>
+      );
+
+      // The Select component should receive these inner class names
+      expect(container.querySelector('[class*="w-full"]')).toBeInTheDocument();
+    });
+
+    it("applies default classes when no custom classes provided", () => {
+      const { container } = render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      expect(container.querySelector('[class*="mb-0"]')).toBeInTheDocument();
+      expect(container.querySelector('[class*="h-9"]')).toBeInTheDocument();
+    });
+  });
+
+  describe("Form Integration", () => {
+    it("updates form values when input changes", async () => {
+      const onSubmit = vi.fn();
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper onSubmit={onSubmit}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      await user.clear(input);
+      await user.type(input, "10");
+
+      const submitButton = screen.getByText("Submit");
+      await user.click(submitButton);
+
+      await waitFor(() => {
+        expect(onSubmit).toHaveBeenCalledWith(
+          expect.objectContaining({
+            minimumCancellationNotice: expect.any(Number)
+          })
+        );
+      });
+    });
+
+    it("marks form as dirty when value changes", async () => {
+      const user = userEvent.setup();
+      
+      const { container } = render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      await user.clear(input);
+      await user.type(input, "15");
+
+      // The setValue call should include shouldDirty: true
+      await waitFor(() => {
+        expect(mockConvertToNewDurationType).toHaveBeenCalled();
+      });
+    });
+
+    it("synchronizes hidden field with display values", async () => {
+      const user = userEvent.setup();
+      
+      const { container } = render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 60 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      const hiddenInput = container.querySelector('input[type="hidden"]');
+
+      await user.clear(input);
+      await user.type(input, "5");
+
+      // Hidden field should be updated via useEffect
+      await waitFor(() => {
+        expect(mockConvertToNewDurationType).toHaveBeenCalledWith(
+          expect.any(String),
+          "minutes",
+          5
+        );
+      });
+    });
+  });
+
+  describe("Edge Cases and Error Handling", () => {
+    it("handles NaN values gracefully", async () => {
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      await user.clear(input);
+      await user.type(input, "abc");
+
+      // HTML number input won't accept non-numeric values
+      expect(input).toHaveValue(null);
+    });
+
+    it("handles switching between all duration types correctly", async () => {
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 2880 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      // 2880 minutes = 2 days
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveValue(2);
+      expect(mockFindDurationType).toHaveBeenCalledWith(2880);
+      expect(mockFindDurationType).toHaveReturnedWith("days");
+    });
+
+    it("handles rapid value changes", async () => {
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      
+      // Rapidly change values
+      await user.clear(input);
+      await user.type(input, "1");
+      await user.type(input, "2");
+      await user.type(input, "3");
+
+      expect(input).toHaveValue(123);
+    });
+
+    it("maintains consistency between display and stored values", async () => {
+      const onSubmit = vi.fn();
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 90 }} onSubmit={onSubmit}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      // 90 minutes should display as 1.5 hours
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveValue(1.5);
+
+      const submitButton = screen.getByText("Submit");
+      await user.click(submitButton);
+
+      await waitFor(() => {
+        expect(onSubmit).toHaveBeenCalledWith(
+          expect.objectContaining({
+            minimumCancellationNotice: 90 // Should still store as minutes
+          })
+        );
+      });
+    });
+  });
+
+  describe("Accessibility", () => {
+    it("has proper ARIA attributes", () => {
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      expect(input).toHaveAttribute("type", "number");
+      expect(input).toHaveAttribute("min", "0");
+    });
+
+    it("associates label with input correctly", () => {
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const label = screen.getByText("minimum_cancellation_notice");
+      const input = screen.getByRole("spinbutton");
+      
+      // Check that label is properly associated
+      expect(label).toBeInTheDocument();
+      expect(input).toHaveAttribute("required");
+    });
+
+    it("provides keyboard navigation support", async () => {
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      
+      // Tab to input
+      await user.tab();
+      
+      // Use arrow keys to change value
+      await user.keyboard("{ArrowUp}");
+      
+      // Number inputs respond to arrow keys
+      expect(input).toBeInTheDocument();
+    });
+  });
+
+  describe("Performance", () => {
+    it("memoizes conversion calculations correctly", async () => {
+      const { rerender } = render(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 120 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const initialCallCount = mockConvertToNewDurationType.mock.calls.length;
+
+      // Re-render with same props
+      rerender(
+        <TestWrapper defaultValues={{ minimumCancellationNotice: 120 }}>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      // Should not trigger unnecessary conversions
+      expect(mockConvertToNewDurationType.mock.calls.length).toBeGreaterThanOrEqual(initialCallCount);
+    });
+
+    it("debounces rapid input changes effectively", async () => {
+      const user = userEvent.setup();
+      
+      render(
+        <TestWrapper>
+          <MinimumCancellationNoticeInput name="minimumCancellationNotice" />
+        </TestWrapper>
+      );
+
+      const input = screen.getByRole("spinbutton");
+      
+      // Type rapidly
+      await user.clear(input);
+      await user.type(input, "12345", { delay: 1 });
+
+      // Should handle all changes smoothly
+      expect(input).toHaveValue(12345);
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/features/eventtypes/components/tabs/limits/MinimumCancellationNoticeInput.tsx b/packages/features/eventtypes/components/tabs/limits/MinimumCancellationNoticeInput.tsx
new file mode 100644
index 00000000000000..186bfb25719ea2
--- /dev/null
+++ b/packages/features/eventtypes/components/tabs/limits/MinimumCancellationNoticeInput.tsx
@@ -0,0 +1,111 @@
+import React, { useEffect, useState } from "react";
+import type { UseFormRegisterReturn } from "react-hook-form";
+import { useFormContext } from "react-hook-form";
+
+import type { DurationType } from "@calcom/lib/convertToNewDurationType";
+import convertToNewDurationType from "@calcom/lib/convertToNewDurationType";
+import findDurationType from "@calcom/lib/findDurationType";
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import classNames from "@calcom/ui/classNames";
+import { InputField, Select } from "@calcom/ui/components/form";
+
+import type { FormValues, SelectClassNames } from "../../../lib/types";
+
+const MinimumCancellationNoticeInput = React.forwardRef<
+  HTMLInputElement,
+  Omit<UseFormRegisterReturn<"minimumCancellationNotice">, "ref"> & {
+    customClassNames?: SelectClassNames & { input?: string };
+  }
+>(function MinimumCancellationNoticeInput({ customClassNames, ...passThroughProps }, ref) {
+  const { t } = useLocale();
+  const { setValue, getValues } = useFormContext<FormValues & { minimumCancellationNotice: number }>();
+  const durationTypeOptions: {
+    value: DurationType;
+    label: string;
+  }[] = [
+    {
+      label: t("minutes"),
+      value: "minutes",
+    },
+    {
+      label: t("hours"),
+      value: "hours",
+    },
+    {
+      label: t("days"),
+      value: "days",
+    },
+  ];
+
+  const [minimumCancellationNoticeDisplayValues, setMinimumCancellationNoticeDisplayValues] = useState<{
+    type: DurationType;
+    value: number;
+  }>({
+    type: findDurationType(getValues("minimumCancellationNotice" as any) || 0),
+    value: convertToNewDurationType(
+      "minutes",
+      findDurationType(getValues("minimumCancellationNotice" as any) || 0),
+      getValues("minimumCancellationNotice" as any) || 0
+    ),
+  });
+
+  // keep hidden field in sync with minimumCancellationNoticeDisplayValues
+  useEffect(() => {
+    setValue(
+      "minimumCancellationNotice" as any,
+      convertToNewDurationType(
+        minimumCancellationNoticeDisplayValues.type,
+        "minutes",
+        minimumCancellationNoticeDisplayValues.value
+      ),
+      { shouldDirty: true }
+    );
+  }, [minimumCancellationNoticeDisplayValues, setValue]);
+
+  return (
+    <div className="flex items-end justify-end">
+      <div className="w-1/2 md:w-full">
+        <InputField
+          required
+          disabled={passThroughProps.disabled}
+          defaultValue={minimumCancellationNoticeDisplayValues.value}
+          onChange={(e) =>
+            setMinimumCancellationNoticeDisplayValues({
+              ...minimumCancellationNoticeDisplayValues,
+              value: parseInt(e.target.value || "0", 10),
+            })
+          }
+          label={t("minimum_cancellation_notice")}
+          type="number"
+          placeholder="0"
+          className={classNames("mb-0 h-9 ltr:mr-2 rtl:ml-2", customClassNames?.input)}
+          min={0}
+        />
+        <input type="hidden" ref={ref} {...passThroughProps} />
+      </div>
+      <Select
+        isSearchable={false}
+        isDisabled={passThroughProps.disabled}
+        className={classNames(
+          "mb-0 ml-2 h-9 w-full capitalize md:min-w-[150px] md:max-w-[200px]",
+          customClassNames?.select
+        )}
+        innerClassNames={customClassNames?.innerClassNames}
+        defaultValue={durationTypeOptions.find(
+          (option) => option.value === minimumCancellationNoticeDisplayValues.type
+        )}
+        onChange={(input) => {
+          if (input) {
+            setMinimumCancellationNoticeDisplayValues({
+              ...minimumCancellationNoticeDisplayValues,
+              type: input.value,
+            });
+          }
+        }}
+        options={durationTypeOptions}
+      />
+    </div>
+  );
+});
+
+export default MinimumCancellationNoticeInput;
\ No newline at end of file
diff --git a/packages/features/eventtypes/lib/types-minimumCancellationNotice.ts b/packages/features/eventtypes/lib/types-minimumCancellationNotice.ts
new file mode 100644
index 00000000000000..3c708662116231
--- /dev/null
+++ b/packages/features/eventtypes/lib/types-minimumCancellationNotice.ts
@@ -0,0 +1,5 @@
+// Extension to FormValues type for minimumCancellationNotice
+export interface FormValuesExtension {
+  minimumCancellationNotice: number;
+  minimumCancellationNoticeInDurationType: number;
+}
\ No newline at end of file
diff --git a/packages/lib/__tests__/convertToNewDurationType.test.ts b/packages/lib/__tests__/convertToNewDurationType.test.ts
new file mode 100644
index 00000000000000..50e900cbd53dfb
--- /dev/null
+++ b/packages/lib/__tests__/convertToNewDurationType.test.ts
@@ -0,0 +1,234 @@
+import { describe, it, expect } from "vitest";
+import convertToNewDurationType from "../convertToNewDurationType";
+
+describe("convertToNewDurationType", () => {
+  describe("Minutes conversions", () => {
+    it("converts minutes to minutes", () => {
+      expect(convertToNewDurationType("minutes", "minutes", 30)).toBe(30);
+      expect(convertToNewDurationType("minutes", "minutes", 0)).toBe(0);
+      expect(convertToNewDurationType("minutes", "minutes", 1440)).toBe(1440);
+    });
+
+    it("converts minutes to hours", () => {
+      expect(convertToNewDurationType("minutes", "hours", 60)).toBe(1);
+      expect(convertToNewDurationType("minutes", "hours", 120)).toBe(2);
+      expect(convertToNewDurationType("minutes", "hours", 90)).toBe(1.5);
+      expect(convertToNewDurationType("minutes", "hours", 30)).toBe(0.5);
+      expect(convertToNewDurationType("minutes", "hours", 0)).toBe(0);
+    });
+
+    it("converts minutes to days", () => {
+      expect(convertToNewDurationType("minutes", "days", 1440)).toBe(1);
+      expect(convertToNewDurationType("minutes", "days", 2880)).toBe(2);
+      expect(convertToNewDurationType("minutes", "days", 720)).toBe(0.5);
+      expect(convertToNewDurationType("minutes", "days", 0)).toBe(0);
+    });
+  });
+
+  describe("Hours conversions", () => {
+    it("converts hours to minutes", () => {
+      expect(convertToNewDurationType("hours", "minutes", 1)).toBe(60);
+      expect(convertToNewDurationType("hours", "minutes", 2)).toBe(120);
+      expect(convertToNewDurationType("hours", "minutes", 0.5)).toBe(30);
+      expect(convertToNewDurationType("hours", "minutes", 1.5)).toBe(90);
+      expect(convertToNewDurationType("hours", "minutes", 0)).toBe(0);
+    });
+
+    it("converts hours to hours", () => {
+      expect(convertToNewDurationType("hours", "hours", 1)).toBe(1);
+      expect(convertToNewDurationType("hours", "hours", 24)).toBe(24);
+      expect(convertToNewDurationType("hours", "hours", 0.5)).toBe(0.5);
+      expect(convertToNewDurationType("hours", "hours", 0)).toBe(0);
+    });
+
+    it("converts hours to days", () => {
+      expect(convertToNewDurationType("hours", "days", 24)).toBe(1);
+      expect(convertToNewDurationType("hours", "days", 48)).toBe(2);
+      expect(convertToNewDurationType("hours", "days", 12)).toBe(0.5);
+      expect(convertToNewDurationType("hours", "days", 36)).toBe(1.5);
+      expect(convertToNewDurationType("hours", "days", 0)).toBe(0);
+    });
+  });
+
+  describe("Days conversions", () => {
+    it("converts days to minutes", () => {
+      expect(convertToNewDurationType("days", "minutes", 1)).toBe(1440);
+      expect(convertToNewDurationType("days", "minutes", 2)).toBe(2880);
+      expect(convertToNewDurationType("days", "minutes", 0.5)).toBe(720);
+      expect(convertToNewDurationType("days", "minutes", 0)).toBe(0);
+    });
+
+    it("converts days to hours", () => {
+      expect(convertToNewDurationType("days", "hours", 1)).toBe(24);
+      expect(convertToNewDurationType("days", "hours", 2)).toBe(48);
+      expect(convertToNewDurationType("days", "hours", 0.5)).toBe(12);
+      expect(convertToNewDurationType("days", "hours", 1.5)).toBe(36);
+      expect(convertToNewDurationType("days", "hours", 0)).toBe(0);
+    });
+
+    it("converts days to days", () => {
+      expect(convertToNewDurationType("days", "days", 1)).toBe(1);
+      expect(convertToNewDurationType("days", "days", 7)).toBe(7);
+      expect(convertToNewDurationType("days", "days", 0.5)).toBe(0.5);
+      expect(convertToNewDurationType("days", "days", 0)).toBe(0);
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("handles very large values", () => {
+      expect(convertToNewDurationType("minutes", "days", 144000)).toBe(100);
+      expect(convertToNewDurationType("hours", "days", 2400)).toBe(100);
+      expect(convertToNewDurationType("days", "minutes", 100)).toBe(144000);
+    });
+
+    it("handles fractional values correctly", () => {
+      expect(convertToNewDurationType("minutes", "hours", 45)).toBe(0.75);
+      expect(convertToNewDurationType("hours", "days", 18)).toBe(0.75);
+      expect(convertToNewDurationType("minutes", "days", 1080)).toBe(0.75);
+    });
+
+    it("handles negative values", () => {
+      expect(convertToNewDurationType("minutes", "hours", -60)).toBe(-1);
+      expect(convertToNewDurationType("hours", "minutes", -2)).toBe(-120);
+      expect(convertToNewDurationType("days", "hours", -1)).toBe(-24);
+    });
+
+    it("maintains precision for decimal inputs", () => {
+      expect(convertToNewDurationType("hours", "minutes", 1.25)).toBe(75);
+      expect(convertToNewDurationType("hours", "minutes", 2.75)).toBe(165);
+      expect(convertToNewDurationType("days", "hours", 1.25)).toBe(30);
+    });
+
+    it("rounds appropriately for display purposes", () => {
+      // When converting to smaller units, should maintain precision
+      expect(convertToNewDurationType("hours", "minutes", 1.1)).toBeCloseTo(66, 0);
+      expect(convertToNewDurationType("days", "minutes", 0.1)).toBeCloseTo(144, 0);
+      
+      // When converting to larger units, should maintain decimal precision
+      expect(convertToNewDurationType("minutes", "hours", 66)).toBeCloseTo(1.1, 1);
+      expect(convertToNewDurationType("minutes", "days", 144)).toBeCloseTo(0.1, 1);
+    });
+  });
+
+  describe("Invalid inputs", () => {
+    it("handles invalid duration types gracefully", () => {
+      // @ts-expect-error Testing invalid input
+      expect(convertToNewDurationType("invalid", "minutes", 1)).toBe(1);
+      // @ts-expect-error Testing invalid input
+      expect(convertToNewDurationType("minutes", "invalid", 60)).toBe(60);
+      // @ts-expect-error Testing invalid input
+      expect(convertToNewDurationType("invalid", "invalid", 100)).toBe(100);
+    });
+
+    it("handles null and undefined values", () => {
+      // @ts-expect-error Testing invalid input
+      expect(convertToNewDurationType("minutes", "hours", null)).toBe(0);
+      // @ts-expect-error Testing invalid input
+      expect(convertToNewDurationType("minutes", "hours", undefined)).toBe(0);
+    });
+
+    it("handles NaN values", () => {
+      expect(convertToNewDurationType("minutes", "hours", NaN)).toBe(0);
+      // @ts-expect-error Testing invalid input
+      expect(convertToNewDurationType("minutes", "hours", "not a number")).toBe(0);
+    });
+
+    it("handles Infinity values", () => {
+      expect(convertToNewDurationType("minutes", "hours", Infinity)).toBe(Infinity);
+      expect(convertToNewDurationType("minutes", "hours", -Infinity)).toBe(-Infinity);
+    });
+  });
+
+  describe("Bidirectional conversions", () => {
+    it("maintains value integrity when converting back and forth", () => {
+      const originalMinutes = 90;
+      
+      // Minutes -> Hours -> Minutes
+      const toHours = convertToNewDurationType("minutes", "hours", originalMinutes);
+      const backToMinutes = convertToNewDurationType("hours", "minutes", toHours);
+      expect(backToMinutes).toBe(originalMinutes);
+
+      // Minutes -> Days -> Minutes
+      const toDays = convertToNewDurationType("minutes", "days", 2880);
+      const backToMinutes2 = convertToNewDurationType("days", "minutes", toDays);
+      expect(backToMinutes2).toBe(2880);
+
+      // Hours -> Days -> Hours
+      const originalHours = 36;
+      const toDays2 = convertToNewDurationType("hours", "days", originalHours);
+      const backToHours = convertToNewDurationType("days", "hours", toDays2);
+      expect(backToHours).toBe(originalHours);
+    });
+  });
+
+  describe("Common use cases", () => {
+    it("converts typical booking notice values", () => {
+      // 15 minutes notice
+      expect(convertToNewDurationType("minutes", "minutes", 15)).toBe(15);
+      
+      // 2 hours notice
+      expect(convertToNewDurationType("hours", "minutes", 2)).toBe(120);
+      
+      // 1 day notice
+      expect(convertToNewDurationType("days", "minutes", 1)).toBe(1440);
+      
+      // 3 days notice
+      expect(convertToNewDurationType("days", "minutes", 3)).toBe(4320);
+    });
+
+    it("converts typical cancellation notice values", () => {
+      // 30 minutes cancellation notice
+      expect(convertToNewDurationType("minutes", "minutes", 30)).toBe(30);
+      
+      // 4 hours cancellation notice
+      expect(convertToNewDurationType("hours", "minutes", 4)).toBe(240);
+      
+      // 2 days cancellation notice
+      expect(convertToNewDurationType("days", "minutes", 2)).toBe(2880);
+      
+      // 1 week cancellation notice
+      expect(convertToNewDurationType("days", "minutes", 7)).toBe(10080);
+    });
+
+    it("converts buffer time values", () => {
+      // 5 minute buffer
+      expect(convertToNewDurationType("minutes", "minutes", 5)).toBe(5);
+      
+      // 15 minute buffer
+      expect(convertToNewDurationType("minutes", "minutes", 15)).toBe(15);
+      
+      // 30 minute buffer
+      expect(convertToNewDurationType("minutes", "minutes", 30)).toBe(30);
+      
+      // 1 hour buffer
+      expect(convertToNewDurationType("hours", "minutes", 1)).toBe(60);
+    });
+  });
+
+  describe("Type safety and bounds", () => {
+    it("handles maximum safe integer values", () => {
+      const maxSafeMinutes = Number.MAX_SAFE_INTEGER;
+      const result = convertToNewDurationType("minutes", "days", maxSafeMinutes);
+      expect(result).toBeGreaterThan(0);
+      expect(Number.isFinite(result)).toBe(true);
+    });
+
+    it("handles minimum safe integer values", () => {
+      const minSafeMinutes = Number.MIN_SAFE_INTEGER;
+      const result = convertToNewDurationType("minutes", "days", minSafeMinutes);
+      expect(result).toBeLessThan(0);
+      expect(Number.isFinite(result)).toBe(true);
+    });
+
+    it("maintains type consistency", () => {
+      const result1 = convertToNewDurationType("minutes", "hours", 60);
+      expect(typeof result1).toBe("number");
+      
+      const result2 = convertToNewDurationType("hours", "days", 24);
+      expect(typeof result2).toBe("number");
+      
+      const result3 = convertToNewDurationType("days", "minutes", 1);
+      expect(typeof result3).toBe("number");
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/lib/__tests__/findDurationType.test.ts b/packages/lib/__tests__/findDurationType.test.ts
new file mode 100644
index 00000000000000..662d65b4b647bb
--- /dev/null
+++ b/packages/lib/__tests__/findDurationType.test.ts
@@ -0,0 +1,251 @@
+import { describe, it, expect } from "vitest";
+import findDurationType from "../findDurationType";
+
+describe("findDurationType", () => {
+  describe("Minutes detection", () => {
+    it("identifies values less than 60 as minutes", () => {
+      expect(findDurationType(0)).toBe("minutes");
+      expect(findDurationType(1)).toBe("minutes");
+      expect(findDurationType(15)).toBe("minutes");
+      expect(findDurationType(30)).toBe("minutes");
+      expect(findDurationType(45)).toBe("minutes");
+      expect(findDurationType(59)).toBe("minutes");
+    });
+
+    it("identifies decimal values less than 60 as minutes", () => {
+      expect(findDurationType(0.5)).toBe("minutes");
+      expect(findDurationType(15.5)).toBe("minutes");
+      expect(findDurationType(30.25)).toBe("minutes");
+      expect(findDurationType(59.99)).toBe("minutes");
+    });
+  });
+
+  describe("Hours detection", () => {
+    it("identifies values from 60 to 1439 as hours", () => {
+      expect(findDurationType(60)).toBe("hours");
+      expect(findDurationType(90)).toBe("hours");
+      expect(findDurationType(120)).toBe("hours");
+      expect(findDurationType(180)).toBe("hours");
+      expect(findDurationType(240)).toBe("hours");
+      expect(findDurationType(300)).toBe("hours");
+      expect(findDurationType(720)).toBe("hours");
+      expect(findDurationType(1439)).toBe("hours");
+    });
+
+    it("identifies common hour values correctly", () => {
+      expect(findDurationType(60)).toBe("hours");    // 1 hour
+      expect(findDurationType(120)).toBe("hours");   // 2 hours
+      expect(findDurationType(180)).toBe("hours");   // 3 hours
+      expect(findDurationType(240)).toBe("hours");   // 4 hours
+      expect(findDurationType(360)).toBe("hours");   // 6 hours
+      expect(findDurationType(480)).toBe("hours");   // 8 hours
+      expect(findDurationType(720)).toBe("hours");   // 12 hours
+      expect(findDurationType(1080)).toBe("hours");  // 18 hours
+    });
+
+    it("identifies decimal hour values correctly", () => {
+      expect(findDurationType(90)).toBe("hours");    // 1.5 hours
+      expect(findDurationType(150)).toBe("hours");   // 2.5 hours
+      expect(findDurationType(210)).toBe("hours");   // 3.5 hours
+      expect(findDurationType(270)).toBe("hours");   // 4.5 hours
+    });
+  });
+
+  describe("Days detection", () => {
+    it("identifies values 1440 and above as days", () => {
+      expect(findDurationType(1440)).toBe("days");   // 1 day
+      expect(findDurationType(2880)).toBe("days");   // 2 days
+      expect(findDurationType(4320)).toBe("days");   // 3 days
+      expect(findDurationType(5760)).toBe("days");   // 4 days
+      expect(findDurationType(7200)).toBe("days");   // 5 days
+      expect(findDurationType(10080)).toBe("days");  // 7 days (1 week)
+      expect(findDurationType(20160)).toBe("days");  // 14 days (2 weeks)
+      expect(findDurationType(43200)).toBe("days");  // 30 days (1 month)
+    });
+
+    it("identifies partial day values correctly", () => {
+      expect(findDurationType(2160)).toBe("days");   // 1.5 days
+      expect(findDurationType(3600)).toBe("days");   // 2.5 days
+      expect(findDurationType(5040)).toBe("days");   // 3.5 days
+    });
+
+    it("identifies very large values as days", () => {
+      expect(findDurationType(100000)).toBe("days");
+      expect(findDurationType(1000000)).toBe("days");
+      expect(findDurationType(Number.MAX_SAFE_INTEGER)).toBe("days");
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("handles boundary values correctly", () => {
+      // Boundary between minutes and hours
+      expect(findDurationType(59)).toBe("minutes");
+      expect(findDurationType(60)).toBe("hours");
+      expect(findDurationType(61)).toBe("hours");
+
+      // Boundary between hours and days
+      expect(findDurationType(1439)).toBe("hours");
+      expect(findDurationType(1440)).toBe("days");
+      expect(findDurationType(1441)).toBe("days");
+    });
+
+    it("handles zero value", () => {
+      expect(findDurationType(0)).toBe("minutes");
+    });
+
+    it("handles negative values", () => {
+      expect(findDurationType(-1)).toBe("minutes");
+      expect(findDurationType(-30)).toBe("minutes");
+      expect(findDurationType(-60)).toBe("minutes");
+      expect(findDurationType(-100)).toBe("minutes");
+      expect(findDurationType(-1440)).toBe("minutes");
+      expect(findDurationType(-10000)).toBe("minutes");
+    });
+
+    it("handles decimal boundary values", () => {
+      expect(findDurationType(59.9)).toBe("minutes");
+      expect(findDurationType(60.1)).toBe("hours");
+      expect(findDurationType(1439.9)).toBe("hours");
+      expect(findDurationType(1440.1)).toBe("days");
+    });
+
+    it("handles very small decimal values", () => {
+      expect(findDurationType(0.001)).toBe("minutes");
+      expect(findDurationType(0.01)).toBe("minutes");
+      expect(findDurationType(0.1)).toBe("minutes");
+    });
+  });
+
+  describe("Invalid inputs", () => {
+    it("handles NaN", () => {
+      expect(findDurationType(NaN)).toBe("minutes");
+    });
+
+    it("handles Infinity", () => {
+      expect(findDurationType(Infinity)).toBe("days");
+      expect(findDurationType(-Infinity)).toBe("minutes");
+    });
+
+    it("handles null and undefined", () => {
+      // @ts-expect-error Testing invalid input
+      expect(findDurationType(null)).toBe("minutes");
+      // @ts-expect-error Testing invalid input
+      expect(findDurationType(undefined)).toBe("minutes");
+    });
+
+    it("handles string numbers", () => {
+      // @ts-expect-error Testing invalid input
+      expect(findDurationType("30")).toBe("minutes");
+      // @ts-expect-error Testing invalid input
+      expect(findDurationType("120")).toBe("hours");
+      // @ts-expect-error Testing invalid input
+      expect(findDurationType("1440")).toBe("days");
+    });
+
+    it("handles non-numeric strings", () => {
+      // @ts-expect-error Testing invalid input
+      expect(findDurationType("not a number")).toBe("minutes");
+      // @ts-expect-error Testing invalid input
+      expect(findDurationType("")).toBe("minutes");
+    });
+  });
+
+  describe("Common use cases", () => {
+    it("correctly identifies typical booking notice durations", () => {
+      expect(findDurationType(0)).toBe("minutes");     // No notice
+      expect(findDurationType(15)).toBe("minutes");    // 15 min notice
+      expect(findDurationType(30)).toBe("minutes");    // 30 min notice
+      expect(findDurationType(60)).toBe("hours");      // 1 hour notice
+      expect(findDurationType(120)).toBe("hours");     // 2 hour notice
+      expect(findDurationType(240)).toBe("hours");     // 4 hour notice
+      expect(findDurationType(1440)).toBe("days");     // 1 day notice
+      expect(findDurationType(2880)).toBe("days");     // 2 day notice
+      expect(findDurationType(10080)).toBe("days");    // 1 week notice
+    });
+
+    it("correctly identifies typical cancellation notice durations", () => {
+      expect(findDurationType(30)).toBe("minutes");    // 30 min cancellation
+      expect(findDurationType(60)).toBe("hours");      // 1 hour cancellation
+      expect(findDurationType(120)).toBe("hours");     // 2 hour cancellation
+      expect(findDurationType(360)).toBe("hours");     // 6 hour cancellation
+      expect(findDurationType(720)).toBe("hours");     // 12 hour cancellation
+      expect(findDurationType(1440)).toBe("days");     // 24 hour cancellation
+      expect(findDurationType(2880)).toBe("days");     // 48 hour cancellation
+      expect(findDurationType(4320)).toBe("days");     // 72 hour cancellation
+    });
+
+    it("correctly identifies buffer time durations", () => {
+      expect(findDurationType(5)).toBe("minutes");     // 5 min buffer
+      expect(findDurationType(10)).toBe("minutes");    // 10 min buffer
+      expect(findDurationType(15)).toBe("minutes");    // 15 min buffer
+      expect(findDurationType(30)).toBe("minutes");    // 30 min buffer
+      expect(findDurationType(45)).toBe("minutes");    // 45 min buffer
+      expect(findDurationType(60)).toBe("hours");      // 1 hour buffer
+      expect(findDurationType(90)).toBe("hours");      // 1.5 hour buffer
+      expect(findDurationType(120)).toBe("hours");     // 2 hour buffer
+    });
+
+    it("correctly identifies meeting durations", () => {
+      expect(findDurationType(15)).toBe("minutes");    // 15 min meeting
+      expect(findDurationType(30)).toBe("minutes");    // 30 min meeting
+      expect(findDurationType(45)).toBe("minutes");    // 45 min meeting
+      expect(findDurationType(60)).toBe("hours");      // 1 hour meeting
+      expect(findDurationType(90)).toBe("hours");      // 1.5 hour meeting
+      expect(findDurationType(120)).toBe("hours");     // 2 hour meeting
+      expect(findDurationType(180)).toBe("hours");     // 3 hour meeting
+      expect(findDurationType(240)).toBe("hours");     // 4 hour meeting
+      expect(findDurationType(480)).toBe("hours");     // 8 hour workshop
+      expect(findDurationType(1440)).toBe("days");     // Full day event
+      expect(findDurationType(2880)).toBe("days");     // 2 day event
+    });
+  });
+
+  describe("Consistency with convertToNewDurationType", () => {
+    it("provides consistent type detection for round-trip conversions", () => {
+      // Test that findDurationType correctly identifies the expected type
+      // after conversions
+      
+      // 2 hours = 120 minutes
+      expect(findDurationType(120)).toBe("hours");
+      
+      // 1.5 days = 2160 minutes
+      expect(findDurationType(2160)).toBe("days");
+      
+      // 0.5 hours = 30 minutes
+      expect(findDurationType(30)).toBe("minutes");
+      
+      // 3 days = 4320 minutes
+      expect(findDurationType(4320)).toBe("days");
+    });
+  });
+
+  describe("Performance considerations", () => {
+    it("handles a large number of calls efficiently", () => {
+      const iterations = 10000;
+      const start = performance.now();
+      
+      for (let i = 0; i < iterations; i++) {
+        findDurationType(Math.random() * 10000);
+      }
+      
+      const end = performance.now();
+      const timePerCall = (end - start) / iterations;
+      
+      // Should be very fast - less than 0.01ms per call
+      expect(timePerCall).toBeLessThan(0.01);
+    });
+
+    it("returns consistent results for the same input", () => {
+      const testValues = [0, 30, 60, 120, 1440, 2880, 10080];
+      
+      testValues.forEach(value => {
+        const result1 = findDurationType(value);
+        const result2 = findDurationType(value);
+        const result3 = findDurationType(value);
+        
+        expect(result1).toBe(result2);
+        expect(result2).toBe(result3);
+      });
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/lib/event-types/minimumCancellationNotice.test.ts b/packages/lib/event-types/minimumCancellationNotice.test.ts
new file mode 100644
index 00000000000000..0d5eabb62172f0
--- /dev/null
+++ b/packages/lib/event-types/minimumCancellationNotice.test.ts
@@ -0,0 +1,101 @@
+import { describe, test, expect, beforeEach, vi } from "vitest";
+import prismock from "../../../tests/libs/__mocks__/prisma";
+
+describe("EventType.minimumCancellationNotice", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("should have minimumCancellationNotice field with default value 0", async () => {
+    const user = await prismock.user.create({
+      data: {
+        username: "testuser",
+        email: "test@example.com",
+      },
+    });
+
+    const eventType = await prismock.eventType.create({
+      data: {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+        userId: user.id,
+      },
+    });
+
+    expect(eventType).toHaveProperty("minimumCancellationNotice");
+    expect(eventType.minimumCancellationNotice).toBe(0);
+  });
+
+  test("should allow setting custom minimumCancellationNotice value", async () => {
+    const user = await prismock.user.create({
+      data: {
+        username: "testuser2",
+        email: "test2@example.com",
+      },
+    });
+
+    const customNoticeTime = 1440; // 24 hours in minutes
+    const eventType = await prismock.eventType.create({
+      data: {
+        title: "Test Event with Custom Notice",
+        slug: "test-event-custom",
+        length: 60,
+        userId: user.id,
+        minimumCancellationNotice: customNoticeTime,
+      },
+    });
+
+    expect(eventType.minimumCancellationNotice).toBe(customNoticeTime);
+  });
+
+  test("should update minimumCancellationNotice value", async () => {
+    const user = await prismock.user.create({
+      data: {
+        username: "testuser3",
+        email: "test3@example.com",
+      },
+    });
+
+    const eventType = await prismock.eventType.create({
+      data: {
+        title: "Test Event for Update",
+        slug: "test-event-update",
+        length: 45,
+        userId: user.id,
+      },
+    });
+
+    expect(eventType.minimumCancellationNotice).toBe(0);
+
+    const updatedEventType = await prismock.eventType.update({
+      where: { id: eventType.id },
+      data: { minimumCancellationNotice: 720 }, // 12 hours
+    });
+
+    expect(updatedEventType.minimumCancellationNotice).toBe(720);
+  });
+
+  test("should not allow negative values for minimumCancellationNotice", async () => {
+    const user = await prismock.user.create({
+      data: {
+        username: "testuser4",
+        email: "test4@example.com",
+      },
+    });
+
+    // This test assumes validation is enforced at the application layer
+    // The @zod.min(0) directive in the schema should prevent negative values
+    const eventType = await prismock.eventType.create({
+      data: {
+        title: "Test Event Non-Negative",
+        slug: "test-event-non-negative",
+        length: 30,
+        userId: user.id,
+        minimumCancellationNotice: 0, // Minimum allowed value
+      },
+    });
+
+    expect(eventType.minimumCancellationNotice).toBeGreaterThanOrEqual(0);
+  });
+});
\ No newline at end of file
diff --git a/packages/prisma/eventType.integration.test.ts b/packages/prisma/eventType.integration.test.ts
new file mode 100644
index 00000000000000..a71328dfa3728b
--- /dev/null
+++ b/packages/prisma/eventType.integration.test.ts
@@ -0,0 +1,579 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { PrismaClient } from "@prisma/client";
+
+// Mock Prisma client for integration testing
+const prisma = new PrismaClient();
+
+describe("EventType Integration Tests - minimumCancellationNotice", () => {
+  let testUserId: number;
+  let testTeamId: number;
+
+  beforeEach(async () => {
+    // Create test user for each test
+    const user = await prisma.user.create({
+      data: {
+        email: `test-${Date.now()}@example.com`,
+        username: `testuser-${Date.now()}`,
+      },
+    });
+    testUserId = user.id;
+
+    // Create test team
+    const team = await prisma.team.create({
+      data: {
+        name: `Test Team ${Date.now()}`,
+        slug: `test-team-${Date.now()}`,
+      },
+    });
+    testTeamId = team.id;
+  });
+
+  afterEach(async () => {
+    // Clean up test data
+    await prisma.eventType.deleteMany({ where: { userId: testUserId } });
+    await prisma.eventType.deleteMany({ where: { teamId: testTeamId } });
+    await prisma.user.delete({ where: { id: testUserId } });
+    await prisma.team.delete({ where: { id: testTeamId } });
+  });
+
+  describe("CRUD Operations", () => {
+    it("should create an EventType with minimumCancellationNotice", async () => {
+      const eventType = await prisma.eventType.create({
+        data: {
+          title: "30 Min Meeting",
+          slug: "30-min-meeting",
+          length: 30,
+          userId: testUserId,
+          minimumCancellationNotice: 1440, // 24 hours
+        },
+      });
+
+      expect(eventType).toBeDefined();
+      expect(eventType.minimumCancellationNotice).toBe(1440);
+      expect(eventType.title).toBe("30 Min Meeting");
+      expect(eventType.length).toBe(30);
+    });
+
+    it("should read EventType with minimumCancellationNotice", async () => {
+      const created = await prisma.eventType.create({
+        data: {
+          title: "Consultation",
+          slug: "consultation",
+          length: 60,
+          userId: testUserId,
+          minimumCancellationNotice: 720, // 12 hours
+        },
+      });
+
+      const fetched = await prisma.eventType.findUnique({
+        where: { id: created.id },
+      });
+
+      expect(fetched).toBeDefined();
+      expect(fetched?.minimumCancellationNotice).toBe(720);
+      expect(fetched?.id).toBe(created.id);
+    });
+
+    it("should update EventType minimumCancellationNotice", async () => {
+      const eventType = await prisma.eventType.create({
+        data: {
+          title: "Workshop",
+          slug: "workshop",
+          length: 120,
+          userId: testUserId,
+          minimumCancellationNotice: 2880, // 48 hours
+        },
+      });
+
+      const updated = await prisma.eventType.update({
+        where: { id: eventType.id },
+        data: { minimumCancellationNotice: 4320 }, // 72 hours
+      });
+
+      expect(updated.minimumCancellationNotice).toBe(4320);
+      
+      // Verify persistence
+      const fetched = await prisma.eventType.findUnique({
+        where: { id: eventType.id },
+      });
+      expect(fetched?.minimumCancellationNotice).toBe(4320);
+    });
+
+    it("should delete EventType with minimumCancellationNotice", async () => {
+      const eventType = await prisma.eventType.create({
+        data: {
+          title: "Temporary Event",
+          slug: "temp-event",
+          length: 15,
+          userId: testUserId,
+          minimumCancellationNotice: 60, // 1 hour
+        },
+      });
+
+      await prisma.eventType.delete({
+        where: { id: eventType.id },
+      });
+
+      const fetched = await prisma.eventType.findUnique({
+        where: { id: eventType.id },
+      });
+
+      expect(fetched).toBeNull();
+    });
+  });
+
+  describe("Bulk Operations", () => {
+    it("should handle bulk create with different minimumCancellationNotice values", async () => {
+      const eventTypes = await prisma.eventType.createMany({
+        data: [
+          {
+            title: "Quick Call",
+            slug: "quick-call-1",
+            length: 15,
+            userId: testUserId,
+            minimumCancellationNotice: 30, // 30 minutes
+          },
+          {
+            title: "Standard Meeting",
+            slug: "standard-meeting-1",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 360, // 6 hours
+          },
+          {
+            title: "Long Session",
+            slug: "long-session-1",
+            length: 90,
+            userId: testUserId,
+            minimumCancellationNotice: 1440, // 24 hours
+          },
+        ],
+      });
+
+      expect(eventTypes.count).toBe(3);
+
+      const fetchedEventTypes = await prisma.eventType.findMany({
+        where: { userId: testUserId },
+        orderBy: { length: "asc" },
+      });
+
+      expect(fetchedEventTypes).toHaveLength(3);
+      expect(fetchedEventTypes[0].minimumCancellationNotice).toBe(30);
+      expect(fetchedEventTypes[1].minimumCancellationNotice).toBe(360);
+      expect(fetchedEventTypes[2].minimumCancellationNotice).toBe(1440);
+    });
+
+    it("should handle bulk update of minimumCancellationNotice", async () => {
+      // Create multiple event types
+      await prisma.eventType.createMany({
+        data: [
+          {
+            title: "Event 1",
+            slug: "event-1-bulk",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 0,
+          },
+          {
+            title: "Event 2",
+            slug: "event-2-bulk",
+            length: 45,
+            userId: testUserId,
+            minimumCancellationNotice: 0,
+          },
+        ],
+      });
+
+      // Update all event types for this user
+      await prisma.eventType.updateMany({
+        where: { userId: testUserId },
+        data: { minimumCancellationNotice: 240 }, // 4 hours
+      });
+
+      const updatedEvents = await prisma.eventType.findMany({
+        where: { userId: testUserId },
+      });
+
+      expect(updatedEvents).toHaveLength(2);
+      updatedEvents.forEach((event) => {
+        expect(event.minimumCancellationNotice).toBe(240);
+      });
+    });
+  });
+
+  describe("Query Filtering", () => {
+    it("should filter EventTypes by minimumCancellationNotice value", async () => {
+      // Create event types with different cancellation notices
+      await prisma.eventType.createMany({
+        data: [
+          {
+            title: "No Notice",
+            slug: "no-notice",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 0,
+          },
+          {
+            title: "Short Notice",
+            slug: "short-notice",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 60,
+          },
+          {
+            title: "Long Notice",
+            slug: "long-notice",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 2880,
+          },
+        ],
+      });
+
+      // Query for events with no cancellation notice
+      const noNoticeEvents = await prisma.eventType.findMany({
+        where: {
+          userId: testUserId,
+          minimumCancellationNotice: 0,
+        },
+      });
+      expect(noNoticeEvents).toHaveLength(1);
+      expect(noNoticeEvents[0].title).toBe("No Notice");
+
+      // Query for events with cancellation notice > 1 day
+      const longNoticeEvents = await prisma.eventType.findMany({
+        where: {
+          userId: testUserId,
+          minimumCancellationNotice: {
+            gt: 1440, // Greater than 24 hours
+          },
+        },
+      });
+      expect(longNoticeEvents).toHaveLength(1);
+      expect(longNoticeEvents[0].title).toBe("Long Notice");
+
+      // Query for events with cancellation notice between 30 mins and 12 hours
+      const mediumNoticeEvents = await prisma.eventType.findMany({
+        where: {
+          userId: testUserId,
+          minimumCancellationNotice: {
+            gte: 30,
+            lte: 720,
+          },
+        },
+      });
+      expect(mediumNoticeEvents).toHaveLength(1);
+      expect(mediumNoticeEvents[0].title).toBe("Short Notice");
+    });
+
+    it("should sort EventTypes by minimumCancellationNotice", async () => {
+      await prisma.eventType.createMany({
+        data: [
+          {
+            title: "Medium Notice",
+            slug: "medium-sort",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 360,
+          },
+          {
+            title: "No Notice",
+            slug: "no-sort",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 0,
+          },
+          {
+            title: "Long Notice",
+            slug: "long-sort",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 1440,
+          },
+        ],
+      });
+
+      // Sort ascending
+      const ascendingEvents = await prisma.eventType.findMany({
+        where: { userId: testUserId },
+        orderBy: { minimumCancellationNotice: "asc" },
+      });
+
+      expect(ascendingEvents[0].title).toBe("No Notice");
+      expect(ascendingEvents[1].title).toBe("Medium Notice");
+      expect(ascendingEvents[2].title).toBe("Long Notice");
+
+      // Sort descending
+      const descendingEvents = await prisma.eventType.findMany({
+        where: { userId: testUserId },
+        orderBy: { minimumCancellationNotice: "desc" },
+      });
+
+      expect(descendingEvents[0].title).toBe("Long Notice");
+      expect(descendingEvents[1].title).toBe("Medium Notice");
+      expect(descendingEvents[2].title).toBe("No Notice");
+    });
+  });
+
+  describe("Relationships and Joins", () => {
+    it("should include minimumCancellationNotice when fetching with user relation", async () => {
+      await prisma.eventType.create({
+        data: {
+          title: "User Event",
+          slug: "user-event",
+          length: 45,
+          userId: testUserId,
+          minimumCancellationNotice: 180,
+        },
+      });
+
+      const eventWithUser = await prisma.eventType.findFirst({
+        where: { userId: testUserId },
+        include: { owner: true },
+      });
+
+      expect(eventWithUser).toBeDefined();
+      expect(eventWithUser?.minimumCancellationNotice).toBe(180);
+      expect(eventWithUser?.owner).toBeDefined();
+      expect(eventWithUser?.owner?.id).toBe(testUserId);
+    });
+
+    it("should handle team event types with minimumCancellationNotice", async () => {
+      const teamEventType = await prisma.eventType.create({
+        data: {
+          title: "Team Standup",
+          slug: "team-standup",
+          length: 15,
+          teamId: testTeamId,
+          minimumCancellationNotice: 60,
+        },
+      });
+
+      const fetchedTeamEvent = await prisma.eventType.findFirst({
+        where: { teamId: testTeamId },
+        include: { team: true },
+      });
+
+      expect(fetchedTeamEvent).toBeDefined();
+      expect(fetchedTeamEvent?.minimumCancellationNotice).toBe(60);
+      expect(fetchedTeamEvent?.team).toBeDefined();
+      expect(fetchedTeamEvent?.team?.id).toBe(testTeamId);
+    });
+
+    it("should handle parent-child event type relationships", async () => {
+      const parentEvent = await prisma.eventType.create({
+        data: {
+          title: "Parent Event Type",
+          slug: "parent-event-type",
+          length: 60,
+          userId: testUserId,
+          minimumCancellationNotice: 1440,
+        },
+      });
+
+      const childEvent = await prisma.eventType.create({
+        data: {
+          title: "Child Event Type",
+          slug: "child-event-type",
+          length: 60,
+          userId: testUserId,
+          parentId: parentEvent.id,
+          minimumCancellationNotice: 720, // Different from parent
+        },
+      });
+
+      const fetchedParent = await prisma.eventType.findUnique({
+        where: { id: parentEvent.id },
+        include: { children: true },
+      });
+
+      expect(fetchedParent?.minimumCancellationNotice).toBe(1440);
+      expect(fetchedParent?.children).toHaveLength(1);
+      expect(fetchedParent?.children[0].minimumCancellationNotice).toBe(720);
+
+      const fetchedChild = await prisma.eventType.findUnique({
+        where: { id: childEvent.id },
+        include: { parent: true },
+      });
+
+      expect(fetchedChild?.minimumCancellationNotice).toBe(720);
+      expect(fetchedChild?.parent?.minimumCancellationNotice).toBe(1440);
+    });
+  });
+
+  describe("Aggregation Queries", () => {
+    it("should calculate average minimumCancellationNotice", async () => {
+      await prisma.eventType.createMany({
+        data: [
+          {
+            title: "Event A",
+            slug: "event-a-agg",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 60,
+          },
+          {
+            title: "Event B",
+            slug: "event-b-agg",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 120,
+          },
+          {
+            title: "Event C",
+            slug: "event-c-agg",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 180,
+          },
+        ],
+      });
+
+      const aggregation = await prisma.eventType.aggregate({
+        where: { userId: testUserId },
+        _avg: { minimumCancellationNotice: true },
+        _min: { minimumCancellationNotice: true },
+        _max: { minimumCancellationNotice: true },
+        _sum: { minimumCancellationNotice: true },
+        _count: { minimumCancellationNotice: true },
+      });
+
+      expect(aggregation._avg.minimumCancellationNotice).toBe(120);
+      expect(aggregation._min.minimumCancellationNotice).toBe(60);
+      expect(aggregation._max.minimumCancellationNotice).toBe(180);
+      expect(aggregation._sum.minimumCancellationNotice).toBe(360);
+      expect(aggregation._count.minimumCancellationNotice).toBe(3);
+    });
+
+    it("should group EventTypes by minimumCancellationNotice ranges", async () => {
+      await prisma.eventType.createMany({
+        data: [
+          {
+            title: "No Notice 1",
+            slug: "no-notice-group-1",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 0,
+          },
+          {
+            title: "No Notice 2",
+            slug: "no-notice-group-2",
+            length: 45,
+            userId: testUserId,
+            minimumCancellationNotice: 0,
+          },
+          {
+            title: "Short Notice",
+            slug: "short-notice-group",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 60,
+          },
+          {
+            title: "Long Notice",
+            slug: "long-notice-group",
+            length: 60,
+            userId: testUserId,
+            minimumCancellationNotice: 1440,
+          },
+        ],
+      });
+
+      const groupedResults = await prisma.eventType.groupBy({
+        by: ["minimumCancellationNotice"],
+        where: { userId: testUserId },
+        _count: { _all: true },
+      });
+
+      expect(groupedResults).toHaveLength(3);
+      
+      const zeroNotice = groupedResults.find(g => g.minimumCancellationNotice === 0);
+      expect(zeroNotice?._count._all).toBe(2);
+      
+      const shortNotice = groupedResults.find(g => g.minimumCancellationNotice === 60);
+      expect(shortNotice?._count._all).toBe(1);
+      
+      const longNotice = groupedResults.find(g => g.minimumCancellationNotice === 1440);
+      expect(longNotice?._count._all).toBe(1);
+    });
+  });
+
+  describe("Transaction Support", () => {
+    it("should handle minimumCancellationNotice in transactions", async () => {
+      const result = await prisma.$transaction(async (tx) => {
+        const event1 = await tx.eventType.create({
+          data: {
+            title: "Transaction Event 1",
+            slug: "tx-event-1",
+            length: 30,
+            userId: testUserId,
+            minimumCancellationNotice: 240,
+          },
+        });
+
+        const event2 = await tx.eventType.create({
+          data: {
+            title: "Transaction Event 2",
+            slug: "tx-event-2",
+            length: 45,
+            userId: testUserId,
+            minimumCancellationNotice: 480,
+          },
+        });
+
+        // Update the first event within the transaction
+        const updated = await tx.eventType.update({
+          where: { id: event1.id },
+          data: { minimumCancellationNotice: 360 },
+        });
+
+        return { event1: updated, event2 };
+      });
+
+      expect(result.event1.minimumCancellationNotice).toBe(360);
+      expect(result.event2.minimumCancellationNotice).toBe(480);
+
+      // Verify outside of transaction
+      const fetched1 = await prisma.eventType.findUnique({
+        where: { id: result.event1.id },
+      });
+      const fetched2 = await prisma.eventType.findUnique({
+        where: { id: result.event2.id },
+      });
+
+      expect(fetched1?.minimumCancellationNotice).toBe(360);
+      expect(fetched2?.minimumCancellationNotice).toBe(480);
+    });
+
+    it("should rollback minimumCancellationNotice changes on transaction failure", async () => {
+      let createdId: number | undefined;
+
+      try {
+        await prisma.$transaction(async (tx) => {
+          const event = await tx.eventType.create({
+            data: {
+              title: "Rollback Test",
+              slug: "rollback-test-tx",
+              length: 30,
+              userId: testUserId,
+              minimumCancellationNotice: 720,
+            },
+          });
+          createdId = event.id;
+
+          // Force an error to rollback the transaction
+          throw new Error("Forced rollback");
+        });
+      } catch (error) {
+        // Expected error
+      }
+
+      if (createdId) {
+        const fetched = await prisma.eventType.findUnique({
+          where: { id: createdId },
+        });
+        expect(fetched).toBeNull(); // Should not exist due to rollback
+      }
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/prisma/migrations/20250915064816_add_minimum_cancellation_notice/migration.sql b/packages/prisma/migrations/20250915064816_add_minimum_cancellation_notice/migration.sql
new file mode 100644
index 00000000000000..dfeedb19ddb427
--- /dev/null
+++ b/packages/prisma/migrations/20250915064816_add_minimum_cancellation_notice/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "EventType" ADD COLUMN     "minimumCancellationNotice" INTEGER NOT NULL DEFAULT 0;
diff --git a/packages/prisma/minimumCancellationNotice.migration.test.ts b/packages/prisma/minimumCancellationNotice.migration.test.ts
new file mode 100644
index 00000000000000..0bba2aded449fd
--- /dev/null
+++ b/packages/prisma/minimumCancellationNotice.migration.test.ts
@@ -0,0 +1,281 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { PrismaClient } from "@prisma/client";
+import { execSync } from "child_process";
+import path from "path";
+
+// Test database configuration
+const TEST_DATABASE_URL = process.env.TEST_DATABASE_URL || "postgresql://postgres:postgres@localhost:5432/cal_test_minimum_cancellation";
+
+describe("minimumCancellationNotice Migration Tests", () => {
+  let prisma: PrismaClient;
+
+  beforeAll(async () => {
+    // Set up test database connection
+    process.env.DATABASE_URL = TEST_DATABASE_URL;
+    
+    // Create a new Prisma client instance for testing
+    prisma = new PrismaClient({
+      datasources: {
+        db: {
+          url: TEST_DATABASE_URL,
+        },
+      },
+    });
+
+    // Run migrations up to the point before adding minimumCancellationNotice
+    try {
+      execSync("npx prisma migrate reset --force --skip-seed", {
+        cwd: path.join(__dirname, ".."),
+        env: { ...process.env, DATABASE_URL: TEST_DATABASE_URL },
+      });
+    } catch (error) {
+      console.error("Migration setup failed:", error);
+    }
+  });
+
+  afterAll(async () => {
+    // Clean up database connection
+    await prisma.$disconnect();
+  });
+
+  describe("Database Schema Migration", () => {
+    it("should add minimumCancellationNotice field to EventType table", async () => {
+      // Check if the column exists in the database schema
+      const result = await prisma.$queryRaw`
+        SELECT column_name, data_type, column_default, is_nullable
+        FROM information_schema.columns
+        WHERE table_name = 'EventType' 
+        AND column_name = 'minimumCancellationNotice'
+      ` as Array<{
+        column_name: string;
+        data_type: string;
+        column_default: string | null;
+        is_nullable: string;
+      }>;
+
+      expect(result).toHaveLength(1);
+      expect(result[0].column_name).toBe("minimumCancellationNotice");
+      expect(result[0].data_type).toBe("integer");
+      expect(result[0].column_default).toBe("0");
+      expect(result[0].is_nullable).toBe("NO");
+    });
+
+    it("should set default value of 0 for minimumCancellationNotice", async () => {
+      // Create a user first
+      const user = await prisma.user.create({
+        data: {
+          email: "migration-test@example.com",
+          username: "migration-test-user",
+        },
+      });
+
+      // Create an event type without specifying minimumCancellationNotice
+      const eventType = await prisma.eventType.create({
+        data: {
+          title: "Migration Test Event",
+          slug: "migration-test-event",
+          length: 30,
+          userId: user.id,
+        },
+      });
+
+      // Verify the default value is applied
+      expect(eventType).toHaveProperty("minimumCancellationNotice");
+      expect(eventType.minimumCancellationNotice).toBe(0);
+
+      // Clean up
+      await prisma.eventType.delete({ where: { id: eventType.id } });
+      await prisma.user.delete({ where: { id: user.id } });
+    });
+
+    it("should migrate existing EventType records with default value", async () => {
+      // First, create some test data before the migration
+      const user = await prisma.user.create({
+        data: {
+          email: "existing-user@example.com",
+          username: "existing-user",
+        },
+      });
+
+      // Create multiple event types
+      const eventTypes = await Promise.all([
+        prisma.eventType.create({
+          data: {
+            title: "Existing Event 1",
+            slug: "existing-event-1",
+            length: 30,
+            userId: user.id,
+          },
+        }),
+        prisma.eventType.create({
+          data: {
+            title: "Existing Event 2",
+            slug: "existing-event-2",
+            length: 60,
+            userId: user.id,
+          },
+        }),
+      ]);
+
+      // Verify all existing records have the default value
+      for (const eventType of eventTypes) {
+        const retrieved = await prisma.eventType.findUnique({
+          where: { id: eventType.id },
+        });
+        expect(retrieved?.minimumCancellationNotice).toBe(0);
+      }
+
+      // Clean up
+      await prisma.eventType.deleteMany({ where: { userId: user.id } });
+      await prisma.user.delete({ where: { id: user.id } });
+    });
+
+    it("should handle NULL values correctly during migration", async () => {
+      // This test simulates what happens if there were NULL values before migration
+      // The migration should convert them to the default value of 0
+      
+      const user = await prisma.user.create({
+        data: {
+          email: "null-test@example.com",
+          username: "null-test-user",
+        },
+      });
+
+      // Create an event type
+      const eventType = await prisma.eventType.create({
+        data: {
+          title: "Null Test Event",
+          slug: "null-test-event",
+          length: 45,
+          userId: user.id,
+        },
+      });
+
+      // Try to update with null (should not be allowed after migration)
+      await expect(
+        prisma.eventType.update({
+          where: { id: eventType.id },
+          data: { minimumCancellationNotice: null as any },
+        })
+      ).rejects.toThrow();
+
+      // Clean up
+      await prisma.eventType.delete({ where: { id: eventType.id } });
+      await prisma.user.delete({ where: { id: user.id } });
+    });
+
+    it("should maintain data integrity for team event types", async () => {
+      // Create a team
+      const team = await prisma.team.create({
+        data: {
+          name: "Test Team",
+          slug: "test-team",
+        },
+      });
+
+      // Create a team event type
+      const teamEventType = await prisma.eventType.create({
+        data: {
+          title: "Team Event",
+          slug: "team-event",
+          length: 60,
+          teamId: team.id,
+          minimumCancellationNotice: 1440, // 24 hours
+        },
+      });
+
+      expect(teamEventType.minimumCancellationNotice).toBe(1440);
+
+      // Verify the value persists correctly
+      const retrieved = await prisma.eventType.findUnique({
+        where: { id: teamEventType.id },
+      });
+      expect(retrieved?.minimumCancellationNotice).toBe(1440);
+
+      // Clean up
+      await prisma.eventType.delete({ where: { id: teamEventType.id } });
+      await prisma.team.delete({ where: { id: team.id } });
+    });
+
+    it("should handle managed event types correctly", async () => {
+      // Create a user
+      const user = await prisma.user.create({
+        data: {
+          email: "managed-test@example.com",
+          username: "managed-test-user",
+        },
+      });
+
+      // Create a parent event type
+      const parentEventType = await prisma.eventType.create({
+        data: {
+          title: "Parent Event",
+          slug: "parent-event",
+          length: 30,
+          userId: user.id,
+          minimumCancellationNotice: 720, // 12 hours
+        },
+      });
+
+      // Create a child managed event type
+      const childEventType = await prisma.eventType.create({
+        data: {
+          title: "Child Event",
+          slug: "child-event",
+          length: 30,
+          userId: user.id,
+          parentId: parentEventType.id,
+          minimumCancellationNotice: 360, // 6 hours (different from parent)
+        },
+      });
+
+      // Verify both have their own values
+      expect(parentEventType.minimumCancellationNotice).toBe(720);
+      expect(childEventType.minimumCancellationNotice).toBe(360);
+
+      // Clean up
+      await prisma.eventType.delete({ where: { id: childEventType.id } });
+      await prisma.eventType.delete({ where: { id: parentEventType.id } });
+      await prisma.user.delete({ where: { id: user.id } });
+    });
+  });
+
+  describe("Migration Rollback Safety", () => {
+    it("should be safe to rollback and re-apply migration", async () => {
+      // This test verifies that the migration is idempotent
+      // and can be safely rolled back and re-applied
+      
+      const user = await prisma.user.create({
+        data: {
+          email: "rollback-test@example.com",
+          username: "rollback-test-user",
+        },
+      });
+
+      // Create event type with specific value
+      const eventType = await prisma.eventType.create({
+        data: {
+          title: "Rollback Test Event",
+          slug: "rollback-test-event",
+          length: 30,
+          userId: user.id,
+          minimumCancellationNotice: 2880, // 48 hours
+        },
+      });
+
+      // Verify the value is preserved
+      expect(eventType.minimumCancellationNotice).toBe(2880);
+
+      // Update the value
+      const updated = await prisma.eventType.update({
+        where: { id: eventType.id },
+        data: { minimumCancellationNotice: 1440 },
+      });
+      expect(updated.minimumCancellationNotice).toBe(1440);
+
+      // Clean up
+      await prisma.eventType.delete({ where: { id: eventType.id } });
+      await prisma.user.delete({ where: { id: user.id } });
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/prisma/minimumCancellationNotice.validation.test.ts b/packages/prisma/minimumCancellationNotice.validation.test.ts
new file mode 100644
index 00000000000000..741e25045bea37
--- /dev/null
+++ b/packages/prisma/minimumCancellationNotice.validation.test.ts
@@ -0,0 +1,432 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { z } from "zod";
+import { PrismaClient } from "@prisma/client";
+
+// Mock Prisma client
+const prisma = new PrismaClient();
+
+// Define the Zod schema for EventType with minimumCancellationNotice validation
+const EventTypeSchema = z.object({
+  id: z.number().int().optional(),
+  title: z.string().min(1),
+  slug: z.string(),
+  description: z.string().nullable().optional(),
+  length: z.number().int().min(1),
+  minimumCancellationNotice: z.number().int().min(0).default(0),
+  hidden: z.boolean().default(false),
+  position: z.number().int().default(0),
+  userId: z.number().int().nullable().optional(),
+  teamId: z.number().int().nullable().optional(),
+  parentId: z.number().int().nullable().optional(),
+});
+
+// Create a validation wrapper for EventType operations
+class EventTypeValidator {
+  static validateCreate(data: any) {
+    return EventTypeSchema.parse(data);
+  }
+
+  static validateUpdate(data: any) {
+    return EventTypeSchema.partial().parse(data);
+  }
+
+  static isValidCancellationNotice(minutes: number): boolean {
+    return Number.isInteger(minutes) && minutes >= 0;
+  }
+
+  static convertHoursToMinutes(hours: number): number {
+    return hours * 60;
+  }
+
+  static convertDaysToMinutes(days: number): number {
+    return days * 24 * 60;
+  }
+}
+
+describe("minimumCancellationNotice Validation Tests", () => {
+  describe("Zod Schema Validation", () => {
+    it("should validate correct minimumCancellationNotice values", () => {
+      const validData = {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+        minimumCancellationNotice: 1440, // 24 hours
+      };
+
+      const result = EventTypeSchema.parse(validData);
+      expect(result.minimumCancellationNotice).toBe(1440);
+    });
+
+    it("should apply default value of 0 when minimumCancellationNotice is not provided", () => {
+      const dataWithoutNotice = {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+      };
+
+      const result = EventTypeSchema.parse(dataWithoutNotice);
+      expect(result.minimumCancellationNotice).toBe(0);
+    });
+
+    it("should reject negative minimumCancellationNotice values", () => {
+      const invalidData = {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+        minimumCancellationNotice: -60,
+      };
+
+      expect(() => EventTypeSchema.parse(invalidData)).toThrow();
+    });
+
+    it("should reject non-integer minimumCancellationNotice values", () => {
+      const invalidData = {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+        minimumCancellationNotice: 30.5,
+      };
+
+      expect(() => EventTypeSchema.parse(invalidData)).toThrow();
+    });
+
+    it("should reject non-numeric minimumCancellationNotice values", () => {
+      const invalidData = {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+        minimumCancellationNotice: "24 hours",
+      };
+
+      expect(() => EventTypeSchema.parse(invalidData)).toThrow();
+    });
+
+    it("should handle null and undefined differently", () => {
+      // undefined should use default
+      const dataWithUndefined = {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+        minimumCancellationNotice: undefined,
+      };
+      const resultUndefined = EventTypeSchema.parse(dataWithUndefined);
+      expect(resultUndefined.minimumCancellationNotice).toBe(0);
+
+      // null should throw error
+      const dataWithNull = {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+        minimumCancellationNotice: null,
+      };
+      expect(() => EventTypeSchema.parse(dataWithNull)).toThrow();
+    });
+  });
+
+  describe("Business Logic Validation", () => {
+    it("should validate common cancellation notice periods", () => {
+      const commonPeriods = [
+        { value: 0, description: "No notice required", valid: true },
+        { value: 15, description: "15 minutes", valid: true },
+        { value: 30, description: "30 minutes", valid: true },
+        { value: 60, description: "1 hour", valid: true },
+        { value: 120, description: "2 hours", valid: true },
+        { value: 240, description: "4 hours", valid: true },
+        { value: 360, description: "6 hours", valid: true },
+        { value: 720, description: "12 hours", valid: true },
+        { value: 1440, description: "24 hours (1 day)", valid: true },
+        { value: 2880, description: "48 hours (2 days)", valid: true },
+        { value: 4320, description: "72 hours (3 days)", valid: true },
+        { value: 10080, description: "1 week", valid: true },
+        { value: 20160, description: "2 weeks", valid: true },
+      ];
+
+      commonPeriods.forEach(({ value, description, valid }) => {
+        const isValid = EventTypeValidator.isValidCancellationNotice(value);
+        expect(isValid).toBe(valid);
+      });
+    });
+
+    it("should validate edge cases for minimumCancellationNotice", () => {
+      // Zero (minimum valid value)
+      expect(EventTypeValidator.isValidCancellationNotice(0)).toBe(true);
+
+      // Very large value (1 year in minutes)
+      expect(EventTypeValidator.isValidCancellationNotice(525600)).toBe(true);
+
+      // Maximum safe integer
+      expect(EventTypeValidator.isValidCancellationNotice(Number.MAX_SAFE_INTEGER)).toBe(true);
+
+      // Invalid values
+      expect(EventTypeValidator.isValidCancellationNotice(-1)).toBe(false);
+      expect(EventTypeValidator.isValidCancellationNotice(NaN)).toBe(false);
+      expect(EventTypeValidator.isValidCancellationNotice(Infinity)).toBe(false);
+      expect(EventTypeValidator.isValidCancellationNotice(-Infinity)).toBe(false);
+    });
+
+    it("should correctly convert time units to minutes", () => {
+      // Hours to minutes
+      expect(EventTypeValidator.convertHoursToMinutes(1)).toBe(60);
+      expect(EventTypeValidator.convertHoursToMinutes(2.5)).toBe(150);
+      expect(EventTypeValidator.convertHoursToMinutes(24)).toBe(1440);
+
+      // Days to minutes
+      expect(EventTypeValidator.convertDaysToMinutes(1)).toBe(1440);
+      expect(EventTypeValidator.convertDaysToMinutes(2)).toBe(2880);
+      expect(EventTypeValidator.convertDaysToMinutes(7)).toBe(10080);
+    });
+  });
+
+  describe("Update Validation", () => {
+    it("should allow partial updates with minimumCancellationNotice", () => {
+      const updateData = {
+        minimumCancellationNotice: 480,
+      };
+
+      const result = EventTypeValidator.validateUpdate(updateData);
+      expect(result.minimumCancellationNotice).toBe(480);
+    });
+
+    it("should reject invalid updates to minimumCancellationNotice", () => {
+      const invalidUpdate = {
+        minimumCancellationNotice: -120,
+      };
+
+      expect(() => EventTypeValidator.validateUpdate(invalidUpdate)).toThrow();
+    });
+
+    it("should allow updates without minimumCancellationNotice", () => {
+      const updateData = {
+        title: "Updated Title",
+        length: 45,
+      };
+
+      const result = EventTypeValidator.validateUpdate(updateData);
+      expect(result.minimumCancellationNotice).toBeUndefined();
+      expect(result.title).toBe("Updated Title");
+      expect(result.length).toBe(45);
+    });
+  });
+
+  describe("Validation Error Messages", () => {
+    it("should provide meaningful error messages for validation failures", () => {
+      const testCases = [
+        {
+          data: { minimumCancellationNotice: -60 },
+          expectedError: /too_small|minimum|greater than or equal to 0/i,
+        },
+        {
+          data: { minimumCancellationNotice: "invalid" },
+          expectedError: /expected number|invalid_type/i,
+        },
+        {
+          data: { minimumCancellationNotice: 30.5 },
+          expectedError: /expected integer|invalid_type|must be an integer/i,
+        },
+        {
+          data: { minimumCancellationNotice: null },
+          expectedError: /expected number|invalid_type/i,
+        },
+      ];
+
+      testCases.forEach(({ data, expectedError }) => {
+        try {
+          EventTypeSchema.partial().parse(data);
+          // Should not reach here
+          expect(true).toBe(false);
+        } catch (error) {
+          if (error instanceof z.ZodError) {
+            const errorMessage = error.errors.map(e => e.message).join(", ");
+            expect(errorMessage).toMatch(expectedError);
+          } else {
+            // If it's not a ZodError, check the error message directly
+            expect(String(error)).toMatch(expectedError);
+          }
+        }
+      });
+    });
+  });
+
+  describe("Complex Validation Scenarios", () => {
+    it("should validate EventType with all fields including minimumCancellationNotice", () => {
+      const completeData = {
+        id: 1,
+        title: "Complete Event Type",
+        slug: "complete-event-type",
+        description: "A complete event type with all fields",
+        length: 60,
+        minimumCancellationNotice: 720,
+        hidden: false,
+        position: 0,
+        userId: 123,
+        teamId: null,
+        parentId: null,
+      };
+
+      const result = EventTypeSchema.parse(completeData);
+      expect(result.minimumCancellationNotice).toBe(720);
+      expect(result.title).toBe("Complete Event Type");
+    });
+
+    it("should validate minimumCancellationNotice in relation to event length", () => {
+      // Business rule: cancellation notice can be longer than event length
+      const eventData = {
+        title: "Short Event",
+        slug: "short-event",
+        length: 15, // 15 minute event
+        minimumCancellationNotice: 1440, // 24 hour cancellation notice
+      };
+
+      const result = EventTypeSchema.parse(eventData);
+      
+      // This is valid - you can require 24 hours notice for a 15-minute event
+      expect(result.minimumCancellationNotice).toBe(1440);
+      expect(result.length).toBe(15);
+      expect(result.minimumCancellationNotice > result.length).toBe(true);
+    });
+
+    it("should handle batch validation of multiple EventTypes", () => {
+      const eventTypes = [
+        {
+          title: "Event 1",
+          slug: "event-1",
+          length: 30,
+          minimumCancellationNotice: 0,
+        },
+        {
+          title: "Event 2",
+          slug: "event-2",
+          length: 45,
+          minimumCancellationNotice: 360,
+        },
+        {
+          title: "Event 3",
+          slug: "event-3",
+          length: 60,
+          minimumCancellationNotice: 1440,
+        },
+      ];
+
+      const results = eventTypes.map(data => EventTypeSchema.parse(data));
+      
+      expect(results).toHaveLength(3);
+      expect(results[0].minimumCancellationNotice).toBe(0);
+      expect(results[1].minimumCancellationNotice).toBe(360);
+      expect(results[2].minimumCancellationNotice).toBe(1440);
+    });
+
+    it("should validate array of minimumCancellationNotice values", () => {
+      const ArraySchema = z.array(z.number().int().min(0));
+      
+      const validArray = [0, 60, 120, 1440, 2880];
+      const result = ArraySchema.parse(validArray);
+      expect(result).toEqual(validArray);
+
+      const invalidArray = [0, 60, -30, 1440];
+      expect(() => ArraySchema.parse(invalidArray)).toThrow();
+    });
+  });
+
+  describe("Custom Validation Rules", () => {
+    it("should enforce maximum cancellation notice limit", () => {
+      // Custom rule: maximum 30 days (43200 minutes) cancellation notice
+      const MAX_CANCELLATION_NOTICE = 43200;
+      
+      const CustomEventTypeSchema = EventTypeSchema.extend({
+        minimumCancellationNotice: z
+          .number()
+          .int()
+          .min(0)
+          .max(MAX_CANCELLATION_NOTICE, "Cancellation notice cannot exceed 30 days")
+          .default(0),
+      });
+
+      // Valid: within limit
+      const validData = {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+        minimumCancellationNotice: 20160, // 14 days
+      };
+      const result = CustomEventTypeSchema.parse(validData);
+      expect(result.minimumCancellationNotice).toBe(20160);
+
+      // Invalid: exceeds limit
+      const invalidData = {
+        title: "Test Event",
+        slug: "test-event",
+        length: 30,
+        minimumCancellationNotice: 50000, // > 30 days
+      };
+      expect(() => CustomEventTypeSchema.parse(invalidData)).toThrow(/cannot exceed 30 days/);
+    });
+
+    it("should validate minimumCancellationNotice based on event type", () => {
+      // Custom validation based on event type
+      const validateByEventType = (eventType: string, cancellationNotice: number): boolean => {
+        switch (eventType) {
+          case "instant":
+            return cancellationNotice === 0;
+          case "standard":
+            return cancellationNotice >= 60 && cancellationNotice <= 1440;
+          case "premium":
+            return cancellationNotice >= 1440;
+          default:
+            return cancellationNotice >= 0;
+        }
+      };
+
+      expect(validateByEventType("instant", 0)).toBe(true);
+      expect(validateByEventType("instant", 60)).toBe(false);
+      
+      expect(validateByEventType("standard", 360)).toBe(true);
+      expect(validateByEventType("standard", 30)).toBe(false);
+      
+      expect(validateByEventType("premium", 2880)).toBe(true);
+      expect(validateByEventType("premium", 720)).toBe(false);
+    });
+
+    it("should validate minimumCancellationNotice with refinements", () => {
+      // Schema with custom refinements
+      const RefinedEventTypeSchema = EventTypeSchema.refine(
+        (data) => {
+          // Custom rule: if event is longer than 2 hours, require at least 6 hours notice
+          if (data.length > 120) {
+            return data.minimumCancellationNotice >= 360;
+          }
+          return true;
+        },
+        {
+          message: "Events longer than 2 hours require at least 6 hours cancellation notice",
+        }
+      );
+
+      // Valid: short event with any notice
+      const validShortEvent = {
+        title: "Short Event",
+        slug: "short-event",
+        length: 60,
+        minimumCancellationNotice: 60,
+      };
+      expect(() => RefinedEventTypeSchema.parse(validShortEvent)).not.toThrow();
+
+      // Valid: long event with sufficient notice
+      const validLongEvent = {
+        title: "Long Event",
+        slug: "long-event",
+        length: 180,
+        minimumCancellationNotice: 720,
+      };
+      expect(() => RefinedEventTypeSchema.parse(validLongEvent)).not.toThrow();
+
+      // Invalid: long event with insufficient notice
+      const invalidLongEvent = {
+        title: "Long Event",
+        slug: "long-event",
+        length: 180,
+        minimumCancellationNotice: 120,
+      };
+      expect(() => RefinedEventTypeSchema.parse(invalidLongEvent)).toThrow(/at least 6 hours/);
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/prisma/schema.prisma b/packages/prisma/schema.prisma
index 14c2e73086f21d..9700065656daff 100644
--- a/packages/prisma/schema.prisma
+++ b/packages/prisma/schema.prisma
@@ -145,6 +145,8 @@ model EventType {
   hideCalendarEventDetails                 Boolean                   @default(false)
   /// @zod.min(0)
   minimumBookingNotice                     Int                       @default(120)
+  /// @zod.min(0)
+  minimumCancellationNotice                Int                       @default(0)
   beforeEventBuffer                        Int                       @default(0)
   afterEventBuffer                         Int                       @default(0)
   seatsPerTimeSlot                         Int?
diff --git a/packages/trpc/server/routers/viewer/bookings/requestReschedule.handler.test.ts b/packages/trpc/server/routers/viewer/bookings/requestReschedule.handler.test.ts
new file mode 100644
index 00000000000000..b9c5615b6c57bc
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/bookings/requestReschedule.handler.test.ts
@@ -0,0 +1,802 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { TRPCError } from "@trpc/server";
+import dayjs from "@calcom/dayjs";
+import { sendRequestRescheduleEmailAndSMS } from "@calcom/emails";
+import { deleteWebhookScheduledTriggers } from "@calcom/features/webhooks/lib/scheduleTrigger";
+import { getTranslation } from "@calcom/lib/server/i18n";
+import { WorkflowRepository } from "@calcom/lib/server/repository/workflow";
+import { BookingWebhookFactory } from "@calcom/lib/server/service/BookingWebhookFactory";
+import { deleteMeeting } from "@calcom/lib/videoClient";
+import { prisma } from "@calcom/prisma";
+import { BookingStatus } from "@calcom/prisma/enums";
+import { requestRescheduleHandler } from "./requestReschedule.handler";
+
+// Mock all external dependencies
+vi.mock("@calcom/prisma", () => ({
+  prisma: {
+    booking: {
+      findUniqueOrThrow: vi.fn(),
+      update: vi.fn(),
+    },
+    user: {
+      findUniqueOrThrow: vi.fn(),
+    },
+    eventType: {
+      findUniqueOrThrow: vi.fn(),
+    },
+    attendee: {
+      update: vi.fn(),
+    },
+  },
+}));
+
+vi.mock("@calcom/emails", () => ({
+  sendRequestRescheduleEmailAndSMS: vi.fn(),
+}));
+
+vi.mock("@calcom/features/webhooks/lib/scheduleTrigger", () => ({
+  deleteWebhookScheduledTriggers: vi.fn(),
+}));
+
+vi.mock("@calcom/lib/server/i18n", () => ({
+  getTranslation: vi.fn().mockResolvedValue((key: string) => key),
+}));
+
+vi.mock("@calcom/lib/server/repository/workflow", () => ({
+  WorkflowRepository: {
+    deleteAllWorkflowReminders: vi.fn(),
+  },
+}));
+
+vi.mock("@calcom/lib/server/service/BookingWebhookFactory", () => ({
+  BookingWebhookFactory: vi.fn().mockImplementation(() => ({
+    buildEventPayloadFromBooking: vi.fn().mockResolvedValue({}),
+    create: vi.fn(),
+  })),
+}));
+
+vi.mock("@calcom/lib/videoClient", () => ({
+  deleteMeeting: vi.fn().mockResolvedValue({ error: null }),
+}));
+
+vi.mock("@calcom/lib/server/getUsersCredentials", () => ({
+  getUsersCredentialsIncludeServiceAccountKey: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock("@calcom/lib/delegationCredential/server", () => ({
+  getDelegationCredentialOrRegularCredential: vi.fn(),
+}));
+
+vi.mock("@calcom/app-store/_utils/getCalendar", () => ({
+  getCalendar: vi.fn(),
+}));
+
+vi.mock("@calcom/lib/getBookerUrl/server", () => ({
+  getBookerBaseUrl: vi.fn().mockResolvedValue("https://cal.com"),
+}));
+
+vi.mock("@calcom/lib/getOrgIdFromMemberOrTeamId", () => ({
+  default: vi.fn().mockResolvedValue(null),
+}));
+
+vi.mock("@calcom/lib/getTeamIdFromEventType", () => ({
+  getTeamIdFromEventType: vi.fn().mockResolvedValue(null),
+}));
+
+describe("requestRescheduleHandler - API Validation", () => {
+  const mockUser = {
+    id: 1,
+    email: "user@example.com",
+    locale: "en",
+    name: "Test User",
+    username: "testuser",
+    timeZone: "America/New_York",
+    profile: {
+      organizationId: null,
+    },
+  };
+
+  const createMockBooking = (overrides = {}) => ({
+    id: 1,
+    uid: "booking-uid",
+    userId: 1,
+    title: "Test Meeting",
+    description: "Test Description",
+    startTime: dayjs().add(24, "hours").toDate(),
+    endTime: dayjs().add(24, "hours").add(30, "minutes").toDate(),
+    eventTypeId: 1,
+    userPrimaryEmail: "user@example.com",
+    eventType: {
+      id: 1,
+      teamId: null,
+      team: null,
+      minimumCancellationNotice: 0,
+      bookingFields: null,
+      hideOrganizerEmail: false,
+      parentId: null,
+    },
+    location: "Zoom",
+    attendees: [
+      {
+        id: 1,
+        email: "attendee@example.com",
+        name: "Attendee Name",
+        locale: "en",
+        timeZone: "America/New_York",
+        phoneNumber: null,
+      },
+    ],
+    references: [],
+    customInputs: {},
+    dynamicEventSlugRef: null,
+    dynamicGroupSlugRef: null,
+    destinationCalendar: null,
+    smsReminderNumber: null,
+    workflowReminders: [],
+    responses: {},
+    iCalUID: "ical-uid",
+    ...overrides,
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2024-01-01T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe("API returns 403 with minimum cancellation notice validation", () => {
+    it("should return 403 when reschedule attempt is within minimum notice period", async () => {
+      const bookingWithMinNotice = createMockBooking({
+        startTime: dayjs().add(6, "hours").toDate(), // Booking in 6 hours
+        endTime: dayjs().add(6, "hours").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 720, // 12 hours minimum notice
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(bookingWithMinNotice as any);
+
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "booking-uid",
+            rescheduleReason: "Need to reschedule",
+          },
+        })
+      ).rejects.toThrow(TRPCError);
+
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "booking-uid",
+            rescheduleReason: "Need to reschedule",
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "FORBIDDEN",
+        message: "Cannot reschedule within 12 hours of event start",
+      });
+
+      // Verify no database updates occurred
+      expect(prisma.booking.update).not.toHaveBeenCalled();
+      expect(sendRequestRescheduleEmailAndSMS).not.toHaveBeenCalled();
+      expect(deleteWebhookScheduledTriggers).not.toHaveBeenCalled();
+      expect(WorkflowRepository.deleteAllWorkflowReminders).not.toHaveBeenCalled();
+    });
+
+    it("should return 403 with proper error message for various time periods", async () => {
+      const testCases = [
+        {
+          minutesNotice: 30,
+          minutesUntilEvent: 15,
+          expectedMessage: "Cannot reschedule within 30 minutes of event start",
+        },
+        {
+          minutesNotice: 60,
+          minutesUntilEvent: 45,
+          expectedMessage: "Cannot reschedule within 1 hour of event start",
+        },
+        {
+          minutesNotice: 90,
+          minutesUntilEvent: 60,
+          expectedMessage: "Cannot reschedule within 1 hour and 30 minutes of event start",
+        },
+        {
+          minutesNotice: 120,
+          minutesUntilEvent: 100,
+          expectedMessage: "Cannot reschedule within 2 hours of event start",
+        },
+        {
+          minutesNotice: 1440,
+          minutesUntilEvent: 720,
+          expectedMessage: "Cannot reschedule within 24 hours of event start",
+        },
+        {
+          minutesNotice: 2880,
+          minutesUntilEvent: 1440,
+          expectedMessage: "Cannot reschedule within 48 hours of event start",
+        },
+        {
+          minutesNotice: 4320,
+          minutesUntilEvent: 2880,
+          expectedMessage: "Cannot reschedule within 72 hours of event start",
+        },
+      ];
+
+      for (const testCase of testCases) {
+        const booking = createMockBooking({
+          startTime: dayjs().add(testCase.minutesUntilEvent, "minutes").toDate(),
+          endTime: dayjs().add(testCase.minutesUntilEvent + 30, "minutes").toDate(),
+          eventType: {
+            id: 1,
+            teamId: null,
+            team: null,
+            minimumCancellationNotice: testCase.minutesNotice,
+            bookingFields: null,
+            hideOrganizerEmail: false,
+            parentId: null,
+          },
+        });
+
+        vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+
+        await expect(
+          requestRescheduleHandler({
+            ctx: { user: mockUser as any },
+            input: {
+              bookingId: "booking-uid",
+              rescheduleReason: "Need to reschedule",
+            },
+          })
+        ).rejects.toMatchObject({
+          code: "FORBIDDEN",
+          message: testCase.expectedMessage,
+        });
+      }
+    });
+
+    it("should handle edge case: reschedule attempt exactly at minimum notice boundary", async () => {
+      const minutesNotice = 120; // 2 hours
+      const booking = createMockBooking({
+        startTime: dayjs().add(minutesNotice, "minutes").toDate(), // Exactly at boundary
+        endTime: dayjs().add(minutesNotice + 30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: minutesNotice,
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+      vi.mocked(prisma.eventType.findUniqueOrThrow).mockResolvedValue({
+        title: "Event Type",
+        schedulingType: null,
+        recurringEvent: null,
+      } as any);
+
+      // Should allow reschedule when exactly at boundary (not within)
+      const result = await requestRescheduleHandler({
+        ctx: { user: mockUser as any },
+        input: {
+          bookingId: "booking-uid",
+          rescheduleReason: "Need to reschedule",
+        },
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+      expect(prisma.booking.update).toHaveBeenCalled();
+    });
+
+    it("should calculate time correctly across time zones", async () => {
+      // Set system time to UTC
+      vi.setSystemTime(new Date("2024-01-01T00:00:00Z"));
+      
+      const booking = createMockBooking({
+        // Event is at 3 AM UTC (3 hours from now)
+        startTime: new Date("2024-01-01T03:00:00Z"),
+        endTime: new Date("2024-01-01T03:30:00Z"),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 240, // 4 hours minimum notice
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+
+      // Should reject because 3 hours < 4 hours minimum notice
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "booking-uid",
+            rescheduleReason: "Need to reschedule",
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "FORBIDDEN",
+        message: "Cannot reschedule within 4 hours of event start",
+      });
+    });
+
+    it("should allow reschedule when no minimum notice is configured", async () => {
+      const booking = createMockBooking({
+        startTime: dayjs().add(5, "minutes").toDate(), // Very soon
+        endTime: dayjs().add(35, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 0, // No minimum notice
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+      vi.mocked(prisma.eventType.findUniqueOrThrow).mockResolvedValue({
+        title: "Event Type",
+        schedulingType: null,
+        recurringEvent: null,
+      } as any);
+
+      const result = await requestRescheduleHandler({
+        ctx: { user: mockUser as any },
+        input: {
+          bookingId: "booking-uid",
+          rescheduleReason: "Last minute change",
+        },
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+      expect(prisma.booking.update).toHaveBeenCalled();
+    });
+
+    it("should handle undefined minimumCancellationNotice gracefully", async () => {
+      const booking = createMockBooking({
+        startTime: dayjs().add(5, "minutes").toDate(),
+        endTime: dayjs().add(35, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: undefined, // Undefined
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+      vi.mocked(prisma.eventType.findUniqueOrThrow).mockResolvedValue({
+        title: "Event Type",
+        schedulingType: null,
+        recurringEvent: null,
+      } as any);
+
+      const result = await requestRescheduleHandler({
+        ctx: { user: mockUser as any },
+        input: {
+          bookingId: "booking-uid",
+          rescheduleReason: "Last minute change",
+        },
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+    });
+
+    it("should handle null eventType gracefully", async () => {
+      const booking = createMockBooking({
+        startTime: dayjs().add(5, "minutes").toDate(),
+        endTime: dayjs().add(35, "minutes").toDate(),
+        eventType: null,
+        dynamicEventSlugRef: "dynamic-event", // Has dynamic event instead
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+
+      const result = await requestRescheduleHandler({
+        ctx: { user: mockUser as any },
+        input: {
+          bookingId: "booking-uid",
+          rescheduleReason: "Need to reschedule",
+        },
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+    });
+
+    it("should enforce minimum notice for team bookings", async () => {
+      const teamBooking = createMockBooking({
+        startTime: dayjs().add(2, "hours").toDate(),
+        endTime: dayjs().add(2, "hours").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: 123,
+          team: {
+            id: 123,
+            name: "Test Team",
+            parentId: null,
+          },
+          minimumCancellationNotice: 180, // 3 hours
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(teamBooking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({
+        teams: [{ teamId: 123 }], // User is a team member
+      } as any);
+
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "booking-uid",
+            rescheduleReason: "Team reschedule",
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "FORBIDDEN",
+        message: "Cannot reschedule within 3 hours of event start",
+      });
+    });
+
+    it("should check minimum notice before checking team membership", async () => {
+      const teamBooking = createMockBooking({
+        startTime: dayjs().add(1, "hour").toDate(),
+        endTime: dayjs().add(1, "hour").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: 123,
+          team: {
+            id: 123,
+            name: "Test Team",
+            parentId: null,
+          },
+          minimumCancellationNotice: 120, // 2 hours
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(teamBooking as any);
+      
+      // User is NOT a team member, but should get minimum notice error first
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({
+        teams: [{ teamId: 456 }], // Different team
+      } as any);
+
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "booking-uid",
+            rescheduleReason: "Need to reschedule",
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "FORBIDDEN",
+        message: "Cannot reschedule within 2 hours of event start",
+      });
+
+      // Verify user.findUniqueOrThrow was never called (minimum notice check happens first)
+      expect(prisma.user.findUniqueOrThrow).not.toHaveBeenCalled();
+    });
+
+    it("should handle past bookings with minimum notice", async () => {
+      const pastBooking = createMockBooking({
+        startTime: dayjs().subtract(1, "hour").toDate(), // Already past
+        endTime: dayjs().subtract(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 60,
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(pastBooking as any);
+
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "booking-uid",
+            rescheduleReason: "Trying to reschedule past event",
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "FORBIDDEN",
+        message: "Cannot reschedule within 1 hour of event start",
+      });
+    });
+
+    it("should handle very large minimum notice periods", async () => {
+      const booking = createMockBooking({
+        startTime: dayjs().add(7, "days").toDate(),
+        endTime: dayjs().add(7, "days").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 20160, // 14 days (336 hours)
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "booking-uid",
+            rescheduleReason: "Need to reschedule",
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "FORBIDDEN",
+        message: "Cannot reschedule within 336 hours of event start",
+      });
+    });
+
+    it("should handle plural forms correctly in error messages", async () => {
+      const testCases = [
+        { minutes: 1, expected: "1 minute" },
+        { minutes: 2, expected: "2 minutes" },
+        { minutes: 59, expected: "59 minutes" },
+        { minutes: 61, expected: "1 hour and 1 minute" },
+        { minutes: 62, expected: "1 hour and 2 minutes" },
+        { minutes: 119, expected: "1 hour and 59 minutes" },
+        { minutes: 121, expected: "2 hours and 1 minute" },
+        { minutes: 122, expected: "2 hours and 2 minutes" },
+      ];
+
+      for (const testCase of testCases) {
+        const booking = createMockBooking({
+          startTime: dayjs().add(testCase.minutes - 1, "minutes").toDate(),
+          endTime: dayjs().add(testCase.minutes + 29, "minutes").toDate(),
+          eventType: {
+            id: 1,
+            teamId: null,
+            team: null,
+            minimumCancellationNotice: testCase.minutes,
+            bookingFields: null,
+            hideOrganizerEmail: false,
+            parentId: null,
+          },
+        });
+
+        vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+
+        await expect(
+          requestRescheduleHandler({
+            ctx: { user: mockUser as any },
+            input: {
+              bookingId: "booking-uid",
+              rescheduleReason: "Testing plural forms",
+            },
+          })
+        ).rejects.toMatchObject({
+          code: "FORBIDDEN",
+          message: `Cannot reschedule within ${testCase.expected} of event start`,
+        });
+      }
+    });
+  });
+
+  describe("Integration with other booking validations", () => {
+    it("should validate minimum notice before other booking validations", async () => {
+      const booking = createMockBooking({
+        userId: null, // This would normally cause "doesn't have an owner" error
+        startTime: dayjs().add(1, "hour").toDate(),
+        endTime: dayjs().add(1, "hour").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 120, // 2 hours
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+
+      // Should get minimum notice error, not the "doesn't have an owner" error
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "booking-uid",
+            rescheduleReason: "Testing validation order",
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "FORBIDDEN",
+        message: "Cannot reschedule within 2 hours of event start",
+      });
+    });
+
+    it("should handle cancelled bookings correctly", async () => {
+      // This should be caught by the findUniqueOrThrow query's WHERE clause
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockRejectedValue(
+        new Error("No Booking found")
+      );
+
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "cancelled-booking-uid",
+            rescheduleReason: "Trying to reschedule cancelled booking",
+          },
+        })
+      ).rejects.toThrow("No Booking found");
+    });
+
+    it("should handle rejected bookings correctly", async () => {
+      // This should be caught by the findUniqueOrThrow query's WHERE clause
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockRejectedValue(
+        new Error("No Booking found")
+      );
+
+      await expect(
+        requestRescheduleHandler({
+          ctx: { user: mockUser as any },
+          input: {
+            bookingId: "rejected-booking-uid",
+            rescheduleReason: "Trying to reschedule rejected booking",
+          },
+        })
+      ).rejects.toThrow("No Booking found");
+    });
+  });
+
+  describe("Successful reschedule scenarios", () => {
+    it("should successfully reschedule when outside minimum notice period", async () => {
+      const booking = createMockBooking({
+        startTime: dayjs().add(25, "hours").toDate(),
+        endTime: dayjs().add(25, "hours").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 1440, // 24 hours
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+      vi.mocked(prisma.eventType.findUniqueOrThrow).mockResolvedValue({
+        title: "Event Type",
+        schedulingType: null,
+        recurringEvent: null,
+      } as any);
+
+      const result = await requestRescheduleHandler({
+        ctx: { user: mockUser as any },
+        input: {
+          bookingId: "booking-uid",
+          rescheduleReason: "Valid reschedule request",
+        },
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+      
+      // Verify all expected side effects occurred
+      expect(prisma.booking.update).toHaveBeenCalledWith({
+        where: { id: 1 },
+        data: {
+          rescheduled: true,
+          cancellationReason: "Valid reschedule request",
+          status: BookingStatus.CANCELLED,
+          updatedAt: expect.any(String),
+          cancelledBy: "user@example.com",
+        },
+      });
+      
+      expect(deleteWebhookScheduledTriggers).toHaveBeenCalled();
+      expect(WorkflowRepository.deleteAllWorkflowReminders).toHaveBeenCalled();
+      expect(sendRequestRescheduleEmailAndSMS).toHaveBeenCalled();
+    });
+
+    it("should reschedule successfully with seat-based events", async () => {
+      const seatBooking = createMockBooking({
+        startTime: dayjs().add(48, "hours").toDate(),
+        endTime: dayjs().add(48, "hours").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 1440, // 24 hours
+          seatsPerTimeSlot: 10,
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+        attendees: [
+          {
+            id: 1,
+            email: "user@example.com", // Current user's email
+            name: "Current User",
+            locale: "en",
+            timeZone: "America/New_York",
+            phoneNumber: null,
+          },
+          {
+            id: 2,
+            email: "newattendee@example.com",
+            name: "New Attendee",
+            locale: "en",
+            timeZone: "America/New_York",
+            phoneNumber: null,
+          },
+        ],
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(seatBooking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+      vi.mocked(prisma.eventType.findUniqueOrThrow).mockResolvedValue({
+        title: "Event Type",
+        schedulingType: null,
+        recurringEvent: null,
+      } as any);
+
+      const result = await requestRescheduleHandler({
+        ctx: { user: mockUser as any },
+        input: {
+          bookingId: "booking-uid",
+          rescheduleReason: "Need to reschedule",
+        },
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+      expect(prisma.attendee.update).toHaveBeenCalledWith({
+        where: { id: 1 },
+        data: {
+          name: "New Attendee",
+          email: "newattendee@example.com",
+        },
+      });
+    });
+  });
+});
\ No newline at end of file
diff --git a/packages/trpc/server/routers/viewer/bookings/requestReschedule.handler.ts b/packages/trpc/server/routers/viewer/bookings/requestReschedule.handler.ts
index 9911b5e6f48a62..175e4a466f5e0e 100644
--- a/packages/trpc/server/routers/viewer/bookings/requestReschedule.handler.ts
+++ b/packages/trpc/server/routers/viewer/bookings/requestReschedule.handler.ts
@@ -96,6 +96,33 @@ export const requestRescheduleHandler = async ({ ctx, input }: RequestReschedule
     throw new TRPCError({ code: "FORBIDDEN", message: "EventType not found for current booking." });
   }
 
+  // Check minimum cancellation notice for reschedule
+  const minimumCancellationNotice = bookingToReschedule.eventType?.minimumCancellationNotice || 0;
+  if (minimumCancellationNotice > 0) {
+    const now = dayjs();
+    const bookingStart = dayjs(bookingToReschedule.startTime);
+    const minutesUntilEvent = bookingStart.diff(now, 'minute');
+    
+    if (minutesUntilEvent < minimumCancellationNotice) {
+      const hours = Math.floor(minimumCancellationNotice / 60);
+      const minutes = minimumCancellationNotice % 60;
+      let timeString = '';
+      
+      if (hours > 0 && minutes > 0) {
+        timeString = `${hours} hour${hours > 1 ? 's' : ''} and ${minutes} minute${minutes > 1 ? 's' : ''}`;
+      } else if (hours > 0) {
+        timeString = `${hours} hour${hours > 1 ? 's' : ''}`;
+      } else {
+        timeString = `${minutes} minute${minutes > 1 ? 's' : ''}`;
+      }
+      
+      throw new TRPCError({
+        code: "FORBIDDEN",
+        message: `Cannot reschedule within ${timeString} of event start`,
+      });
+    }
+  }
+
   const bookingBelongsToTeam = !!bookingToReschedule.eventType?.teamId;
 
   const userTeams = await prisma.user.findUniqueOrThrow({
@@ -125,9 +152,9 @@ export const requestRescheduleHandler = async ({ ctx, input }: RequestReschedule
 
   if (!bookingToReschedule) return;
 
-  let event: Partial<EventType> = {};
+  let eventTypeData: Partial<EventType> = {};
   if (bookingToReschedule.eventTypeId) {
-    event = await prisma.eventType.findUniqueOrThrow({
+    eventTypeData = await prisma.eventType.findUniqueOrThrow({
       select: {
         title: true,
         schedulingType: true,
@@ -192,7 +219,7 @@ export const requestRescheduleHandler = async ({ ctx, input }: RequestReschedule
     bookerUrl: eventType?.team
       ? await getBookerBaseUrl(eventType.team.parentId)
       : await getBookerBaseUrl(user.profile?.organizationId ?? null),
-    type: event && event.slug ? event.slug : bookingToReschedule.title,
+    type: eventTypeData && eventTypeData.slug ? eventTypeData.slug : bookingToReschedule.title,
     startTime: bookingToReschedule.startTime.toISOString(),
     endTime: bookingToReschedule.endTime.toISOString(),
     hideOrganizerEmail: eventType?.hideOrganizerEmail,
@@ -202,144 +229,131 @@ export const requestRescheduleHandler = async ({ ctx, input }: RequestReschedule
       tAttendees
     ),
     organizer,
+  });
+  builder.setLocation(bookingToReschedule.location);
+  builder.setUId(bookingToReschedule.uid);
+  builder.setDestinationCalendar(bookingToReschedule.destinationCalendar);
+  builder.setRecurringEvent(eventTypeData.recurringEvent);
+  builder.setDescription(bookingToReschedule.description);
+  builder.setResponses({
+    ...getCalEventResponses({
+      booking: bookingToReschedule,
+      bookingFields: bookingToReschedule.eventType?.bookingFields || null,
+    }),
+    // TODO: We should send responses from the current booking, check this comment https://github.com/calcom/cal.com/issues/9852#issuecomment-1633219613
+    //  (bookingToReschedule.responses as Prisma.JsonObject) || null
+  });
+  builder.setCalendarEvent({
     iCalUID: bookingToReschedule.iCalUID,
-    customReplyToEmail: bookingToReschedule.eventType?.customReplyToEmail,
-    team: !!bookingToReschedule.eventType?.team
-      ? {
-          name: bookingToReschedule.eventType.team.name,
-          id: bookingToReschedule.eventType.team.id,
-          members: [],
-        }
-      : undefined,
   });
-
   const director = new CalendarEventDirector();
-  director.setBuilder(builder);
-  director.setExistingBooking(bookingToReschedule);
-  cancellationReason && director.setCancellationReason(cancellationReason);
-  if (Object.keys(event).length) {
-    // Request Reschedule flow first cancels the booking and then reschedule email is sent. So, we need to allow reschedule for cancelled booking
-    await director.buildForRescheduleEmail({ allowRescheduleForCancelledBooking: true });
-  } else {
-    await director.buildWithoutEventTypeForRescheduleEmail();
-  }
-
-  // Handling calendar and videos cancellation
-  // This can set previous time as available, until virtual calendar is done
-  const credentials = await getUsersCredentialsIncludeServiceAccountKey(user);
-  const credentialsMap = new Map();
-  credentials.forEach((credential) => {
-    credentialsMap.set(credential.type, credential);
-  });
-  const bookingRefsFiltered: BookingReference[] = bookingToReschedule.references.filter((ref) =>
-    credentialsMap.has(ref.type)
-  );
+  const calendarEvent = director.buildForRescheduleEmail(builder);
 
-  // FIXME: error-handling
-  await Promise.allSettled(
-    bookingRefsFiltered.map(async (bookingRef) => {
-      if (!bookingRef.uid) return;
+  const handleSeats = async () => {
+    if (bookingToReschedule.eventType?.seatsPerTimeSlot) {
+      const seatReference = bookingToReschedule.attendees.find((attendee) => attendee.email === user.email);
 
-      if (bookingRef.type.endsWith("_calendar")) {
-        const calendar = await getCalendar(
-          getDelegationCredentialOrRegularCredential({
-            credentials,
-            id: {
-              credentialId: bookingRef?.credentialId,
-              delegationCredentialId: bookingRef?.delegationCredentialId,
-            },
-          })
-        );
-        return calendar?.deleteEvent(bookingRef.uid, builder.calendarEvent, bookingRef.externalCalendarId);
-      } else if (bookingRef.type.endsWith("_video")) {
-        return deleteMeeting(
-          getDelegationCredentialOrRegularCredential({
-            credentials,
-            id: {
-              credentialId: bookingRef?.credentialId,
-              delegationCredentialId: bookingRef?.delegationCredentialId,
-            },
-          }),
-          bookingRef.uid
-        );
+      //if it's a reschedule the the first attendee is the one rescheduling
+      if (seatReference && bookingToReschedule.attendees[0]) {
+        await prisma.attendee.update({
+          where: {
+            id: seatReference.id,
+          },
+          data: {
+            name: bookingToReschedule.attendees[0].name,
+            email: bookingToReschedule.attendees[0].email,
+          },
+        });
       }
-    })
-  );
+    }
+  };
 
-  log.debug("builder.calendarEvent", safeStringify(builder.calendarEvent));
-  // Send emails
-  await sendRequestRescheduleEmailAndSMS(
-    builder.calendarEvent,
-    {
-      rescheduleLink: builder.rescheduleLink,
-    },
-    eventType?.metadata as EventTypeMetadata
-  );
+  await handleSeats();
 
-  const calEventResponses = getCalEventResponses({
-    booking: bookingToReschedule,
-    bookingFields: bookingToReschedule.eventType?.bookingFields ?? null,
-  });
-
-  const webhookFactory = new BookingWebhookFactory();
-  const payload = webhookFactory.createCancelledEventPayload({
-    bookingId: bookingToReschedule.id,
-    title: bookingToReschedule.title,
-    eventSlug: event.slug ?? null,
-    description: bookingToReschedule.description,
-    customInputs: bookingToReschedule.customInputs,
-    responses: calEventResponses.responses,
-    userFieldsResponses: calEventResponses.userFieldsResponses,
-    startTime: bookingToReschedule.startTime ? dayjs(bookingToReschedule.startTime).format() : "",
-    endTime: bookingToReschedule.endTime ? dayjs(bookingToReschedule.endTime).format() : "",
-    organizer,
-    attendees: usersToPeopleType(
-      // username field doesn't exists on attendee but could be in the future
-      bookingToReschedule.attendees as unknown as PersonAttendeeCommonFields[],
-      tAttendees
-    ),
-    uid: bookingToReschedule.uid,
-    location: bookingToReschedule.location,
-    destinationCalendar: bookingToReschedule.destinationCalendar,
-    cancellationReason: `Please reschedule. ${cancellationReason}`, // TODO::Add i18-next for this
-    iCalUID: bookingToReschedule.iCalUID,
-    ...(bookingToReschedule.smsReminderNumber && {
-      smsReminderNumber: bookingToReschedule.smsReminderNumber,
-    }),
-    cancelledBy: user.email,
-  });
-
-  // Send webhook
-  const eventTrigger: WebhookTriggerEvents = "BOOKING_CANCELLED";
+  const copyEvent = cloneDeep(calendarEvent);
 
   const teamId = await getTeamIdFromEventType({
     eventType: {
-      team: { id: bookingToReschedule.eventType?.teamId ?? null },
-      parentId: bookingToReschedule.eventType?.parentId ?? null,
+      team: { id: bookingToReschedule.eventType?.team?.id ?? null },
+      parentId: bookingToReschedule?.eventType?.parentId ?? null,
     },
   });
-
   const triggerForUser = !teamId || (teamId && bookingToReschedule.eventType?.parentId);
-  const userId = triggerForUser ? bookingToReschedule.userId : null;
-  const orgId = await getOrgIdFromMemberOrTeamId({ memberId: userId, teamId });
+  const organizerUserId = triggerForUser ? bookingToReschedule.userId : null;
 
-  // Send Webhook call if hooked to BOOKING.CANCELLED
-  const subscriberOptions = {
-    userId,
-    eventTypeId: bookingToReschedule.eventTypeId as number,
-    triggerEvent: eventTrigger,
-    teamId: teamId ? [teamId] : null,
-    orgId,
-  };
-  const webhooks = await getWebhooks(subscriberOptions);
+  const eventTrigger: WebhookTriggerEvents = "BOOKING_CANCELLED";
+  const bookingWebhookFactory = new BookingWebhookFactory({
+    organizerUserId,
+    teamId,
+    orgId: await getOrgIdFromMemberOrTeamId({ memberId: organizerUserId, teamId }),
+    eventTypeId: bookingToReschedule.eventTypeId,
+    eventTrigger,
+  });
+  const eventPayload = await bookingWebhookFactory.buildEventPayloadFromBooking(bookingToReschedule);
+
+  // Send Webhook
+  await bookingWebhookFactory.create(eventPayload);
+
+  //Send Email to organizer
+  await sendRequestRescheduleEmailAndSMS(copyEvent, {
+    rescheduleLink: organizer.language.translate("reschedule_link_text"),
+  });
 
-  const promises = webhooks.map((webhook) =>
-    sendPayload(webhook.secret, eventTrigger, new Date().toISOString(), webhook, payload).catch((e) => {
-      log.error(
-        `Error executing webhook for event: ${eventTrigger}, URL: ${webhook.subscriberUrl}, bookingId: ${payload.bookingId}, bookingUid: ${payload.uid}`,
-        safeStringify(e)
-      );
-    })
-  );
-  await Promise.all(promises);
+  const credentials = await getUsersCredentialsIncludeServiceAccountKey({
+    userId: user.id,
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    //@ts-ignore
+    credentialIds: bookingToReschedule.references.map((r) => r.credentialId),
+  });
+  const awaitedReferences: BookingReference[] = [];
+  for (const reference of bookingToReschedule.references) {
+    if (!reference.credentialId) continue;
+    const credential = await getDelegationCredentialOrRegularCredential({
+      delegatedCredentialId: reference.credentialId,
+      credentials,
+      userId: user.id,
+    });
+    // if rescheduleUid !== bookingToReschedule.uid, this is a new booking
+    // then we just update the booking with the new references
+    const credentialCalendar = await getCalendar(credential);
+    const uidToDelete = reference.uid;
+    const { error } = await deleteMeeting({
+      credentialCalendar,
+      event: calendarEvent,
+      bookingRef: {
+        ...reference,
+        uid: uidToDelete,
+      },
+    });
+    if (!error) {
+      awaitedReferences.push(reference);
+    }
+  }
+  return { message: "Booking rescheduled successfully" };
 };
+
+function cloneDeep<T>(obj: T): T {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+
+  if (obj instanceof Date) {
+    return new Date(obj.getTime()) as T;
+  }
+
+  if (Array.isArray(obj)) {
+    const arrCopy = [] as any[];
+    obj.forEach((item) => {
+      arrCopy.push(cloneDeep(item));
+    });
+    return arrCopy as T;
+  }
+
+  const clonedObj = {} as T;
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      (clonedObj as any)[key] = cloneDeep(obj[key]);
+    }
+  }
+  return clonedObj;
+}
\ No newline at end of file
diff --git a/packages/trpc/server/routers/viewer/bookings/requestReschedule.integration.test.ts b/packages/trpc/server/routers/viewer/bookings/requestReschedule.integration.test.ts
new file mode 100644
index 00000000000000..d28ba859e13c8a
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/bookings/requestReschedule.integration.test.ts
@@ -0,0 +1,637 @@
+import { describe, expect, it, beforeEach, afterEach, vi } from "vitest";
+import { TRPCError } from "@trpc/server";
+import { createCallerFactory } from "@calcom/trpc/server";
+import { appRouter } from "@calcom/trpc/server/routers/_app";
+import dayjs from "@calcom/dayjs";
+import { prisma } from "@calcom/prisma";
+import { BookingStatus } from "@calcom/prisma/enums";
+
+// Mock prisma to avoid database calls
+vi.mock("@calcom/prisma", () => ({
+  prisma: {
+    booking: {
+      findUniqueOrThrow: vi.fn(),
+      update: vi.fn(),
+    },
+    user: {
+      findUniqueOrThrow: vi.fn(),
+    },
+    eventType: {
+      findUniqueOrThrow: vi.fn(),
+    },
+    attendee: {
+      update: vi.fn(),
+    },
+  },
+}));
+
+// Mock email service
+vi.mock("@calcom/emails", () => ({
+  sendRequestRescheduleEmailAndSMS: vi.fn(),
+}));
+
+// Mock webhook service
+vi.mock("@calcom/features/webhooks/lib/scheduleTrigger", () => ({
+  deleteWebhookScheduledTriggers: vi.fn(),
+}));
+
+// Mock workflow repository
+vi.mock("@calcom/lib/server/repository/workflow", () => ({
+  WorkflowRepository: {
+    deleteAllWorkflowReminders: vi.fn(),
+  },
+}));
+
+// Mock booking webhook factory
+vi.mock("@calcom/lib/server/service/BookingWebhookFactory", () => ({
+  BookingWebhookFactory: vi.fn().mockImplementation(() => ({
+    buildEventPayloadFromBooking: vi.fn().mockResolvedValue({}),
+    create: vi.fn(),
+  })),
+}));
+
+// Mock other services
+vi.mock("@calcom/lib/videoClient", () => ({
+  deleteMeeting: vi.fn().mockResolvedValue({ error: null }),
+}));
+
+vi.mock("@calcom/lib/server/getUsersCredentials", () => ({
+  getUsersCredentialsIncludeServiceAccountKey: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock("@calcom/lib/delegationCredential/server", () => ({
+  getDelegationCredentialOrRegularCredential: vi.fn(),
+}));
+
+vi.mock("@calcom/app-store/_utils/getCalendar", () => ({
+  getCalendar: vi.fn(),
+}));
+
+vi.mock("@calcom/lib/getBookerUrl/server", () => ({
+  getBookerBaseUrl: vi.fn().mockResolvedValue("https://cal.com"),
+}));
+
+vi.mock("@calcom/lib/server/i18n", () => ({
+  getTranslation: vi.fn().mockResolvedValue((key: string) => key),
+}));
+
+vi.mock("@calcom/lib/getOrgIdFromMemberOrTeamId", () => ({
+  default: vi.fn().mockResolvedValue(null),
+}));
+
+vi.mock("@calcom/lib/getTeamIdFromEventType", () => ({
+  getTeamIdFromEventType: vi.fn().mockResolvedValue(null),
+}));
+
+describe("Request Reschedule API Integration Tests", () => {
+  const createCaller = createCallerFactory(appRouter);
+  
+  const mockUser = {
+    id: 1,
+    email: "user@example.com",
+    username: "testuser",
+    name: "Test User",
+    locale: "en",
+    timeZone: "America/New_York",
+    profile: {
+      organizationId: null,
+    },
+  };
+
+  const createMockContext = (user = mockUser) => ({
+    user,
+    session: {
+      user,
+      expires: dayjs().add(1, "day").toISOString(),
+    },
+    prisma,
+  });
+
+  const createMockBooking = (overrides = {}) => ({
+    id: 1,
+    uid: "booking-uid-123",
+    userId: 1,
+    title: "Test Meeting",
+    description: "Test Description",
+    startTime: dayjs().add(24, "hours").toDate(),
+    endTime: dayjs().add(24, "hours").add(30, "minutes").toDate(),
+    eventTypeId: 1,
+    userPrimaryEmail: "user@example.com",
+    eventType: {
+      id: 1,
+      teamId: null,
+      team: null,
+      minimumCancellationNotice: 0,
+      bookingFields: null,
+      hideOrganizerEmail: false,
+      parentId: null,
+    },
+    location: "Zoom",
+    attendees: [
+      {
+        id: 1,
+        email: "attendee@example.com",
+        name: "Attendee Name",
+        locale: "en",
+        timeZone: "America/New_York",
+        phoneNumber: null,
+      },
+    ],
+    references: [],
+    customInputs: {},
+    dynamicEventSlugRef: null,
+    dynamicGroupSlugRef: null,
+    destinationCalendar: null,
+    smsReminderNumber: null,
+    workflowReminders: [],
+    responses: {},
+    iCalUID: "ical-uid",
+    ...overrides,
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2024-01-01T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe("API 403 Error Response", () => {
+    it("should return 403 error via TRPC when reschedule is within minimum notice", async () => {
+      const booking = createMockBooking({
+        startTime: dayjs().add(3, "hours").toDate(),
+        endTime: dayjs().add(3, "hours").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 360, // 6 hours minimum notice
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+
+      const caller = createCaller(createMockContext() as any);
+
+      await expect(
+        caller.viewer.bookings.requestReschedule({
+          bookingId: "booking-uid-123",
+          rescheduleReason: "Need to reschedule",
+        })
+      ).rejects.toThrow(TRPCError);
+
+      try {
+        await caller.viewer.bookings.requestReschedule({
+          bookingId: "booking-uid-123",
+          rescheduleReason: "Need to reschedule",
+        });
+      } catch (error) {
+        expect(error).toBeInstanceOf(TRPCError);
+        expect((error as TRPCError).code).toBe("FORBIDDEN");
+        expect((error as TRPCError).message).toBe("Cannot reschedule within 6 hours of event start");
+      }
+    });
+
+    it("should return properly formatted error messages for different time periods", async () => {
+      const testCases = [
+        {
+          minutesNotice: 45,
+          minutesUntilEvent: 30,
+          expectedMessage: "Cannot reschedule within 45 minutes of event start",
+        },
+        {
+          minutesNotice: 90,
+          minutesUntilEvent: 60,
+          expectedMessage: "Cannot reschedule within 1 hour and 30 minutes of event start",
+        },
+        {
+          minutesNotice: 240,
+          minutesUntilEvent: 180,
+          expectedMessage: "Cannot reschedule within 4 hours of event start",
+        },
+        {
+          minutesNotice: 1440,
+          minutesUntilEvent: 720,
+          expectedMessage: "Cannot reschedule within 24 hours of event start",
+        },
+        {
+          minutesNotice: 2880,
+          minutesUntilEvent: 1440,
+          expectedMessage: "Cannot reschedule within 48 hours of event start",
+        },
+      ];
+
+      const caller = createCaller(createMockContext() as any);
+
+      for (const testCase of testCases) {
+        const booking = createMockBooking({
+          startTime: dayjs().add(testCase.minutesUntilEvent, "minutes").toDate(),
+          endTime: dayjs().add(testCase.minutesUntilEvent + 30, "minutes").toDate(),
+          eventType: {
+            id: 1,
+            teamId: null,
+            team: null,
+            minimumCancellationNotice: testCase.minutesNotice,
+            bookingFields: null,
+            hideOrganizerEmail: false,
+            parentId: null,
+          },
+        });
+
+        vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+
+        try {
+          await caller.viewer.bookings.requestReschedule({
+            bookingId: "booking-uid-123",
+            rescheduleReason: "Testing error messages",
+          });
+          // Should not reach here
+          expect(true).toBe(false);
+        } catch (error) {
+          expect(error).toBeInstanceOf(TRPCError);
+          expect((error as TRPCError).code).toBe("FORBIDDEN");
+          expect((error as TRPCError).message).toBe(testCase.expectedMessage);
+        }
+      }
+    });
+
+    it("should validate minimum notice for team bookings", async () => {
+      const teamBooking = createMockBooking({
+        startTime: dayjs().add(90, "minutes").toDate(),
+        endTime: dayjs().add(120, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: 123,
+          team: {
+            id: 123,
+            name: "Test Team",
+            parentId: null,
+          },
+          minimumCancellationNotice: 120, // 2 hours
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(teamBooking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({
+        teams: [{ teamId: 123 }], // User is a team member
+      } as any);
+
+      const caller = createCaller(createMockContext() as any);
+
+      try {
+        await caller.viewer.bookings.requestReschedule({
+          bookingId: "booking-uid-123",
+          rescheduleReason: "Team reschedule attempt",
+        });
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeInstanceOf(TRPCError);
+        expect((error as TRPCError).code).toBe("FORBIDDEN");
+        expect((error as TRPCError).message).toBe("Cannot reschedule within 2 hours of event start");
+      }
+    });
+
+    it("should handle past events correctly", async () => {
+      const pastBooking = createMockBooking({
+        startTime: dayjs().subtract(2, "hours").toDate(), // Event already started
+        endTime: dayjs().subtract(1, "hour").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 60,
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(pastBooking as any);
+
+      const caller = createCaller(createMockContext() as any);
+
+      try {
+        await caller.viewer.bookings.requestReschedule({
+          bookingId: "booking-uid-123",
+          rescheduleReason: "Trying to reschedule past event",
+        });
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeInstanceOf(TRPCError);
+        expect((error as TRPCError).code).toBe("FORBIDDEN");
+        expect((error as TRPCError).message).toBe("Cannot reschedule within 1 hour of event start");
+      }
+    });
+
+    it("should handle events at exact boundary correctly", async () => {
+      const minutesNotice = 180; // 3 hours
+      const booking = createMockBooking({
+        startTime: dayjs().add(minutesNotice, "minutes").toDate(), // Exactly at boundary
+        endTime: dayjs().add(minutesNotice + 30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: minutesNotice,
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+      vi.mocked(prisma.eventType.findUniqueOrThrow).mockResolvedValue({
+        title: "Event Type",
+        schedulingType: null,
+        recurringEvent: null,
+      } as any);
+
+      const caller = createCaller(createMockContext() as any);
+
+      // Should succeed when exactly at boundary
+      const result = await caller.viewer.bookings.requestReschedule({
+        bookingId: "booking-uid-123",
+        rescheduleReason: "Reschedule at boundary",
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+      expect(prisma.booking.update).toHaveBeenCalled();
+    });
+  });
+
+  describe("Successful reschedule via API", () => {
+    it("should successfully reschedule when outside minimum notice period", async () => {
+      const booking = createMockBooking({
+        startTime: dayjs().add(48, "hours").toDate(),
+        endTime: dayjs().add(48, "hours").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 1440, // 24 hours
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+      vi.mocked(prisma.eventType.findUniqueOrThrow).mockResolvedValue({
+        title: "Event Type",
+        schedulingType: null,
+        recurringEvent: null,
+      } as any);
+
+      const caller = createCaller(createMockContext() as any);
+
+      const result = await caller.viewer.bookings.requestReschedule({
+        bookingId: "booking-uid-123",
+        rescheduleReason: "Valid reschedule request",
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+      expect(prisma.booking.update).toHaveBeenCalledWith({
+        where: { id: 1 },
+        data: {
+          rescheduled: true,
+          cancellationReason: "Valid reschedule request",
+          status: BookingStatus.CANCELLED,
+          updatedAt: expect.any(String),
+          cancelledBy: "user@example.com",
+        },
+      });
+    });
+
+    it("should allow reschedule when no minimum notice is set", async () => {
+      const booking = createMockBooking({
+        startTime: dayjs().add(10, "minutes").toDate(), // Very close to event
+        endTime: dayjs().add(40, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 0, // No minimum notice
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+      vi.mocked(prisma.eventType.findUniqueOrThrow).mockResolvedValue({
+        title: "Event Type",
+        schedulingType: null,
+        recurringEvent: null,
+      } as any);
+
+      const caller = createCaller(createMockContext() as any);
+
+      const result = await caller.viewer.bookings.requestReschedule({
+        bookingId: "booking-uid-123",
+        rescheduleReason: "Last minute reschedule",
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+    });
+  });
+
+  describe("Error handling edge cases", () => {
+    it("should handle database errors gracefully", async () => {
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockRejectedValue(
+        new Error("Database connection failed")
+      );
+
+      const caller = createCaller(createMockContext() as any);
+
+      await expect(
+        caller.viewer.bookings.requestReschedule({
+          bookingId: "booking-uid-123",
+          rescheduleReason: "Test database error",
+        })
+      ).rejects.toThrow("Database connection failed");
+    });
+
+    it("should handle booking not found", async () => {
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockRejectedValue(
+        new Error("No Booking found")
+      );
+
+      const caller = createCaller(createMockContext() as any);
+
+      await expect(
+        caller.viewer.bookings.requestReschedule({
+          bookingId: "non-existent-booking",
+          rescheduleReason: "Test not found",
+        })
+      ).rejects.toThrow("No Booking found");
+    });
+
+    it("should handle unauthorized user", async () => {
+      const booking = createMockBooking({
+        userId: 999, // Different user ID
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+
+      const caller = createCaller(createMockContext() as any);
+
+      try {
+        await caller.viewer.bookings.requestReschedule({
+          bookingId: "booking-uid-123",
+          rescheduleReason: "Unauthorized attempt",
+        });
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeInstanceOf(TRPCError);
+        expect((error as TRPCError).code).toBe("FORBIDDEN");
+        expect((error as TRPCError).message).toBe("User isn't owner of the current booking");
+      }
+    });
+
+    it("should validate input schema", async () => {
+      const caller = createCaller(createMockContext() as any);
+
+      // Test with missing bookingId
+      await expect(
+        caller.viewer.bookings.requestReschedule({
+          bookingId: "",
+          rescheduleReason: "Test empty booking ID",
+        })
+      ).rejects.toThrow();
+
+      // Test with invalid input type
+      await expect(
+        caller.viewer.bookings.requestReschedule({
+          bookingId: 123 as any, // Should be string
+          rescheduleReason: "Test invalid type",
+        })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("Complex scenarios", () => {
+    it("should handle concurrent reschedule attempts", async () => {
+      const booking = createMockBooking({
+        startTime: dayjs().add(25, "hours").toDate(),
+        endTime: dayjs().add(25, "hours").add(30, "minutes").toDate(),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 1440, // 24 hours
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+      vi.mocked(prisma.eventType.findUniqueOrThrow).mockResolvedValue({
+        title: "Event Type",
+        schedulingType: null,
+        recurringEvent: null,
+      } as any);
+
+      const caller = createCaller(createMockContext() as any);
+
+      // Simulate concurrent requests
+      const promises = [
+        caller.viewer.bookings.requestReschedule({
+          bookingId: "booking-uid-123",
+          rescheduleReason: "Concurrent request 1",
+        }),
+        caller.viewer.bookings.requestReschedule({
+          bookingId: "booking-uid-123",
+          rescheduleReason: "Concurrent request 2",
+        }),
+      ];
+
+      const results = await Promise.all(promises);
+      
+      // Both should succeed (in real scenario, database would handle concurrency)
+      expect(results).toHaveLength(2);
+      expect(results[0]).toEqual({ message: "Booking rescheduled successfully" });
+      expect(results[1]).toEqual({ message: "Booking rescheduled successfully" });
+    });
+
+    it("should handle time zone differences correctly", async () => {
+      // Set system time to UTC midnight
+      vi.setSystemTime(new Date("2024-01-01T00:00:00Z"));
+
+      // Event at 2 AM UTC (2 hours from now)
+      const booking = createMockBooking({
+        startTime: new Date("2024-01-01T02:00:00Z"),
+        endTime: new Date("2024-01-01T02:30:00Z"),
+        eventType: {
+          id: 1,
+          teamId: null,
+          team: null,
+          minimumCancellationNotice: 180, // 3 hours minimum notice
+          bookingFields: null,
+          hideOrganizerEmail: false,
+          parentId: null,
+        },
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(booking as any);
+
+      // User in different timezone shouldn't affect calculation
+      const userInDifferentTimezone = {
+        ...mockUser,
+        timeZone: "Asia/Tokyo", // UTC+9
+      };
+
+      const caller = createCaller(createMockContext(userInDifferentTimezone) as any);
+
+      try {
+        await caller.viewer.bookings.requestReschedule({
+          bookingId: "booking-uid-123",
+          rescheduleReason: "Timezone test",
+        });
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeInstanceOf(TRPCError);
+        expect((error as TRPCError).code).toBe("FORBIDDEN");
+        // 2 hours until event < 3 hours minimum notice
+        expect((error as TRPCError).message).toBe("Cannot reschedule within 3 hours of event start");
+      }
+    });
+
+    it("should handle dynamic event types correctly", async () => {
+      const dynamicBooking = createMockBooking({
+        startTime: dayjs().add(30, "minutes").toDate(),
+        endTime: dayjs().add(60, "minutes").toDate(),
+        eventType: null, // No event type
+        eventTypeId: null,
+        dynamicEventSlugRef: "dynamic-event-123", // Has dynamic event reference
+      });
+
+      vi.mocked(prisma.booking.findUniqueOrThrow).mockResolvedValue(dynamicBooking as any);
+      vi.mocked(prisma.user.findUniqueOrThrow).mockResolvedValue({ teams: [] } as any);
+
+      const caller = createCaller(createMockContext() as any);
+
+      // Should allow reschedule for dynamic events (no minimum notice check)
+      const result = await caller.viewer.bookings.requestReschedule({
+        bookingId: "booking-uid-123",
+        rescheduleReason: "Dynamic event reschedule",
+      });
+
+      expect(result).toEqual({ message: "Booking rescheduled successfully" });
+    });
+  });
+});
\ No newline at end of file