chore: release v5.4.11

fix: Optional Question ' Leaves Variable Tag in Event Name (#22175 )
chore: deprecate platform libraries 0.0.2 (#22149 )
2025-07-01 11:06:49 +00:00 · 2025-07-01 10:50:41 +00:00 · 2025-07-01 10:23:58 +00:00 · 2025-07-01 11:06:57 +01:00 · 2025-07-01 12:07:48 +03:00 · 2025-07-01 10:05:21 +03:00
852 changed files with 31819 additions and 7843 deletions
@@ -7,7 +7,7 @@
  "access": "public",
  "baseBranch": "main",
  "updateInternalDependencies": "patch",
-  "ignore": [],
+  "ignore": ["@calcom/platform-libraries"],
  "privatePackages": {
    "version": false,
    "tag": false
@@ -17,13 +17,14 @@
 /packages/app-store/larkcalendar/**/* @calcom/Foundation
 /packages/app-store/office365calendar/**/* @calcom/Foundation
 /packages/app-store/zohocalendar/**/* @calcom/Foundation
+/packages/embeds/**/* @calcom/Foundation
 /packages/features/bookings/lib/**/* @calcom/Foundation
 /packages/lib/getAggregatedAvailability.ts @calcom/Foundation
 /packages/lib/getUserAvailability.ts @calcom/Foundation
 /packages/lib/server/getLuckyUser.ts @calcom/Foundation
 /packages/lib/slots.ts @calcom/Foundation
 /packages/platform/**/* @calcom/Platform @calcom/Foundation
-/packages/prisma/**/* @calcom/Foundation
+/packages/prisma/**/* @calcom/DBA
 /packages/trpc/server/routers/viewer/bookings/confirm.handler.ts @calcom/Foundation
 /packages/trpc/server/routers/viewer/bookings/get.handler.ts @calcom/Foundation
 /packages/trpc/server/routers/viewer/slots/**/* @calcom/Foundation
@@ -15,7 +15,7 @@ jobs:
      contents: write # to create release by changesets/action below
      pull-requests: write # to create pull request by changesets/action below
    name: Release
-    runs-on: ubuntu-latest
+    runs-on: buildjet-4vcpu-ubuntu-2204
    steps:
      - name: Checkout Repo
        uses: actions/checkout@v4
@@ -0,0 +1,2 @@
+undecided:
+  - "@calcom/prisma"
@@ -0,0 +1,2 @@
+undecided:
+  - "@calcom/prisma"
@@ -0,0 +1,2 @@
+undecided:
+  - "@calcom/prisma"
@@ -0,0 +1,6 @@
+undecided:
+  - "@calcom/platform-constants"
+  - "@calcom/platform-enums"
+  - "@calcom/platform-types"
+  - "@calcom/platform-utils"
+  - "@calcom/prisma"
@@ -0,0 +1,6 @@
+undecided:
+  - "@calcom/app-store-cli"
+  - "@calcom/platform-constants"
+  - "@calcom/platform-enums"
+  - "@calcom/platform-types"
+  - "@calcom/platform-utils"
@@ -0,0 +1,3 @@
+undecided:
+  - calcom-monorepo
+  - "@calcom/prisma"
@@ -0,0 +1,8 @@
+undecided:
+  - calcom-monorepo
+  - "@calcom/app-store-cli"
+  - "@calcom/platform-constants"
+  - "@calcom/platform-enums"
+  - "@calcom/platform-types"
+  - "@calcom/platform-utils"
+  - "@calcom/prisma"
@@ -0,0 +1,3 @@
+undecided:
+  - calcom-monorepo
+  - "@calcom/prisma"
@@ -0,0 +1,8 @@
+undecided:
+  - calcom-monorepo
+  - "@calcom/app-store-cli"
+  - "@calcom/platform-constants"
+  - "@calcom/platform-enums"
+  - "@calcom/platform-types"
+  - "@calcom/platform-utils"
+  - "@calcom/prisma"
@@ -0,0 +1,3 @@
+undecided:
+  - calcom-monorepo
+  - "@calcom/prisma"
@@ -3,6 +3,7 @@
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
+  "private": true,
  "scripts": {
    "dev": "node ./index.js"
  },
@@ -1,4 +1,4 @@
-import prismock from "../../../../../../tests/libs/__mocks__/prisma";
+import prismock from "../../../../../tests/libs/__mocks__/prisma";

 import type { Request, Response } from "express";
 import type { NextApiRequest, NextApiResponse } from "next";
@@ -7,12 +7,12 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

 import type { ILicenseKeyService } from "@calcom/ee/common/server/LicenseKeyService";
 import LicenseKeyService from "@calcom/ee/common/server/LicenseKeyService";
+import { hashAPIKey } from "@calcom/features/ee/api-keys/lib/apiKeys";
+import type { IDeploymentRepository } from "@calcom/lib/server/repository/deployment.interface";
 import prisma from "@calcom/prisma";
 import { MembershipRole, UserPermissionRole } from "@calcom/prisma/enums";

-import { hashAPIKey } from "~/../../../packages/features/ee/api-keys/lib/apiKeys";
-
-import { verifyApiKey } from "../../../lib/helpers/verifyApiKey";
+import { verifyApiKey } from "./verifyApiKey";

 type CustomNextApiRequest = NextApiRequest & Request;
 type CustomNextApiResponse = NextApiResponse & Response;
@@ -21,11 +21,16 @@ afterEach(() => {
  vi.resetAllMocks();
 });

-describe("Verify API key", () => {
+const mockDeploymentRepository: IDeploymentRepository = {
+  getLicenseKeyWithId: vi.fn().mockResolvedValue("mockLicenseKey"), // Mocked return value
+};
+
+// TODO: Fix the skip condition for this test suite
+describe.skip("Verify API key", () => {
  let service: ILicenseKeyService;

  beforeEach(async () => {
-    service = await LicenseKeyService.create();
+    service = await LicenseKeyService.create(mockDeploymentRepository);

    vi.spyOn(service, "checkLicense");
  });
@@ -3,6 +3,7 @@ import type { NextMiddleware } from "next-api-middleware";
 import { LicenseKeySingleton } from "@calcom/ee/common/server/LicenseKeyService";
 import { hashAPIKey } from "@calcom/features/ee/api-keys/lib/apiKeys";
 import { IS_PRODUCTION } from "@calcom/lib/constants";
+import { DeploymentRepository } from "@calcom/lib/server/repository/deployment";
 import prisma from "@calcom/prisma";

 import { isAdminGuard } from "../utils/isAdmin";
@@ -19,11 +20,12 @@ export const dateNotInPast = function (date: Date) {

 // This verifies the apiKey and sets the user if it is valid.
 export const verifyApiKey: NextMiddleware = async (req, res, next) => {
-  const licenseKeyService = await LicenseKeySingleton.getInstance();
+  const deploymentRepo = new DeploymentRepository(prisma);
+  const licenseKeyService = await LicenseKeySingleton.getInstance(deploymentRepo);
  const hasValidLicense = await licenseKeyService.checkLicense();

  if (!hasValidLicense && IS_PRODUCTION) {
-    return res.status(401).json({ error: "Invalid or missing CALCOM_LICENSE_KEY environment variable" });
+    return res.status(401).json({ message: "Invalid or missing CALCOM_LICENSE_KEY environment variable" });
  }

  if (!req.query.apiKey) return res.status(401).json({ message: "No apiKey provided" });
@@ -1,6 +1,10 @@
 import { z } from "zod";

-import { MAX_SEATS_PER_TIME_SLOT } from "@calcom/lib/constants";
+import {
+  MAX_SEATS_PER_TIME_SLOT,
+  MAX_EVENT_DURATION_MINUTES,
+  MIN_EVENT_DURATION_MINUTES,
+} from "@calcom/lib/constants";
 import slugify from "@calcom/lib/slugify";
 import { _EventTypeModel as EventType, _HostModel } from "@calcom/prisma/zod";
 import { customInputSchema, eventTypeBookingFields } from "@calcom/prisma/zod-utils";
@@ -80,7 +84,7 @@ const schemaEventTypeCreateParams = z
    title: z.string(),
    slug: z.string().transform((s) => slugify(s)),
    description: z.string().optional().nullable(),
-    length: z.number().int(),
+    length: z.number().int().min(MIN_EVENT_DURATION_MINUTES).max(MAX_EVENT_DURATION_MINUTES),
    metadata: z.any().optional(),
    recurringEvent: recurringEventInputSchema.optional(),
    seatsPerTimeSlot: z.number().optional(),
@@ -38,7 +38,7 @@
    "next-axiom": "^0.17.0",
    "next-swagger-doc": "^0.3.6",
    "next-validations": "^0.2.0",
-    "typescript": "^5.8.3",
+    "typescript": "^5.7.2",
    "tzdata": "^1.0.30",
    "uuid": "^8.3.2",
    "zod": "^3.22.4"
@@ -42,11 +42,6 @@ describe("GET /api/slots", () => {
      await handler(req, res);

      expect(res.statusCode).toBe(400);
-      expect(JSON.parse(res._getData())).toMatchInlineSnapshot(`
-        {
-          "message": "invalid_type in 'startTime': Required; invalid_type in 'endTime': Required",
-        }
-      `);
    });
  });

@@ -37,4 +37,8 @@ AXIOM_TOKEN=
 # INFO: 1
 # WARN: 2
 # ERROR: 3
-LOGGER_BRIDGE_LOG_LEVEL="1"
+LOGGER_BRIDGE_LOG_LEVEL="1"
+
+# 1: Rewrite /api/v2 to /v2
+# 0: Don't rewrite
+REWRITE_API_V2_PREFIX="1"
@@ -4,6 +4,7 @@
  "description": "Platform API for Cal.com",
  "author": "Cal.com Inc.",
  "license": "UNLICENSED",
+  "private": true,
  "scripts": {
    "build": "yarn dev:build && nest build",
    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
@@ -37,8 +38,7 @@
    "@axiomhq/winston": "^1.2.0",
    "@calcom/platform-constants": "*",
    "@calcom/platform-enums": "*",
-    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.208",
-    "@calcom/platform-libraries-0.0.2": "npm:@calcom/platform-libraries@0.0.2",
+    "@calcom/platform-libraries": "npm:@calcom/platform-libraries@0.0.236",
    "@calcom/platform-types": "*",
    "@calcom/platform-utils": "*",
    "@calcom/prisma": "*",
@@ -108,7 +108,7 @@
    "ts-loader": "^9.4.3",
    "ts-node": "^10.9.1",
    "tsconfig-paths": "^4.1.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.7.2"
  },
  "prisma": {
    "schema": "../../../packages/prisma/schema.prisma"
@@ -86,10 +86,16 @@ export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer): void {
    consumer
      .apply(RawBodyMiddleware)
-      .forRoutes({
-        path: "/api/v2/billing/webhook",
-        method: RequestMethod.POST,
-      })
+      .forRoutes(
+        {
+          path: "/api/v2/billing/webhook",
+          method: RequestMethod.POST,
+        },
+        {
+          path: "/v2/billing/webhook",
+          method: RequestMethod.POST,
+        }
+      )
      .apply(JsonBodyMiddleware)
      .forRoutes("*")
      .apply(RequestIdMiddleware)
@@ -81,5 +81,9 @@ export const bootstrap = (app: NestExpressApplication): NestExpressApplication =

  app.use(cookieParser());

+  if (process?.env?.API_GLOBAL_PREFIX) {
+    app.setGlobalPrefix(process?.env?.API_GLOBAL_PREFIX);
+  }
+
  return app;
 };
@@ -36,7 +36,7 @@ const loadConfig = (): AppConfig => {
    app: {
      baseUrl: getEnv("WEB_APP_URL", "https://app.cal.com"),
    },
-    e2e: getEnv("IS_E2E", false),
+    e2e: getEnv("IS_E2E", "false") === "true" ? true : false,
  };
 };

@@ -77,6 +77,7 @@ type OAuthRequestParams = {
  platformBookingUrl: string;
  platformBookingLocation?: string;
  arePlatformEmailsEnabled: boolean;
+  areCalendarEventsEnabled: boolean;
 };

 const DEFAULT_PLATFORM_PARAMS = {
@@ -86,6 +87,7 @@ const DEFAULT_PLATFORM_PARAMS = {
  platformBookingUrl: "",
  arePlatformEmailsEnabled: false,
  platformBookingLocation: undefined,
+  areCalendarEventsEnabled: false,
 };

@Controller({
@@ -135,9 +137,13 @@ export class BookingsController_2024_04_15 {
      },
    });

+    let nextCursor = null;
+    if (bookings.totalCount > (cursor ?? 0) + (limit ?? 10)) {
+      nextCursor = (cursor ?? 0) + (limit ?? 10);
+    }
    return {
      status: SUCCESS_STATUS,
-      data: bookings,
+      data: { ...bookings, nextCursor },
    };
  }

@@ -191,6 +197,7 @@ export class BookingsController_2024_04_15 {
        platformCancelUrl: bookingRequest.platformCancelUrl,
        platformBookingUrl: bookingRequest.platformBookingUrl,
        platformBookingLocation: bookingRequest.platformBookingLocation,
+        areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
      });
      if (booking.userId && booking.uid && booking.startTime) {
        void (await this.billingService.increaseUsageByUserId(booking.userId, {
@@ -424,7 +431,7 @@ export class BookingsController_2024_04_15 {

    if (isEmbed) {
      // embed should ignore oauth client settings and enable emails by default
-      return { ...res, arePlatformEmailsEnabled: true };
+      return { ...res, arePlatformEmailsEnabled: true, areCalendarEventsEnabled: true };
    }

    try {
@@ -436,6 +443,7 @@ export class BookingsController_2024_04_15 {
        res.platformRescheduleUrl = client.bookingRescheduleRedirectUri ?? "";
        res.platformBookingUrl = client.bookingRedirectUri ?? "";
        res.arePlatformEmailsEnabled = client.areEmailsEnabled ?? false;
+        res.areCalendarEventsEnabled = client.areCalendarEventsEnabled;
      }
      return res;
    } catch (err) {
@@ -16,13 +16,15 @@ import {

 import { SUCCESS_STATUS, ERROR_STATUS } from "@calcom/platform-constants";

-enum Status {
-  CANCELLED = "CANCELLED",
-  REJECTED = "REJECTED",
-  ACCEPTED = "ACCEPTED",
-  PENDING = "PENDING",
-  AWAITING_HOST = "AWAITING_HOST",
-}
+const Status = {
+  CANCELLED: "CANCELLED",
+  REJECTED: "REJECTED",
+  ACCEPTED: "ACCEPTED",
+  PENDING: "PENDING",
+  AWAITING_HOST: "AWAITING_HOST",
+} as const;
+
+export type Status = (typeof Status)[keyof typeof Status];

 class Attendee {
  @IsInt()
@@ -24,4 +24,26 @@ export class BookingReferencesRepository_2024_08_13 {
      },
    });
  }
+
+  async getBookingReferencesIncludeSensitiveCredentials(eventUid: string) {
+    return this.dbRead.prisma.bookingReference.findFirst({
+      where: {
+        uid: eventUid,
+      },
+      include: {
+        credential: true,
+        delegationCredential: true,
+        booking: {
+          select: {
+            user: {
+              select: {
+                id: true,
+                email: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
 }
@@ -3,6 +3,7 @@ import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings
 import { BookingsController_2024_08_13 } from "@/ee/bookings/2024-08-13/controllers/bookings.controller";
 import { BookingReferencesService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/booking-references.service";
 import { BookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/bookings.service";
+import { CalVideoService } from "@/ee/bookings/2024-08-13/services/cal-video.service";
 import { ErrorsBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/errors.service";
 import { InputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/input.service";
 import { OutputBookingReferencesService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/output-booking-references.service";
@@ -77,6 +78,7 @@ import { Module } from "@nestjs/common";
    ErrorsBookingsService_2024_08_13,
    BookingReferencesService_2024_08_13,
    BookingReferencesRepository_2024_08_13,
+    CalVideoService,
  ],
  controllers: [BookingsController_2024_08_13],
  exports: [InputBookingsService_2024_08_13, OutputBookingsService_2024_08_13, BookingsService_2024_08_13],
@@ -169,4 +169,15 @@ export class BookingsRepository_2024_08_13 {
      },
    });
  }
+
+  async getByUidWithBookingReference(uid: string) {
+    return this.dbRead.prisma.booking.findUnique({
+      where: {
+        uid,
+      },
+      select: {
+        references: true,
+      },
+    });
+  }
 }
@@ -9,6 +9,7 @@ import { ReassignBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outpu
 import { RescheduleBookingOutput_2024_08_13 } from "@/ee/bookings/2024-08-13/outputs/reschedule-booking.output";
 import { BookingReferencesService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/booking-references.service";
 import { BookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/bookings.service";
+import { CalVideoService } from "@/ee/bookings/2024-08-13/services/cal-video.service";
 import { VERSION_2024_08_13_VALUE, VERSION_2024_08_13 } from "@/lib/api-versions";
 import { API_KEY_OR_ACCESS_TOKEN_HEADER } from "@/lib/docs/headers";
 import { PlatformPlan } from "@/modules/auth/decorators/billing/platform-plan.decorator";
@@ -54,6 +55,8 @@ import {
  RescheduleBookingInput_2024_08_13,
  RescheduleBookingInputPipe,
  RescheduleSeatedBookingInput_2024_08_13,
+  GetBookingRecordingsOutput,
+  GetBookingTranscriptsOutput,
 } from "@calcom/platform-types";
 import {
  CreateBookingInputPipe,
@@ -88,7 +91,8 @@ export class BookingsController_2024_08_13 {
  constructor(
    private readonly bookingsService: BookingsService_2024_08_13,
    private readonly usersService: UsersService,
-    private readonly bookingReferencesService: BookingReferencesService_2024_08_13
+    private readonly bookingReferencesService: BookingReferencesService_2024_08_13,
+    private readonly calVideoService: CalVideoService
  ) {}

  @Post("/")
@@ -171,6 +175,36 @@ export class BookingsController_2024_08_13 {
    };
  }

+  @Get("/:bookingUid/recordings")
+  @UseGuards(BookingUidGuard)
+  @ApiOperation({
+    summary: "Get all the recordings for the booking",
+    description: `Fetches all the recordings for the booking \`:bookingUid\``,
+  })
+  async getBookingRecordings(@Param("bookingUid") bookingUid: string): Promise<GetBookingRecordingsOutput> {
+    const recordings = await this.calVideoService.getRecordings(bookingUid);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: recordings,
+    };
+  }
+
+  @Get("/:bookingUid/transcripts")
+  @UseGuards(BookingUidGuard)
+  @ApiOperation({
+    summary: "Get all the transcripts download links for the booking",
+    description: `Fetches all the transcripts download links for the booking \`:bookingUid\``,
+  })
+  async getBookingTranscripts(@Param("bookingUid") bookingUid: string): Promise<GetBookingTranscriptsOutput> {
+    const transcripts = await this.calVideoService.getTranscripts(bookingUid);
+
+    return {
+      status: SUCCESS_STATUS,
+      data: transcripts ?? [],
+    };
+  }
+
  @Get("/")
  @UseGuards(ApiAuthGuard)
  @ApiHeader(API_KEY_OR_ACCESS_TOKEN_HEADER)
@@ -233,7 +267,14 @@ export class BookingsController_2024_08_13 {
  @ApiOperation({
    summary: "Cancel a booking",
    description: `:bookingUid can be :bookingUid of an usual booking, individual recurrence or recurring booking to cancel all recurrences.
-    For seated bookings to cancel one individual booking provide :bookingUid and :seatUid in the request body. For recurring seated bookings it is not possible to cancel all of them with 1 call
+    
+    \nCancelling seated bookings:
+    It is possible to cancel specific seat within a booking as an attendee or all of the seats as the host.
+    \n1. As an attendee - provide :bookingUid in the request URL \`/bookings/:bookingUid/cancel\` and seatUid in the request body \`{"seatUid": "123-123-123"}\` . This will remove this particular attendance from the booking.
+    \n2. As the host - host can cancel booking for all attendees aka for every seat. Provide :bookingUid in the request URL \`/bookings/:bookingUid/cancel\` and cancellationReason in the request body \`{"cancellationReason": "Will travel"}\` and \`Authorization: Bearer token\` request header where token is event type owner (host) credential. This will cancel the booking for all attendees.
+    
+    \nCancelling recurring seated bookings:
+    For recurring seated bookings it is not possible to cancel all of them with 1 call
    like with non-seated recurring bookings by providing recurring bookind uid - you have to cancel each recurrence booking by its bookingUid + seatUid.`,
  })
  @ApiBody({
@@ -874,9 +874,8 @@ describe("Bookings Endpoints 2024-08-13 team emails", () => {
            expect(responseBody.status).toEqual(SUCCESS_STATUS);
            expect(responseBody.data).toBeDefined();
            expect(AttendeeScheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
-            expect(AttendeeRescheduledEmail.prototype.getHtml).not.toHaveBeenCalled();
+            expect(AttendeeRescheduledEmail.prototype.getHtml).toHaveBeenCalled();

-            expect(OrganizerRescheduledEmail.prototype.getHtml).toHaveBeenCalled();
            expect(OrganizerScheduledEmail.prototype.getHtml).toHaveBeenCalled();
            expect(OrganizerCancelledEmail.prototype.getHtml).toHaveBeenCalled();
            emailsEnabledSetup.roundRobinEventType.rescheduledBookingUid = responseBody.data.uid;
@@ -14,29 +14,27 @@ import { Test } from "@nestjs/testing";
 import { User } from "@prisma/client";
 import { DateTime } from "luxon";
 import * as request from "supertest";
+import { ApiKeysRepositoryFixture } from "test/fixtures/repository/api-keys.repository.fixture";
+import { BookingSeatRepositoryFixture } from "test/fixtures/repository/booking-seat.repository.fixture";
 import { BookingsRepositoryFixture } from "test/fixtures/repository/bookings.repository.fixture";
 import { EventTypesRepositoryFixture } from "test/fixtures/repository/event-types.repository.fixture";
 import { OAuthClientRepositoryFixture } from "test/fixtures/repository/oauth-client.repository.fixture";
 import { TeamRepositoryFixture } from "test/fixtures/repository/team.repository.fixture";
 import { UserRepositoryFixture } from "test/fixtures/repository/users.repository.fixture";
 import { randomString } from "test/utils/randomString";
-import { withApiAuth } from "test/utils/withApiAuth";

 import { CAL_API_VERSION_HEADER, SUCCESS_STATUS, VERSION_2024_08_13 } from "@calcom/platform-constants";
 import {
+  CancelBookingInput_2024_08_13,
  CancelSeatedBookingInput_2024_08_13,
  CreateRecurringSeatedBookingOutput_2024_08_13,
  CreateSeatedBookingOutput_2024_08_13,
  GetBookingOutput_2024_08_13,
  GetBookingsOutput_2024_08_13,
-  GetRecurringSeatedBookingOutput_2024_08_13,
  GetSeatedBookingOutput_2024_08_13,
  RescheduleSeatedBookingInput_2024_08_13,
 } from "@calcom/platform-types";
-import {
-  CreateBookingInput_2024_08_13,
-  CreateRecurringBookingInput_2024_08_13,
-} from "@calcom/platform-types";
+import { CreateBookingInput_2024_08_13 } from "@calcom/platform-types";
 import { PlatformOAuthClient, Team } from "@calcom/prisma/client";

 describe("Bookings Endpoints 2024-08-13", () => {
@@ -51,11 +49,13 @@ describe("Bookings Endpoints 2024-08-13", () => {
    let schedulesService: SchedulesService_2024_04_15;
    let eventTypesRepositoryFixture: EventTypesRepositoryFixture;
    let oauthClientRepositoryFixture: OAuthClientRepositoryFixture;
-    let oAuthClient: PlatformOAuthClient;
    let teamRepositoryFixture: TeamRepositoryFixture;
+    let apiKeysRepositoryFixture: ApiKeysRepositoryFixture;
+    let bookingSeatRepositoryFixture: BookingSeatRepositoryFixture;

    const userEmail = `seated-bookings-user-${randomString()}@api.com`;
    let user: User;
+    let apiKeyString: string;

    let seatedEventTypeId: number;
    const maxRecurrenceCount = 3;
@@ -63,6 +63,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
    const seatedEventSlug = `seated-bookings-event-type-${randomString()}`;

    let createdSeatedBooking: CreateSeatedBookingOutput_2024_08_13;
+    let createdSeatedBooking2: CreateSeatedBookingOutput_2024_08_13;

    const emailAttendeeOne = `seated-bookings-attendee1-${randomString()}@api.com`;
    const nameAttendeeOne = `Attendee One ${randomString()}`;
@@ -70,12 +71,9 @@ describe("Bookings Endpoints 2024-08-13", () => {
    const nameAttendeeTwo = `Attendee Two ${randomString()}`;

    beforeAll(async () => {
-      const moduleRef = await withApiAuth(
-        userEmail,
-        Test.createTestingModule({
-          imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
-        })
-      )
+      const moduleRef = await Test.createTestingModule({
+        imports: [AppModule, PrismaModule, UsersModule, SchedulesModule_2024_04_15],
+      })
        .overrideGuard(PermissionsGuard)
        .useValue({
          canActivate: () => true,
@@ -87,22 +85,21 @@ describe("Bookings Endpoints 2024-08-13", () => {
      eventTypesRepositoryFixture = new EventTypesRepositoryFixture(moduleRef);
      oauthClientRepositoryFixture = new OAuthClientRepositoryFixture(moduleRef);
      teamRepositoryFixture = new TeamRepositoryFixture(moduleRef);
+      apiKeysRepositoryFixture = new ApiKeysRepositoryFixture(moduleRef);
      schedulesService = moduleRef.get<SchedulesService_2024_04_15>(SchedulesService_2024_04_15);
+      bookingSeatRepositoryFixture = new BookingSeatRepositoryFixture(moduleRef);

      organization = await teamRepositoryFixture.create({
        name: `seated-bookings-organization-${randomString()}`,
      });
-      oAuthClient = await createOAuthClient(organization.id);

      user = await userRepositoryFixture.create({
        email: userEmail,
-        platformOAuthClients: {
-          connect: {
-            id: oAuthClient.id,
-          },
-        },
      });

+      const { keyString } = await apiKeysRepositoryFixture.createApiKey(user.id, null);
+      apiKeyString = `cal_test_${keyString}`;
+
      const userSchedule: CreateScheduleInput_2024_04_15 = {
        name: `seated-bookings-2024-08-13-schedule-${randomString()}`,
        timeZone: "Europe/Rome",
@@ -118,6 +115,14 @@ describe("Bookings Endpoints 2024-08-13", () => {
          seatsShowAttendees: true,
          seatsShowAvailabilityCount: true,
          locations: [{ type: "inPerson", address: "via 10, rome, italy" }],
+          metadata: {
+            disableStandardEmails: {
+              all: {
+                attendee: true,
+                host: true,
+              },
+            },
+          },
        },
        user.id
      );
@@ -129,19 +134,6 @@ describe("Bookings Endpoints 2024-08-13", () => {
      await app.init();
    });

-    async function createOAuthClient(organizationId: number) {
-      const data = {
-        logo: "logo-url",
-        name: "name",
-        redirectUris: ["http://localhost:5555"],
-        permissions: 32,
-      };
-      const secret = "secret";
-
-      const client = await oauthClientRepositoryFixture.create(organizationId, data, secret);
-      return client;
-    }
-
    it("should book an event type with seats for the first time", async () => {
      const body: CreateBookingInput_2024_08_13 = {
        start: new Date(Date.UTC(2030, 0, 8, 13, 0, 0)).toISOString(),
@@ -333,6 +325,7 @@ describe("Bookings Endpoints 2024-08-13", () => {
      return request(app.getHttpServer())
        .get("/v2/bookings?sortCreated=asc")
        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .set("Authorization", `Bearer ${apiKeyString}`)
        .expect(200)
        .then(async (response) => {
          const responseBody: GetBookingsOutput_2024_08_13 = response.body;
@@ -350,6 +343,22 @@ describe("Bookings Endpoints 2024-08-13", () => {
        });
    });

+    it("should not be able to reschedule seated booking if seatUid is not provided", async () => {
+      const body = {
+        start: new Date(Date.UTC(2030, 0, 8, 15, 0, 0)).toISOString(),
+      };
+
+      const response = await request(app.getHttpServer())
+        .post(`/v2/bookings/${createdSeatedBooking.uid}/reschedule`)
+        .send(body)
+        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+        .expect(400);
+
+      expect(response.body.error.message).toEqual(
+        `Booking with uid=${createdSeatedBooking.uid} is a seated booking which means you have to provide seatUid in the request body to specify which seat specifically you want to reschedule. First, fetch the booking using https://cal.com/docs/api-reference/v2/bookings/get-a-booking and then within the attendees array you will find the seatUid of the booking you want to reschedule. Second, provide the seatUid in the request body to specify which seat specifically you want to reschedule using the reschedule endpoint https://cal.com/docs/api-reference/v2/bookings/reschedule-a-booking#option-2`
+      );
+    });
+
    it("should reschedule seated booking", async () => {
      const body: RescheduleSeatedBookingInput_2024_08_13 = {
        start: new Date(Date.UTC(2030, 0, 8, 15, 0, 0)).toISOString(),
@@ -409,67 +418,186 @@ describe("Bookings Endpoints 2024-08-13", () => {
        });
    });

-    it("should cancel seated booking", async () => {
-      const body: CancelSeatedBookingInput_2024_08_13 = {
-        seatUid: createdSeatedBooking.seatUid,
-      };
+    describe("cancel seated booking", () => {
+      describe("cancel seated booking as attendee", () => {
+        it("should cancel seated booking", async () => {
+          const body: CancelSeatedBookingInput_2024_08_13 = {
+            seatUid: createdSeatedBooking.seatUid,
+          };

-      return request(app.getHttpServer())
-        .post(`/v2/bookings/${createdSeatedBooking.uid}/cancel`)
-        .send(body)
-        .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
-        .expect(200)
-        .then(async (response) => {
-          const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
-          expect(responseBody.status).toEqual(SUCCESS_STATUS);
-          expect(responseBody.data).toBeDefined();
-          expect(responseDataIsGetSeatedBooking(responseBody.data)).toBe(true);
+          return request(app.getHttpServer())
+            .post(`/v2/bookings/${createdSeatedBooking.uid}/cancel`)
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(200)
+            .then(async (response) => {
+              const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(responseDataIsGetSeatedBooking(responseBody.data)).toBe(true);

-          if (responseDataIsGetSeatedBooking(responseBody.data)) {
-            const data: GetSeatedBookingOutput_2024_08_13 = responseBody.data;
-            expect(data.id).toBeDefined();
-            expect(data.uid).toBeDefined();
-            expect(data.hosts[0].id).toEqual(user.id);
-            expect(data.status).toEqual("cancelled");
-            expect(data.start).toEqual(createdSeatedBooking.start);
-            expect(data.end).toEqual(createdSeatedBooking.end);
-            expect(data.duration).toEqual(60);
-            expect(data.eventTypeId).toEqual(seatedEventTypeId);
-            expect(data.eventType).toEqual({
-              id: seatedEventTypeId,
-              slug: seatedEventSlug,
+              if (responseDataIsGetSeatedBooking(responseBody.data)) {
+                const data: GetSeatedBookingOutput_2024_08_13 = responseBody.data;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(data.hosts[0].id).toEqual(user.id);
+                expect(data.status).toEqual("cancelled");
+                expect(data.start).toEqual(createdSeatedBooking.start);
+                expect(data.end).toEqual(createdSeatedBooking.end);
+                expect(data.duration).toEqual(60);
+                expect(data.eventTypeId).toEqual(seatedEventTypeId);
+                expect(data.eventType).toEqual({
+                  id: seatedEventTypeId,
+                  slug: seatedEventSlug,
+                });
+                expect(data.attendees.length).toEqual(0);
+                expect(data.location).toBeDefined();
+                expect(data.absentHost).toEqual(false);
+              } else {
+                throw new Error("Invalid response data - expected booking but received array response");
+              }
            });
-            expect(data.attendees.length).toEqual(0);
-            expect(data.location).toBeDefined();
-            expect(data.absentHost).toEqual(false);
-          } else {
-            throw new Error("Invalid response data - expected booking but received array response");
-          }
        });
+      });
+
+      describe("cancel seated booking as host", () => {
+        it("should book an event type with seats", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2030, 0, 8, 14, 0, 0)).toISOString(),
+            eventTypeId: seatedEventTypeId,
+            attendee: {
+              name: nameAttendeeOne,
+              email: emailAttendeeOne,
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+            bookingFieldsResponses: {
+              codingLanguage: "TypeScript",
+            },
+            metadata: {
+              userId: "100",
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(201)
+            .then(async (response) => {
+              const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(responseDataIsCreateSeatedBooking(responseBody.data)).toBe(true);
+
+              if (responseDataIsCreateSeatedBooking(responseBody.data)) {
+                const data: CreateSeatedBookingOutput_2024_08_13 = responseBody.data;
+                expect(data.seatUid).toBeDefined();
+                const seatUid = data.seatUid;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(data.hosts[0].id).toEqual(user.id);
+                expect(data.status).toEqual("accepted");
+                expect(data.start).toEqual(body.start);
+                expect(data.end).toEqual(
+                  DateTime.fromISO(body.start, { zone: "utc" }).plus({ hours: 1 }).toISO()
+                );
+                expect(data.duration).toEqual(60);
+                expect(data.eventTypeId).toEqual(seatedEventTypeId);
+                expect(data.eventType).toEqual({
+                  id: seatedEventTypeId,
+                  slug: seatedEventSlug,
+                });
+                expect(data.attendees.length).toEqual(1);
+                expect(data.attendees[0]).toEqual({
+                  name: body.attendee.name,
+                  email: body.attendee.email,
+                  timeZone: body.attendee.timeZone,
+                  language: body.attendee.language,
+                  absent: false,
+                  seatUid,
+                  bookingFieldsResponses: {
+                    name: body.attendee.name,
+                    ...body.bookingFieldsResponses,
+                  },
+                  metadata: body.metadata,
+                });
+                expect(data.location).toBeDefined();
+                expect(data.absentHost).toEqual(false);
+                createdSeatedBooking2 = data;
+              } else {
+                throw new Error(
+                  "Invalid response data - expected recurring booking but received non array response"
+                );
+              }
+            });
+        });
+
+        it("should not be able to cancel without cancellation reason", async () => {
+          const response = await request(app.getHttpServer())
+            .post(`/v2/bookings/${createdSeatedBooking2.uid}/cancel`)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .set("Authorization", `Bearer ${apiKeyString}`)
+            .expect(400);
+
+          expect(response.body.message).toEqual("Cancellation reason is required when you are the host");
+        });
+
+        it("should cancel seated booking", async () => {
+          const body: CancelBookingInput_2024_08_13 = {
+            cancellationReason: "I will be travelling without internet",
+          };
+
+          return request(app.getHttpServer())
+            .post(`/v2/bookings/${createdSeatedBooking2.uid}/cancel`)
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .set("Authorization", `Bearer ${apiKeyString}`)
+            .expect(200)
+            .then(async (response) => {
+              const responseBody: RescheduleBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(responseDataIsGetSeatedBooking(responseBody.data)).toBe(true);
+
+              if (responseDataIsGetSeatedBooking(responseBody.data)) {
+                const data: GetSeatedBookingOutput_2024_08_13 = responseBody.data;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(data.hosts[0].id).toEqual(user.id);
+                expect(data.status).toEqual("cancelled");
+                expect(data.start).toEqual(createdSeatedBooking2.start);
+                expect(data.end).toEqual(createdSeatedBooking2.end);
+                expect(data.duration).toEqual(60);
+                expect(data.eventTypeId).toEqual(seatedEventTypeId);
+                expect(data.eventType).toEqual({
+                  id: seatedEventTypeId,
+                  slug: seatedEventSlug,
+                });
+                expect(data.attendees.length).toEqual(0);
+                expect(data.location).toBeDefined();
+                expect(data.absentHost).toEqual(false);
+                expect(data.cancellationReason).toEqual("I will be travelling without internet");
+
+                const seats = await bookingSeatRepositoryFixture.findAllByBookingId(data.id);
+                expect(seats.length).toEqual(0);
+              } else {
+                throw new Error("Invalid response data - expected booking but received array response");
+              }
+            });
+        });
+      });
    });

    function responseDataIsCreateSeatedBooking(data: any): data is CreateSeatedBookingOutput_2024_08_13 {
      return data.hasOwnProperty("seatUid");
    }

-    function responseDataIsCreateRecurringSeatedBooking(
-      data: any
-    ): data is CreateRecurringSeatedBookingOutput_2024_08_13[] {
-      return Array.isArray(data);
-    }
-
    function responseDataIsGetSeatedBooking(data: any): data is GetSeatedBookingOutput_2024_08_13 {
      return data?.attendees?.every((attendee: any) => attendee?.hasOwnProperty("seatUid"));
    }

-    function responseDataIsGetRecurringSeatedBooking(
-      data: any
-    ): data is GetRecurringSeatedBookingOutput_2024_08_13[] {
-      return Array.isArray(data);
-    }
-
    afterAll(async () => {
-      await oauthClientRepositoryFixture.delete(oAuthClient.id);
      await teamRepositoryFixture.delete(organization.id);
      await userRepositoryFixture.deleteByEmail(user.email);
      await bookingsRepositoryFixture.deleteAllBookings(user.id, user.email);
@@ -35,6 +35,7 @@ import {
  X_CAL_CLIENT_ID,
 } from "@calcom/platform-constants";
 import { AttendeeScheduledEmail, OrganizerScheduledEmail } from "@calcom/platform-libraries/emails";
+import { EventManager } from "@calcom/platform-libraries/event-types";
 import {
  CreateEventTypeInput_2024_06_14,
  FAILED_EVENT_TYPE_IDENTIFICATION_ERROR_MESSAGE,
@@ -78,6 +79,8 @@ describe("Bookings Endpoints 2024-08-13", () => {
    const eventTypeSlug = `user-bookings-event-type-${randomString()}`;
    let recurringEventTypeId: number;
    const recurringEventTypeSlug = `user-bookings-event-type-${randomString()}`;
+    let eventTypeRequiresConfirmationId: number;
+    const eventTypeRequiresConfirmationSlug = `user-bookings-event-type-requires-confirmation-${randomString()}`;

    let createdBooking: BookingOutput_2024_08_13;
    let rescheduledBooking: BookingOutput_2024_08_13;
@@ -153,6 +156,17 @@ describe("Bookings Endpoints 2024-08-13", () => {
      );
      recurringEventTypeId = recurringEvent.id;

+      const eventTypeRequiresConfirmation = await eventTypesRepositoryFixture.create(
+        {
+          title: `user-bookings-2024-08-13-event-type-requires-confirmation-${randomString()}`,
+          slug: eventTypeRequiresConfirmationSlug,
+          length: 60,
+          requiresConfirmation: true,
+        },
+        user.id
+      );
+      eventTypeRequiresConfirmationId = eventTypeRequiresConfirmation.id;
+
      bookingInThePast = await bookingsRepositoryFixture.create({
        user: {
          connect: {
@@ -2399,6 +2413,425 @@ describe("Bookings Endpoints 2024-08-13", () => {
      });
    });

+    describe("cant't reschedule cancelled booking", () => {
+      it("should not be able to reschedule cancelled booking", async () => {
+        const cancelledBooking = await bookingsRepositoryFixture.create({
+          status: "CANCELLED",
+          user: {
+            connect: {
+              id: user.id,
+            },
+          },
+          startTime: new Date(Date.UTC(2050, 0, 8, 13, 0, 0)),
+          endTime: new Date(Date.UTC(2050, 0, 8, 14, 0, 0)),
+          title: "peer coding lets goo",
+          uid: `cancelled-booking-${randomString()}`,
+          eventType: {
+            connect: {
+              id: eventTypeId,
+            },
+          },
+          location: "integrations:daily",
+          customInputs: {},
+          metadata: {},
+          responses: {
+            name: "Oldie",
+            email: "oldie@gmail.com",
+          },
+          attendees: {
+            create: {
+              email: "oldie@gmail.com",
+              name: "Oldie",
+              locale: "lv",
+              timeZone: "Europe/Rome",
+            },
+          },
+        });
+
+        const body: RescheduleBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2040, 0, 9, 14, 0, 0)).toISOString(),
+          reschedulingReason: "Flying to mars that day",
+        };
+
+        const response = await request(app.getHttpServer())
+          .post(`/v2/bookings/${cancelledBooking.uid}/reschedule`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(400);
+
+        expect(response.body.error.message).toEqual(
+          `Can't reschedule booking with uid=${cancelledBooking.uid} because it has been cancelled. Please provide uid of a booking that is not cancelled.`
+        );
+        await bookingsRepositoryFixture.deleteById(cancelledBooking.id);
+      });
+
+      it("should not be able to reschedule rescheduled booking", async () => {
+        const rescheduledBooking = await bookingsRepositoryFixture.create({
+          status: "CANCELLED",
+          rescheduled: true,
+          user: {
+            connect: {
+              id: user.id,
+            },
+          },
+          startTime: new Date(Date.UTC(2050, 0, 8, 13, 0, 0)),
+          endTime: new Date(Date.UTC(2050, 0, 8, 14, 0, 0)),
+          title: "peer coding lets goo",
+          uid: `cancelled-booking-${randomString()}`,
+          eventType: {
+            connect: {
+              id: eventTypeId,
+            },
+          },
+          location: "integrations:daily",
+          customInputs: {},
+          metadata: {},
+          responses: {
+            name: "Oldie",
+            email: "oldie@gmail.com",
+          },
+          attendees: {
+            create: {
+              email: "oldie@gmail.com",
+              name: "Oldie",
+              locale: "lv",
+              timeZone: "Europe/Rome",
+            },
+          },
+        });
+
+        const newBooking = await bookingsRepositoryFixture.create({
+          status: "ACCEPTED",
+          user: {
+            connect: {
+              id: user.id,
+            },
+          },
+          fromReschedule: rescheduledBooking.uid,
+          startTime: new Date(Date.UTC(2050, 0, 8, 13, 0, 0)),
+          endTime: new Date(Date.UTC(2050, 0, 8, 14, 0, 0)),
+          title: "peer coding lets goo",
+          uid: `new-booking-${randomString()}`,
+          eventType: {
+            connect: {
+              id: eventTypeId,
+            },
+          },
+          location: "integrations:daily",
+          customInputs: {},
+          metadata: {},
+          responses: {
+            name: "Oldie",
+            email: "oldie@gmail.com",
+          },
+          attendees: {
+            create: {
+              email: "oldie@gmail.com",
+              name: "Oldie",
+              locale: "lv",
+              timeZone: "Europe/Rome",
+            },
+          },
+        });
+
+        const body: RescheduleBookingInput_2024_08_13 = {
+          start: new Date(Date.UTC(2040, 0, 9, 14, 0, 0)).toISOString(),
+          reschedulingReason: "Flying to mars that day",
+        };
+
+        const response = await request(app.getHttpServer())
+          .post(`/v2/bookings/${rescheduledBooking.uid}/reschedule`)
+          .send(body)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+          .expect(400);
+
+        expect(response.body.error.message).toEqual(
+          `Can't reschedule booking with uid=${rescheduledBooking.uid} because it has been cancelled and rescheduled already to booking with uid=${newBooking.uid}. You probably want to reschedule ${newBooking.uid} instead by passing it within the request URL.`
+        );
+        await bookingsRepositoryFixture.deleteById(rescheduledBooking.id);
+        await bookingsRepositoryFixture.deleteById(newBooking.id);
+      });
+    });
+
+    describe("calendar events", () => {
+      beforeEach(() => {
+        jest.restoreAllMocks();
+        jest
+          .spyOn(EventManager.prototype, "create")
+          .mockImplementation(() => Promise.resolve({ results: [], referencesToCreate: [] }));
+      });
+
+      describe("platform oAuth client has calendar events enabled", () => {
+        beforeAll(async () => {
+          await oauthClientRepositoryFixture.update(oAuthClient.id, {
+            areCalendarEventsEnabled: true,
+          });
+        });
+
+        it("should create calendar event when booking normal event", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2040, 0, 9, 9, 0, 0)).toISOString(),
+            eventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(201)
+            .then(async (response) => {
+              const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+              if (responseDataIsBooking(responseBody.data)) {
+                const data: BookingOutput_2024_08_13 = responseBody.data;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(EventManager.prototype.create).toHaveBeenCalledTimes(1);
+              } else {
+                throw new Error(
+                  "Invalid response data - expected booking but received array of possibly recurring bookings"
+                );
+              }
+            });
+        });
+
+        it("should create calendar events when booking recurring event", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2040, 0, 10, 9, 0, 0)).toISOString(),
+            eventTypeId: recurringEventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(201)
+            .then(async (response) => {
+              const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(EventManager.prototype.create).toHaveBeenCalledTimes(3);
+            });
+        });
+
+        describe("event type requires confirmation", () => {
+          let bookingThatRequiresConfirmationUid: string;
+
+          it("should not create calendar event when booking event that requires confirmation", async () => {
+            const body: CreateBookingInput_2024_08_13 = {
+              start: new Date(Date.UTC(2040, 0, 12, 9, 0, 0)).toISOString(),
+              eventTypeId: eventTypeRequiresConfirmationId,
+              attendee: {
+                name: "Mr Proper",
+                email: "mr_proper@gmail.com",
+                timeZone: "Europe/Rome",
+                language: "it",
+              },
+            };
+
+            return request(app.getHttpServer())
+              .post("/v2/bookings")
+              .send(body)
+              .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+              .expect(201)
+              .then(async (response) => {
+                const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+                expect(responseBody.status).toEqual(SUCCESS_STATUS);
+                expect(responseBody.data).toBeDefined();
+                expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+                if (responseDataIsBooking(responseBody.data)) {
+                  const data: BookingOutput_2024_08_13 = responseBody.data;
+                  expect(data.id).toBeDefined();
+                  expect(data.uid).toBeDefined();
+                  expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+                  bookingThatRequiresConfirmationUid = data.uid;
+                } else {
+                  throw new Error(
+                    "Invalid response data - expected booking but received array of possibly recurring bookings"
+                  );
+                }
+              });
+          });
+
+          it("should create calendar event when confirming event that requires confirmation", async () => {
+            return request(app.getHttpServer())
+              .post(`/v2/bookings/${bookingThatRequiresConfirmationUid}/confirm`)
+              .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+              .expect(200)
+              .then(async (response) => {
+                const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+                expect(responseBody.status).toEqual(SUCCESS_STATUS);
+                expect(responseBody.data).toBeDefined();
+                expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+                if (responseDataIsBooking(responseBody.data)) {
+                  const data: BookingOutput_2024_08_13 = responseBody.data;
+                  expect(data.id).toBeDefined();
+                  expect(data.uid).toBeDefined();
+                  expect(EventManager.prototype.create).toHaveBeenCalledTimes(1);
+                } else {
+                  throw new Error(
+                    "Invalid response data - expected booking but received array of possibly recurring bookings"
+                  );
+                }
+              });
+          });
+        });
+      });
+
+      describe("platform oAuth client has calendar events disabled", () => {
+        beforeAll(async () => {
+          await oauthClientRepositoryFixture.update(oAuthClient.id, {
+            areCalendarEventsEnabled: false,
+          });
+        });
+
+        it("should not create calendar event when booking", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2040, 0, 9, 10, 0, 0)).toISOString(),
+            eventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+          };
+
+          const beforeCreate = new Date();
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(201)
+            .then(async (response) => {
+              const afterCreate = new Date();
+              const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+              if (responseDataIsBooking(responseBody.data)) {
+                const data: BookingOutput_2024_08_13 = responseBody.data;
+                expect(data.id).toBeDefined();
+                expect(data.uid).toBeDefined();
+                expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+              } else {
+                throw new Error(
+                  "Invalid response data - expected booking but received array of possibly recurring bookings"
+                );
+              }
+            });
+        });
+
+        it("should not create calendar events when booking recurring event", async () => {
+          const body: CreateBookingInput_2024_08_13 = {
+            start: new Date(Date.UTC(2040, 0, 11, 10, 0, 0)).toISOString(),
+            eventTypeId: recurringEventTypeId,
+            attendee: {
+              name: "Mr Proper",
+              email: "mr_proper@gmail.com",
+              timeZone: "Europe/Rome",
+              language: "it",
+            },
+          };
+
+          return request(app.getHttpServer())
+            .post("/v2/bookings")
+            .send(body)
+            .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+            .expect(201)
+            .then(async (response) => {
+              const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+              expect(responseBody.status).toEqual(SUCCESS_STATUS);
+              expect(responseBody.data).toBeDefined();
+              expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+            });
+        });
+
+        describe("event type requires confirmation", () => {
+          let bookingThatRequiresConfirmationUid: string;
+
+          it("should not create calendar event when booking event that requires confirmation", async () => {
+            const body: CreateBookingInput_2024_08_13 = {
+              start: new Date(Date.UTC(2040, 0, 12, 10, 0, 0)).toISOString(),
+              eventTypeId: eventTypeRequiresConfirmationId,
+              attendee: {
+                name: "Mr Proper",
+                email: "mr_proper@gmail.com",
+                timeZone: "Europe/Rome",
+                language: "it",
+              },
+            };
+
+            return request(app.getHttpServer())
+              .post("/v2/bookings")
+              .send(body)
+              .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+              .expect(201)
+              .then(async (response) => {
+                const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+                expect(responseBody.status).toEqual(SUCCESS_STATUS);
+                expect(responseBody.data).toBeDefined();
+                expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+                if (responseDataIsBooking(responseBody.data)) {
+                  const data: BookingOutput_2024_08_13 = responseBody.data;
+                  expect(data.id).toBeDefined();
+                  expect(data.uid).toBeDefined();
+                  expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+                  bookingThatRequiresConfirmationUid = data.uid;
+                } else {
+                  throw new Error(
+                    "Invalid response data - expected booking but received array of possibly recurring bookings"
+                  );
+                }
+              });
+          });
+
+          it("should not create calendar event when confirming event that requires confirmation", async () => {
+            return request(app.getHttpServer())
+              .post(`/v2/bookings/${bookingThatRequiresConfirmationUid}/confirm`)
+              .set(CAL_API_VERSION_HEADER, VERSION_2024_08_13)
+              .expect(200)
+              .then(async (response) => {
+                const responseBody: CreateBookingOutput_2024_08_13 = response.body;
+                expect(responseBody.status).toEqual(SUCCESS_STATUS);
+                expect(responseBody.data).toBeDefined();
+                expect(responseDataIsBooking(responseBody.data)).toBe(true);
+
+                if (responseDataIsBooking(responseBody.data)) {
+                  const data: BookingOutput_2024_08_13 = responseBody.data;
+                  expect(data.id).toBeDefined();
+                  expect(data.uid).toBeDefined();
+                  expect(EventManager.prototype.create).toHaveBeenCalledTimes(0);
+                } else {
+                  throw new Error(
+                    "Invalid response data - expected booking but received array of possibly recurring bookings"
+                  );
+                }
+              });
+          });
+        });
+      });
+    });
+
    function responseDataIsRecurranceBooking(data: any): data is RecurringBookingOutput_2024_08_13 {
      return (
        !Array.isArray(data) &&
@@ -5,6 +5,7 @@ import { InputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/servic
 import { OutputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/output.service";
 import { PlatformBookingsService } from "@/ee/bookings/shared/platform-bookings.service";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { getPagination } from "@/lib/pagination/pagination";
 import { BillingService } from "@/modules/billing/services/billing.service";
 import { BookingSeatRepository } from "@/modules/booking-seat/booking-seat.repository";
 import { KyselyReadService } from "@/modules/kysely/kysely-read.service";
@@ -403,6 +404,7 @@ export class BookingsService_2024_08_13 {
      platformBookingUrl: bookingRequest.platformBookingUrl,
      platformBookingLocation: bookingRequest.platformBookingLocation,
      noEmail: bookingRequest.noEmail,
+      areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
    });
    const ids = bookings.map((booking) => booking.id || 0);
    return this.outputService.getOutputRecurringBookings(ids);
@@ -423,6 +425,7 @@ export class BookingsService_2024_08_13 {
      platformCancelUrl: bookingRequest.platformCancelUrl,
      platformBookingUrl: bookingRequest.platformBookingUrl,
      platformBookingLocation: bookingRequest.platformBookingLocation,
+      areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
    });
    return this.outputService.getOutputCreateRecurringSeatedBookings(
      bookings.map((booking) => ({ uid: booking.uid || "", seatUid: booking.seatReferenceUid || "" }))
@@ -444,6 +447,7 @@ export class BookingsService_2024_08_13 {
      platformCancelUrl: bookingRequest.platformCancelUrl,
      platformBookingUrl: bookingRequest.platformBookingUrl,
      platformBookingLocation: bookingRequest.platformBookingLocation,
+      areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
    });

    if (!booking.uid) {
@@ -474,6 +478,7 @@ export class BookingsService_2024_08_13 {
        platformCancelUrl: bookingRequest.platformCancelUrl,
        platformBookingUrl: bookingRequest.platformBookingUrl,
        platformBookingLocation: bookingRequest.platformBookingLocation,
+        areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
      });

      if (!booking.uid) {
@@ -538,10 +543,13 @@ export class BookingsService_2024_08_13 {
      queryParams.attendeeEmail = await this.getAttendeeEmail(queryParams.attendeeEmail, user);
    }

+    const skip = Math.abs(queryParams?.skip ?? 0);
+    const take = Math.abs(queryParams?.take ?? 100);
+
    const fetchedBookings: { bookings: { id: number }[]; totalCount: number } = await getAllUserBookings({
      bookingListingByStatus: queryParams.status || [],
-      skip: queryParams.skip ?? 0,
-      take: queryParams.take ?? 100,
+      skip,
+      take,
      filters: {
        ...this.inputService.transformGetBookingsFilters(queryParams),
        ...(userIds?.length ? { userIds } : {}),
@@ -594,28 +602,11 @@ export class BookingsService_2024_08_13 {
      }
    }

-    const skip = Math.abs(queryParams?.skip ?? 0);
-    const take = Math.abs(queryParams?.take ?? 100);
-    const itemsPerPage = take;
-    const totalPages = itemsPerPage !== 0 ? Math.ceil(fetchedBookings.totalCount / itemsPerPage) : 0;
-    const currentPage = Math.floor(skip / itemsPerPage) + 1;
-    const hasNextPage = skip + itemsPerPage < fetchedBookings.totalCount;
-    const hasPreviousPage = skip > 0;
+    const pagination = getPagination({ skip, take, totalCount: fetchedBookings.totalCount });
+
    return {
      bookings: formattedBookings,
-      pagination: {
-        totalItems: fetchedBookings.totalCount,
-        // clamp remainingItems between 0 and totalCount
-        remainingItems: Math.min(
-          Math.max(fetchedBookings.totalCount - (skip + take), 0),
-          fetchedBookings.totalCount
-        ),
-        itemsPerPage: itemsPerPage,
-        currentPage: currentPage,
-        totalPages: totalPages,
-        hasNextPage: hasNextPage,
-        hasPreviousPage: hasPreviousPage,
-      },
+      pagination,
    };
  }

@@ -650,6 +641,7 @@ export class BookingsService_2024_08_13 {

  async rescheduleBooking(request: Request, bookingUid: string, body: RescheduleBookingInput) {
    try {
+      await this.canRescheduleBooking(bookingUid);
      const bookingRequest = await this.inputService.createRescheduleBookingRequest(
        request,
        bookingUid,
@@ -664,6 +656,7 @@ export class BookingsService_2024_08_13 {
        platformCancelUrl: bookingRequest.platformCancelUrl,
        platformBookingUrl: bookingRequest.platformBookingUrl,
        platformBookingLocation: bookingRequest.platformBookingLocation,
+        areCalendarEventsEnabled: bookingRequest.areCalendarEventsEnabled,
      });
      if (!booking.uid) {
        throw new Error("Booking missing uid");
@@ -695,15 +688,29 @@ export class BookingsService_2024_08_13 {
      }
      return this.outputService.getOutputBooking(databaseBooking);
    } catch (error) {
-      if (error instanceof Error) {
-        if (error.message === "no_available_users_found_error") {
-          throw new BadRequestException("User either already has booking at this time or is not available");
-        }
-      }
-      throw error;
+      this.errorsBookingsService.handleBookingError(error, false);
    }
  }

+  async canRescheduleBooking(bookingUid: string) {
+    const booking = await this.bookingsRepository.getByUid(bookingUid);
+    if (!booking) {
+      throw new Error(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+    if (booking.status === "CANCELLED" && !booking.rescheduled) {
+      throw new BadRequestException(
+        `Can't reschedule booking with uid=${bookingUid} because it has been cancelled. Please provide uid of a booking that is not cancelled.`
+      );
+    }
+    if (booking.status === "CANCELLED" && booking.rescheduled) {
+      const rescheduledTo = await this.bookingsRepository.getByFromReschedule(bookingUid);
+      throw new BadRequestException(
+        `Can't reschedule booking with uid=${bookingUid} because it has been cancelled and rescheduled already to booking with uid=${rescheduledTo?.uid}. You probably want to reschedule ${rescheduledTo?.uid} instead by passing it within the request URL.`
+      );
+    }
+    return booking;
+  }
+
  async cancelBooking(request: Request, bookingUid: string, body: CancelBookingInput) {
    if (this.inputService.isCancelSeatedBody(body)) {
      const seat = await this.bookingSeatRepository.getByReferenceUid(body.seatUid);
@@ -928,15 +935,19 @@ export class BookingsService_2024_08_13 {
      : undefined;

    const emailsEnabled = platformClientParams ? platformClientParams.arePlatformEmailsEnabled : true;
+    const userCalendars = await this.usersRepository.findByIdWithCalendars(requestUser.id);

    await confirmBookingHandler({
      ctx: {
-        user: requestUser,
+        user: {
+          ...requestUser,
+          destinationCalendar: userCalendars?.destinationCalendar ?? null,
+        },
      },
      input: {
        bookingId: booking.id,
        confirmed: true,
-        recurringEventId: booking.recurringEventId,
+        recurringEventId: booking.recurringEventId ?? undefined,
        emailsEnabled,
        platformClientParams,
      },
@@ -956,15 +967,19 @@ export class BookingsService_2024_08_13 {
      : undefined;

    const emailsEnabled = platformClientParams ? platformClientParams.arePlatformEmailsEnabled : true;
+    const userCalendars = await this.usersRepository.findByIdWithCalendars(requestUser.id);

    await confirmBookingHandler({
      ctx: {
-        user: requestUser,
+        user: {
+          ...requestUser,
+          destinationCalendar: userCalendars?.destinationCalendar ?? null,
+        },
      },
      input: {
        bookingId: booking.id,
        confirmed: false,
-        recurringEventId: booking.recurringEventId,
+        recurringEventId: booking.recurringEventId ?? undefined,
        reason,
        emailsEnabled,
        platformClientParams,
@@ -0,0 +1,83 @@
+import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.repository";
+import { OutputBookingsService_2024_08_13 } from "@/ee/bookings/2024-08-13/services/output.service";
+import { Injectable, Logger, NotFoundException } from "@nestjs/common";
+
+import {
+  getRecordingsOfCalVideoByRoomName,
+  getAllTranscriptsAccessLinkFromRoomName,
+  getDownloadLinkOfCalVideoByRecordingId,
+} from "@calcom/platform-libraries/conferencing";
+
+@Injectable()
+export class CalVideoService {
+  private readonly logger = new Logger("CalVideoService");
+  constructor(
+    private readonly bookingsRepository: BookingsRepository_2024_08_13,
+    private readonly outputService: OutputBookingsService_2024_08_13
+  ) {}
+
+  async getRecordings(bookingUid: string) {
+    const booking = await this.bookingsRepository.getByUidWithBookingReference(bookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    const roomName =
+      booking?.references?.filter((reference) => reference.type === "daily_video")?.pop()?.meetingId ??
+      undefined;
+    if (!roomName) {
+      throw new NotFoundException(`No Cal Video reference found with booking uid ${bookingUid}`);
+    }
+
+    const recordings = await getRecordingsOfCalVideoByRoomName(roomName);
+
+    if (!recordings || !("data" in recordings)) return [];
+
+    const recordingWithDownloadLink = recordings.data.map((recording) => {
+      return getDownloadLinkOfCalVideoByRecordingId(recording.id)
+        .then((res: { download_link: string } | undefined) => ({
+          id: recording.id,
+          roomName: recording.room_name,
+          startTs: recording.start_ts,
+          status: recording.status,
+          maxParticipants: recording.max_participants,
+          duration: recording.duration,
+          shareToken: recording.share_token,
+          downloadLink: res?.download_link,
+        }))
+        .catch((err: Error) => ({
+          id: recording.id,
+          roomName: recording.room_name,
+          startTs: recording.start_ts,
+          status: recording.status,
+          maxParticipants: recording.max_participants,
+          duration: recording.duration,
+          shareToken: recording.share_token,
+          downloadLink: null,
+          error: err.message,
+        }));
+    });
+    const allRecordingsWithDownloadLink = await Promise.all(recordingWithDownloadLink);
+
+    return allRecordingsWithDownloadLink;
+  }
+
+  async getTranscripts(bookingUid: string) {
+    const booking = await this.bookingsRepository.getByUidWithBookingReference(bookingUid);
+    if (!booking) {
+      throw new NotFoundException(`Booking with uid=${bookingUid} was not found in the database`);
+    }
+
+    const roomName =
+      booking?.references?.filter((reference) => reference.type === "daily_video")?.pop()?.meetingId ??
+      undefined;
+
+    if (!roomName) {
+      throw new NotFoundException(`No Cal Video reference found with booking uid ${bookingUid}`);
+    }
+
+    const transcripts = await getAllTranscriptsAccessLinkFromRoomName(roomName);
+
+    return transcripts;
+  }
+}
@@ -10,6 +10,7 @@ import {
 import { PlatformBookingsService } from "@/ee/bookings/shared/platform-bookings.service";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
 import { OutputEventTypesService_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/services/output-event-types.service";
+import { apiToInternalintegrationsMapping } from "@/ee/event-types/event-types_2024_06_14/transformers";
 import { hashAPIKey, isApiKey, stripApiKey } from "@/lib/api-key";
 import { defaultBookingResponses } from "@/lib/safe-parse/default-responses-booking";
 import { safeParse } from "@/lib/safe-parse/safe-parse";
@@ -29,10 +30,7 @@ import { NextApiRequest } from "next/types";
 import { v4 as uuidv4 } from "uuid";
 import { z } from "zod";

-import {
-  EventTypeMetaDataSchema,
-  apiToInternalintegrationsMapping,
-} from "@calcom/platform-libraries/event-types";
+import { EventTypeMetaDataSchema } from "@calcom/platform-libraries/event-types";
 import {
  CancelBookingInput,
  CancelBookingInput_2024_08_13,
@@ -61,6 +59,7 @@ type OAuthRequestParams = {
  platformBookingUrl: string;
  platformBookingLocation?: string;
  arePlatformEmailsEnabled: boolean;
+  areCalendarEventsEnabled: boolean;
 };

 export enum Frequency {
@@ -587,6 +586,11 @@ export class InputBookingsService_2024_08_13 {
    if (!eventType) {
      throw new NotFoundException(`Event type with id=${booking.eventTypeId} not found`);
    }
+    if (eventType.seatsPerTimeSlot) {
+      throw new BadRequestException(
+        `Booking with uid=${bookingUid} is a seated booking which means you have to provide seatUid in the request body to specify which seat specifically you want to reschedule. First, fetch the booking using https://cal.com/docs/api-reference/v2/bookings/get-a-booking and then within the attendees array you will find the seatUid of the booking you want to reschedule. Second, provide the seatUid in the request body to specify which seat specifically you want to reschedule using the reschedule endpoint https://cal.com/docs/api-reference/v2/bookings/reschedule-a-booking#option-2`
+      );
+    }

    const bookingResponses = safeParse(
      bookingResponsesSchema,
@@ -22,7 +22,7 @@ import {
  RecurringBookingOutput_2024_08_13,
  SeatedAttendee,
 } from "@calcom/platform-types";
-import { Booking, BookingReference, BookingSeat } from "@calcom/prisma/client";
+import { Booking, BookingSeat } from "@calcom/prisma/client";

 export const bookingResponsesSchema = z
  .object({
@@ -266,6 +266,7 @@ export class OutputBookingsService_2024_08_13 {
      description: databaseBooking.description,
      hosts: [this.getHost(databaseBooking.user)],
      status: databaseBooking.status.toLowerCase(),
+      cancellationReason: databaseBooking.cancellationReason || undefined,
      rescheduledFromUid: databaseBooking.fromReschedule || undefined,
      start: databaseBooking.startTime,
      end: databaseBooking.endTime,
@@ -54,6 +54,7 @@ export class PlatformBookingsService {
        platformRescheduleUrl: oAuthClient.bookingRescheduleRedirectUri,
        platformBookingUrl: oAuthClient.bookingRedirectUri,
        arePlatformEmailsEnabled: oAuthClient.areEmailsEnabled,
+        areCalendarEventsEnabled: oAuthClient.areCalendarEventsEnabled,
      };
    }

@@ -78,6 +79,7 @@ export class PlatformBookingsService {
        platformRescheduleUrl: oAuthClient.bookingRescheduleRedirectUri,
        platformBookingUrl: oAuthClient.bookingRedirectUri,
        arePlatformEmailsEnabled: oAuthClient.areEmailsEnabled,
+        areCalendarEventsEnabled: oAuthClient.areCalendarEventsEnabled,
      };
    }

@@ -1,3 +1,5 @@
+import { BookingReferencesRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/booking-references.repository";
+import { BookingsRepository_2024_08_13 } from "@/ee/bookings/2024-08-13/bookings.repository";
 import { CalendarsRepository } from "@/ee/calendars/calendars.repository";
 import { CalendarsController } from "@/ee/calendars/controllers/calendars.controller";
 import { AppleCalendarService } from "@/ee/calendars/services/apple-calendar.service";
@@ -25,8 +27,10 @@ import { Module } from "@nestjs/common";
    SelectedCalendarsRepository,
    AppsRepository,
    CalendarsRepository,
+    BookingsRepository_2024_08_13,
+    BookingReferencesRepository_2024_08_13,
  ],
  controllers: [CalendarsController],
-  exports: [CalendarsService],
+  exports: [CalendarsService, GoogleCalendarService],
 })
 export class CalendarsModule {}
@@ -54,6 +54,23 @@ import {
 } from "@calcom/platform-constants";
 import { ApiResponse, CalendarBusyTimesInput, CreateCalendarCredentialsInput } from "@calcom/platform-types";

+export interface CalendarState {
+  accessToken: string;
+  origin: string;
+  redir?: string;
+  isDryRun?: boolean;
+}
+
+const calendarStateSchema = z.object({
+  accessToken: z.string(),
+  origin: z.string(),
+  redir: z.string().optional(),
+  isDryRun: z
+    .string()
+    .optional()
+    .transform((val) => val === "true"),
+});
+
@Controller({
  path: "/v2/calendars",
  version: API_VERSIONS_VALUES,
@@ -181,32 +198,31 @@ export class CalendarsController {
    @Query("code") code: string,
    @Param("calendar") calendar: string
  ): Promise<{ url: string }> {
-    // state params contains our user access token
-    const stateParams = new URLSearchParams(state);
-    const { accessToken, origin, redir, isDryRun } = z
-      .object({
-        accessToken: z.string(),
-        origin: z.string(),
-        redir: z.string().nullish().optional(),
-        isDryRun: z.string().nullish().optional(),
-      })
-      .parse({
+    let stateObj: CalendarState;
+
+    try {
+      // First try to parse as JSON
+      stateObj = JSON.parse(state) as CalendarState;
+    } catch (e) {
+      // If JSON parsing fails, try URL params
+      const stateParams = new URLSearchParams(state);
+
+      const parsedState = calendarStateSchema.parse({
        accessToken: stateParams.get("accessToken"),
        origin: stateParams.get("origin"),
-        redir: stateParams.get("redir"),
+        redir: stateParams.get("redir") || undefined,
        isDryRun: stateParams.get("isDryRun"),
      });
+
+      stateObj = parsedState;
+    }
+
+    const { accessToken, origin, redir, isDryRun } = stateObj;
    switch (calendar) {
      case OFFICE_365_CALENDAR:
-        return await this.outlookService.save(code, accessToken, origin, redir ?? "", isDryRun === "true");
+        return await this.outlookService.save(code, accessToken, origin, redir ?? "", !!isDryRun);
      case GOOGLE_CALENDAR:
-        return await this.googleCalendarService.save(
-          code,
-          accessToken,
-          origin,
-          redir ?? "",
-          isDryRun === "true"
-        );
+        return await this.googleCalendarService.save(code, accessToken, origin, redir ?? "", !!isDryRun);
      default:
        throw new BadRequestException(
          "Invalid calendar type, available calendars are: ",
@@ -22,6 +22,7 @@ import { APPS_TYPE_ID_MAPPING } from "@calcom/platform-constants";
 import {
  getConnectedDestinationCalendarsAndEnsureDefaultsInDb,
  getBusyCalendarTimes,
+  type EventBusyDate,
 } from "@calcom/platform-libraries";
 import { Calendar } from "@calcom/platform-types";
 import { PrismaClient } from "@calcom/prisma";
@@ -45,6 +46,7 @@ export class CalendarsService {
        ...credential,
        delegatedTo: null,
        delegatedToId: null,
+        delegationCredentialId: null,
      }))
      .filter((credential) => !!credential);
  }
@@ -88,18 +90,19 @@ export class CalendarsService {
        dateTo,
        composedSelectedCalendars
      );
-      // @ts-expect-error Element implicitly has any type
-      const calendarBusyTimesConverted = calendarBusyTimes.map((busyTime) => {
-        const busyTimeStart = DateTime.fromJSDate(new Date(busyTime.start)).setZone(timezone);
-        const busyTimeEnd = DateTime.fromJSDate(new Date(busyTime.end)).setZone(timezone);
-        const busyTimeStartDate = busyTimeStart.toJSDate();
-        const busyTimeEndDate = busyTimeEnd.toJSDate();
-        return {
-          ...busyTime,
-          start: busyTimeStartDate,
-          end: busyTimeEndDate,
-        };
-      });
+      const calendarBusyTimesConverted = calendarBusyTimes.map(
+        (busyTime: EventBusyDate & { timeZone?: string }) => {
+          const busyTimeStart = DateTime.fromJSDate(new Date(busyTime.start)).setZone(timezone);
+          const busyTimeEnd = DateTime.fromJSDate(new Date(busyTime.end)).setZone(timezone);
+          const busyTimeStartDate = busyTimeStart.toJSDate();
+          const busyTimeEndDate = busyTimeEnd.toJSDate();
+          return {
+            ...busyTime,
+            start: busyTimeStartDate,
+            end: busyTimeEndDate,
+          };
+        }
+      );
      return calendarBusyTimesConverted;
    } catch (error) {
      throw new InternalServerErrorException(
@@ -1,4 +1,5 @@
 import { OAuthCalendarApp } from "@/ee/calendars/calendars.interface";
+import type { CalendarState } from "@/ee/calendars/controllers/calendars.controller";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { AppsRepository } from "@/modules/apps/apps.repository";
 import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
@@ -23,7 +24,7 @@ const CALENDAR_SCOPES = [

@Injectable()
 export class GoogleCalendarService implements OAuthCalendarApp {
-  private redirectUri = `${this.config.get("api.url")}/gcal/oauth/save`;
+  public readonly redirectUri = `${this.config.get("api.url")}/gcal/oauth/save`;
  private gcalResponseSchema = z.object({ client_id: z.string(), client_secret: z.string() });
  private logger = new Logger("GcalService");

@@ -65,12 +66,18 @@ export class GoogleCalendarService implements OAuthCalendarApp {

  async getCalendarRedirectUrl(accessToken: string, origin: string, redir?: string, isDryRun?: boolean) {
    const oAuth2Client = await this.getOAuthClient(this.redirectUri);
+    const state: CalendarState = {
+      accessToken,
+      origin,
+      redir,
+      isDryRun,
+    };

    const authUrl = oAuth2Client.generateAuthUrl({
      access_type: "offline",
      scope: CALENDAR_SCOPES,
      prompt: "consent",
-      state: `accessToken=${accessToken}&origin=${origin}&redir=${redir ?? ""}&isDryRun=${isDryRun}`,
+      state: JSON.stringify(state),
    });

    return authUrl;
@@ -1,4 +1,5 @@
 import { OAuthCalendarApp } from "@/ee/calendars/calendars.interface";
+import { CalendarState } from "@/ee/calendars/controllers/calendars.controller";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { CredentialsRepository } from "@/modules/credentials/credentials.repository";
 import { SelectedCalendarsRepository } from "@/modules/selected-calendars/selected-calendars.repository";
@@ -60,6 +61,13 @@ export class OutlookService implements OAuthCalendarApp {
  async getCalendarRedirectUrl(accessToken: string, origin: string, redir?: string, isDryRun?: boolean) {
    const { client_id } = await this.calendarsService.getAppKeys(OFFICE_365_CALENDAR_ID);

+    const state: CalendarState = {
+      accessToken,
+      origin,
+      redir,
+      isDryRun,
+    };
+
    const scopes = ["User.Read", "Calendars.Read", "Calendars.ReadWrite", "offline_access"];
    const params = {
      response_type: "code",
@@ -67,7 +75,7 @@ export class OutlookService implements OAuthCalendarApp {
      client_id,
      prompt: "select_account",
      redirect_uri: this.redirectUri,
-      state: `accessToken=${accessToken}&origin=${origin}&redir=${redir ?? ""}&isDryRun=${isDryRun}`,
+      state: JSON.stringify(state),
    };

    const query = stringify(params);
@@ -18,6 +18,7 @@ import { GetUser } from "@/modules/auth/decorators/get-user/get-user.decorator";
 import { Permissions } from "@/modules/auth/decorators/permissions/permissions.decorator";
 import { ApiAuthGuard } from "@/modules/auth/guards/api-auth/api-auth.guard";
 import { PermissionsGuard } from "@/modules/auth/guards/permissions/permissions.guard";
+import { OrganizationsRepository } from "@/modules/organizations/index/organizations.repository";
 import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
 import { UserWithProfile } from "@/modules/users/users.repository";
 import {
@@ -33,13 +34,19 @@ import {
  HttpStatus,
  Delete,
  Query,
+  Headers,
  InternalServerErrorException,
  ParseIntPipe,
 } from "@nestjs/common";
 import { ApiExcludeController as DocsExcludeController } from "@nestjs/swagger";

-import { EVENT_TYPE_READ, EVENT_TYPE_WRITE, SUCCESS_STATUS } from "@calcom/platform-constants";
-import { getPublicEvent, getEventTypesByViewer } from "@calcom/platform-libraries-0.0.2";
+import {
+  EVENT_TYPE_READ,
+  EVENT_TYPE_WRITE,
+  SUCCESS_STATUS,
+  X_CAL_CLIENT_ID,
+} from "@calcom/platform-constants";
+import { getPublicEvent, getEventTypesByViewer } from "@calcom/platform-libraries/event-types";
 import { PrismaClient } from "@calcom/prisma";

@Controller({
@@ -51,7 +58,8 @@ import { PrismaClient } from "@calcom/prisma";
 export class EventTypesController_2024_04_15 {
  constructor(
    private readonly eventTypesService: EventTypesService_2024_04_15,
-    private readonly prismaReadService: PrismaReadService
+    private readonly prismaReadService: PrismaReadService,
+    private readonly organizationsRepository: OrganizationsRepository
  ) {}

  @Post("/")
@@ -109,19 +117,30 @@ export class EventTypesController_2024_04_15 {
  async getPublicEventType(
    @Param("username") username: string,
    @Param("eventSlug") eventSlug: string,
-    @Query() queryParams: GetPublicEventTypeQueryParams_2024_04_15
+    @Query() queryParams: GetPublicEventTypeQueryParams_2024_04_15,
+    @Headers(X_CAL_CLIENT_ID) clientId?: string
  ): Promise<GetEventTypePublicOutput> {
    try {
+      let orgSlug = queryParams.org;
+
+      if (clientId && !orgSlug && username.includes(`-${clientId}`)) {
+        const org = await this.organizationsRepository.findTeamIdAndSlugFromClientId(clientId).catch(() => null);
+        if (org) {
+          orgSlug = org.slug;
+        }
+      }
+
      const event = await getPublicEvent(
        username.toLowerCase(),
        eventSlug,
        queryParams.isTeamEvent,
-        queryParams.org || null,
+        orgSlug ?? null,
        this.prismaReadService.prisma as unknown as PrismaClient,
        // We should be fine allowing unpublished orgs events to be servable through platform because Platform access is behind license
        // If there is ever a need to restrict this, we can introduce a new query param `fromRedirectOfNonOrgLink`
        true
      );
+
      return {
        data: event,
        status: SUCCESS_STATUS,
@@ -2,6 +2,7 @@ import { EventTypesController_2024_04_15 } from "@/ee/event-types/event-types_20
 import { EventTypesRepository_2024_04_15 } from "@/ee/event-types/event-types_2024_04_15/event-types.repository";
 import { EventTypesService_2024_04_15 } from "@/ee/event-types/event-types_2024_04_15/services/event-types.service";
 import { MembershipsModule } from "@/modules/memberships/memberships.module";
+import { OrganizationsModule } from "@/modules/organizations/organizations.module";
 import { PrismaModule } from "@/modules/prisma/prisma.module";
 import { SelectedCalendarsModule } from "@/modules/selected-calendars/selected-calendars.module";
 import { TokensModule } from "@/modules/tokens/tokens.module";
@@ -9,7 +10,14 @@ import { UsersModule } from "@/modules/users/users.module";
 import { Module } from "@nestjs/common";

@Module({
-  imports: [PrismaModule, MembershipsModule, TokensModule, UsersModule, SelectedCalendarsModule],
+  imports: [
+    PrismaModule,
+    MembershipsModule,
+    TokensModule,
+    UsersModule,
+    SelectedCalendarsModule,
+    OrganizationsModule,
+  ],
  providers: [EventTypesRepository_2024_04_15, EventTypesService_2024_04_15],
  controllers: [EventTypesController_2024_04_15],
  exports: [EventTypesService_2024_04_15, EventTypesRepository_2024_04_15],
@@ -5,6 +5,7 @@ import { Editable } from "@/ee/event-types/event-types_2024_04_15/inputs/enums/e
 import { BaseField } from "@/ee/event-types/event-types_2024_04_15/inputs/enums/field-type";
 import { UpdateEventTypeInput_2024_04_15 } from "@/ee/event-types/event-types_2024_04_15/inputs/update-event-type.input";
 import { EventTypeOutput } from "@/ee/event-types/event-types_2024_04_15/outputs/event-type.output";
+import { systemBeforeFieldEmail } from "@/ee/event-types/event-types_2024_06_14/transformers";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { SelectedCalendarsRepository } from "@/modules/selected-calendars/selected-calendars.repository";
@@ -17,7 +18,6 @@ import {
  updateEventType,
  EventTypesPublic,
  getEventTypesPublic,
-  systemBeforeFieldEmail,
 } from "@calcom/platform-libraries/event-types";
 import { EventType } from "@calcom/prisma/client";

@@ -1,4 +1,4 @@
-import { OrganizerIntegrationLocation } from "@calcom/lib/event-types/transformers/internal/locations";
+import { OrganizerIntegrationLocation } from "@/ee/event-types/event-types_2024_06_14/transformers";

 type BaseEventType = {
  length: number;
@@ -34,6 +34,7 @@ import {
  ApiSuccessResponse,
  CreateEventTypeInput_2024_06_14,
  EventTypeOutput_2024_06_14,
+  GuestsDefaultFieldOutput_2024_06_14,
  NameDefaultFieldInput_2024_06_14,
  NotesDefaultFieldInput_2024_06_14,
  UpdateEventTypeInput_2024_06_14,
@@ -535,6 +536,7 @@ describe("Event types Endpoints", () => {
            body.lockTimeZoneToggleOnBookingPage
          );
          expect(createdEventType.color).toEqual(body.color);
+          expect(createdEventType.disableGuests).toEqual(false);

          const expectedBookingFields = [
            { ...defaultResponseBookingFieldName, ...nameBookingField },
@@ -962,6 +964,10 @@ describe("Event types Endpoints", () => {
        title: newTitle,
        scheduleId: secondSchedule.id,
        lengthInMinutesOptions: [15, 30],
+        calVideoSettings: {
+          disableRecordingForGuests: true,
+          disableRecordingForOrganizer: true,
+        },
        bookingFields: [
          nameBookingField,
          {
@@ -1037,6 +1043,7 @@ describe("Event types Endpoints", () => {
          expect(updatedEventType.description).toEqual(eventType.description);
          expect(updatedEventType.lengthInMinutes).toEqual(eventType.lengthInMinutes);
          expect(updatedEventType.locations).toEqual(eventType.locations);
+          expect(updatedEventType.disableGuests).toEqual(false);

          const expectedBookingFields = [
            { ...defaultResponseBookingFieldName, ...nameBookingField },
@@ -1082,6 +1089,12 @@ describe("Event types Endpoints", () => {
            body.lockTimeZoneToggleOnBookingPage
          );
          expect(updatedEventType.color).toEqual(body.color);
+          expect(updatedEventType.calVideoSettings?.disableRecordingForGuests).toEqual(
+            body.calVideoSettings?.disableRecordingForGuests
+          );
+          expect(updatedEventType.calVideoSettings?.disableRecordingForOrganizer).toEqual(
+            body.calVideoSettings?.disableRecordingForOrganizer
+          );

          eventType.title = newTitle;
          eventType.scheduleId = secondSchedule.id;
@@ -1708,7 +1721,7 @@ describe("Event types Endpoints", () => {
        description: "undefined booking fields",
        length: 40,
        hidden: false,
-        slug: "undefined-booking-fields",
+        slug: `undefined-booking-fields-${randomString()}`,
        locations: [],
        schedulingType: SchedulingType.ROUND_ROBIN,
      };
@@ -1738,6 +1751,14 @@ describe("Event types Endpoints", () => {
              disableOnPrefill: false,
              hidden: false,
            },
+            {
+              disableOnPrefill: false,
+              hidden: true,
+              isDefault: true,
+              required: false,
+              slug: "attendeePhoneNumber",
+              type: "phone",
+            },
            {
              isDefault: true,
              type: "radioInput",
@@ -1841,6 +1862,130 @@ describe("Event types Endpoints", () => {
            expect(slug2).not.toEqual(slug);
          });
      });
+
+      it("should create event type with cal video settings", async () => {
+        const body: CreateEventTypeInput_2024_06_14 = {
+          title: "event type with cal video settings",
+          slug: "event-type-with-cal-video-settings",
+          lengthInMinutes: 60,
+          calVideoSettings: {
+            disableRecordingForGuests: true,
+            disableRecordingForOrganizer: true,
+          },
+          locations: [
+            {
+              type: "integration",
+              integration: "cal-video",
+            },
+          ],
+        };
+
+        return request(app.getHttpServer())
+          .post("/api/v2/event-types")
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+          .send(body)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14> = response.body;
+            const createdEventType = responseBody.data;
+            expect(createdEventType).toHaveProperty("id");
+            expect(createdEventType.title).toEqual(body.title);
+            expect(createdEventType.locations).toEqual(body.locations);
+            expect(createdEventType.calVideoSettings?.disableRecordingForGuests).toEqual(true);
+            expect(createdEventType.calVideoSettings?.disableRecordingForOrganizer).toEqual(true);
+            firstCreatedEventType = responseBody.data;
+          });
+      });
+    });
+
+    describe("toggle disable guests", () => {
+      let eventTypeWithGuestsDisabledId: number;
+
+      it("should create an event type with guests disabled", async () => {
+        const body: CreateEventTypeInput_2024_06_14 = {
+          title: "Coding class guests disabled",
+          slug: "coding-class-guests-disabled",
+          description: "Let's learn how to code like a pro.",
+          lengthInMinutes: 60,
+          disableGuests: true,
+        };
+
+        return request(app.getHttpServer())
+          .post("/api/v2/event-types")
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+          .send(body)
+          .expect(201)
+          .then(async (response) => {
+            const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14> = response.body;
+            const createdEventType = responseBody.data;
+            expect(createdEventType).toHaveProperty("id");
+            expect(createdEventType.title).toEqual(body.title);
+            expect(createdEventType.description).toEqual(body.description);
+            expect(createdEventType.lengthInMinutes).toEqual(body.lengthInMinutes);
+
+            expect(createdEventType.disableGuests).toEqual(true);
+            const guestsBookingField = createdEventType.bookingFields.find(
+              (field) => field.slug === "guests"
+            ) as GuestsDefaultFieldOutput_2024_06_14 | undefined;
+            expect(guestsBookingField?.hidden).toEqual(true);
+
+            eventTypeWithGuestsDisabledId = createdEventType.id;
+          });
+      });
+
+      it("should update an event type with guests enabled", async () => {
+        const body: UpdateEventTypeInput_2024_06_14 = {
+          disableGuests: false,
+        };
+
+        return request(app.getHttpServer())
+          .patch(`/api/v2/event-types/${eventTypeWithGuestsDisabledId}`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+          .send(body)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14> = response.body;
+            const updatedEventType = responseBody.data;
+
+            expect(updatedEventType.disableGuests).toEqual(false);
+            const guestsBookingField = updatedEventType.bookingFields.find(
+              (field) => field.slug === "guests"
+            ) as GuestsDefaultFieldOutput_2024_06_14 | undefined;
+            expect(guestsBookingField?.hidden).toEqual(false);
+
+            eventTypeWithGuestsDisabledId = updatedEventType.id;
+          });
+      });
+
+      it("should update an event type with guests disabled", async () => {
+        const body: UpdateEventTypeInput_2024_06_14 = {
+          disableGuests: true,
+        };
+
+        return request(app.getHttpServer())
+          .patch(`/api/v2/event-types/${eventTypeWithGuestsDisabledId}`)
+          .set(CAL_API_VERSION_HEADER, VERSION_2024_06_14)
+          .send(body)
+          .expect(200)
+          .then(async (response) => {
+            const responseBody: ApiSuccessResponse<EventTypeOutput_2024_06_14> = response.body;
+            const updatedEventType = responseBody.data;
+
+            expect(updatedEventType.disableGuests).toEqual(true);
+            const guestsBookingField = updatedEventType.bookingFields.find(
+              (field) => field.slug === "guests"
+            ) as GuestsDefaultFieldOutput_2024_06_14 | undefined;
+            expect(guestsBookingField?.hidden).toEqual(true);
+
+            eventTypeWithGuestsDisabledId = updatedEventType.id;
+          });
+      });
+
+      afterAll(async () => {
+        if (eventTypeWithGuestsDisabledId) {
+          await eventTypesRepositoryFixture.delete(eventTypeWithGuestsDisabledId);
+        }
+      });
    });

    afterAll(async () => {
@@ -114,6 +114,9 @@ export class EventTypesController_2024_06_14 {
    @Query() queryParams: GetEventTypesQuery_2024_06_14
  ): Promise<GetEventTypesOutput_2024_06_14> {
    const eventTypes = await this.eventTypesService.getEventTypes(queryParams);
+    if (!eventTypes || eventTypes.length === 0) {
+      throw new NotFoundException(`Event types not found`);
+    }
    const eventTypesFormatted = this.eventTypeResponseTransformPipe.transform(eventTypes);
    const eventTypesWithoutHiddenFields = eventTypesFormatted.map((eventType) => {
      return {
@@ -1,10 +1,9 @@
+import { InputEventTransformed_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/transformed";
 import { PrismaReadService } from "@/modules/prisma/prisma-read.service";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { Injectable } from "@nestjs/common";
 import type { Prisma } from "@prisma/client";

-import { InputEventTransformed_2024_06_14 } from "@calcom/platform-types";
-
@Injectable()
 export class EventTypesRepository_2024_06_14 {
  constructor(private readonly dbRead: PrismaReadService, private readonly dbWrite: PrismaWriteService) {}
@@ -13,13 +12,20 @@ export class EventTypesRepository_2024_06_14 {
    userId: number,
    body: Omit<InputEventTransformed_2024_06_14, "destinationCalendar">
  ) {
+    const { calVideoSettings, ...restBody } = body;
+
    return this.dbWrite.prisma.eventType.create({
      data: {
-        ...body,
+        ...restBody,
        userId,
        locations: body.locations,
        bookingFields: body.bookingFields,
        users: { connect: { id: userId } },
+        ...(calVideoSettings && {
+          calVideoSettings: {
+            create: calVideoSettings,
+          },
+        }),
      },
    });
  }
@@ -72,7 +78,7 @@ export class EventTypesRepository_2024_06_14 {
  async getEventTypeById(eventTypeId: number) {
    return this.dbRead.prisma.eventType.findUnique({
      where: { id: eventTypeId },
-      include: { users: true, schedule: true, destinationCalendar: true },
+      include: { users: true, schedule: true, destinationCalendar: true, calVideoSettings: true },
    });
  }

@@ -1,5 +1,7 @@
 import { DEFAULT_EVENT_TYPES } from "@/ee/event-types/event-types_2024_06_14/constants/constants";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
+import { InputEventTransformed_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/transformed";
+import { SystemField, CustomField } from "@/ee/event-types/event-types_2024_06_14/transformers";
 import { SchedulesRepository_2024_06_11 } from "@/ee/schedules/schedules_2024_06_11/schedules.repository";
 import { MembershipsRepository } from "@/modules/memberships/memberships.repository";
 import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
@@ -14,10 +16,8 @@ import {
  updateEventType,
  getEventTypesPublic,
  EventTypesPublic,
-  SystemField,
-  CustomField,
 } from "@calcom/platform-libraries/event-types";
-import { GetEventTypesQuery_2024_06_14, InputEventTransformed_2024_06_14 } from "@calcom/platform-types";
+import { GetEventTypesQuery_2024_06_14 } from "@calcom/platform-types";
 import { EventType } from "@calcom/prisma/client";

@Injectable()
@@ -1,13 +1,7 @@
 import { ConnectedCalendarsData } from "@/ee/calendars/outputs/connected-calendars.output";
 import { CalendarsService } from "@/ee/calendars/services/calendars.service";
 import { EventTypesRepository_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/event-types.repository";
-import { ConferencingService } from "@/modules/conferencing/services/conferencing.service";
-import { UserWithProfile } from "@/modules/users/users.repository";
-import { Injectable, BadRequestException } from "@nestjs/common";
-
-import { CONFERENCING_APPS } from "@calcom/platform-constants";
-import { getUsersCredentials } from "@calcom/platform-libraries";
-import { getApps } from "@calcom/platform-libraries/app-store";
+import { InputEventTransformed_2024_06_14 } from "@/ee/event-types/event-types_2024_06_14/transformed";
 import {
  transformBookingFieldsApiToInternal,
  transformLocationsApiToInternal,
@@ -21,21 +15,24 @@ import {
  systemAfterFieldNotes,
  systemAfterFieldGuests,
  systemAfterFieldRescheduleReason,
-  EventTypeMetaDataSchema,
  transformBookerLayoutsApiToInternal,
  transformConfirmationPolicyApiToInternal,
  transformEventColorsApiToInternal,
-  validateCustomEventName,
  transformSeatsApiToInternal,
  SystemField,
  CustomField,
  InternalLocation,
  InternalLocationSchema,
-} from "@calcom/platform-libraries/event-types";
+} from "@/ee/event-types/event-types_2024_06_14/transformers";
+import { UserWithProfile } from "@/modules/users/users.repository";
+import { Injectable, BadRequestException } from "@nestjs/common";
+
+import { getApps, getUsersCredentialsIncludeServiceAccountKey } from "@calcom/platform-libraries/app-store";
+import { validateCustomEventName, EventTypeMetaDataSchema } from "@calcom/platform-libraries/event-types";
 import {
  CreateEventTypeInput_2024_06_14,
  DestinationCalendar_2024_06_14,
-  InputEventTransformed_2024_06_14,
+  InputBookingField_2024_06_14,
  OutputUnknownLocation_2024_06_14,
  UpdateEventTypeInput_2024_06_14,
 } from "@calcom/platform-types";
@@ -121,16 +118,23 @@ export class InputEventTypesService_2024_06_14 {
      seats,
      customName,
      useDestinationCalendarEmail,
+      disableGuests,
      ...rest
    } = inputEventType;
    const confirmationPolicyTransformed = this.transformInputConfirmationPolicy(confirmationPolicy);

    const locationsTransformed = locations?.length ? this.transformInputLocations(locations) : undefined;
+
+    const effectiveBookingFields =
+      disableGuests !== undefined
+        ? this.getBookingFieldsWithGuestsToggled(bookingFields, disableGuests)
+        : bookingFields;
+
    const eventType = {
      ...rest,
      length: lengthInMinutes,
      locations: locationsTransformed,
-      bookingFields: this.transformInputBookingFields(bookingFields),
+      bookingFields: this.transformInputBookingFields(effectiveBookingFields),
      bookingLimits: bookingLimitsCount ? this.transformInputIntervalLimits(bookingLimitsCount) : undefined,
      durationLimits: bookingLimitsDuration
        ? this.transformInputIntervalLimits(bookingLimitsDuration)
@@ -171,6 +175,7 @@ export class InputEventTypesService_2024_06_14 {
      seats,
      customName,
      useDestinationCalendarEmail,
+      disableGuests,
      ...rest
    } = inputEventType;
    const eventTypeDb = await this.eventTypesRepository.getEventTypeWithMetaData(eventTypeId);
@@ -180,11 +185,18 @@ export class InputEventTypesService_2024_06_14 {

    const confirmationPolicyTransformed = this.transformInputConfirmationPolicy(confirmationPolicy);

+    const effectiveBookingFields =
+      disableGuests !== undefined
+        ? this.getBookingFieldsWithGuestsToggled(bookingFields, disableGuests)
+        : bookingFields;
+
    const eventType = {
      ...rest,
      length: lengthInMinutes,
      locations: locations ? this.transformInputLocations(locations) : undefined,
-      bookingFields: bookingFields ? this.transformInputBookingFields(bookingFields) : undefined,
+      bookingFields: effectiveBookingFields
+        ? this.transformInputBookingFields(effectiveBookingFields)
+        : undefined,
      bookingLimits: bookingLimitsCount ? this.transformInputIntervalLimits(bookingLimitsCount) : undefined,
      durationLimits: bookingLimitsDuration
        ? this.transformInputIntervalLimits(bookingLimitsDuration)
@@ -210,6 +222,27 @@ export class InputEventTypesService_2024_06_14 {
    return eventType;
  }

+  getBookingFieldsWithGuestsToggled(
+    bookingFields: InputBookingField_2024_06_14[] | undefined,
+    hideGuests: boolean
+  ) {
+    const toggledGuestsBookingField: InputBookingField_2024_06_14 = { slug: "guests", hidden: hideGuests };
+    if (!bookingFields) {
+      return [toggledGuestsBookingField];
+    }
+
+    const bookingFieldsCopy = [...bookingFields];
+
+    const guestsBookingField = bookingFieldsCopy.find((field) => "slug" in field && field.slug === "guests");
+    if (guestsBookingField) {
+      Object.assign(guestsBookingField, { hidden: hideGuests });
+      return bookingFieldsCopy;
+    }
+
+    bookingFieldsCopy.push(toggledGuestsBookingField);
+    return bookingFieldsCopy;
+  }
+
  transformInputLocations(inputLocations: CreateEventTypeInput_2024_06_14["locations"]) {
    return transformLocationsApiToInternal(inputLocations);
  }
@@ -478,7 +511,7 @@ export class InputEventTypesService_2024_06_14 {
      appSlug = "msteams";
    }

-    const credentials = await getUsersCredentials(user);
+    const credentials = await getUsersCredentialsIncludeServiceAccountKey(user);

    const foundApp = getApps(credentials, true).filter((app) => app.slug === appSlug)[0];

@@ -1,14 +1,4 @@
-import { Injectable } from "@nestjs/common";
-import type { EventType, User, Schedule, DestinationCalendar } from "@prisma/client";
-
 import {
-  userMetadata,
-  parseBookingLimit,
-  parseRecurringEvent,
-  getBookingFieldsWithSystemFields,
-} from "@calcom/platform-libraries";
-import {
-  EventTypeMetaDataSchema,
  transformLocationsInternalToApi,
  transformBookingFieldsInternalToApi,
  InternalLocationSchema,
@@ -20,11 +10,20 @@ import {
  transformBookerLayoutsInternalToApi,
  transformRequiresConfirmationInternalToApi,
  transformEventTypeColorsInternalToApi,
-  parseEventTypeColor,
  transformSeatsInternalToApi,
  InternalLocation,
  BookingFieldSchema,
-} from "@calcom/platform-libraries/event-types";
+} from "@/ee/event-types/event-types_2024_06_14/transformers";
+import { Injectable } from "@nestjs/common";
+import type { EventType, User, Schedule, DestinationCalendar, CalVideoSettings } from "@prisma/client";
+
+import {
+  userMetadata,
+  parseBookingLimit,
+  parseRecurringEvent,
+  getBookingFieldsWithSystemFields,
+} from "@calcom/platform-libraries";
+import { EventTypeMetaDataSchema, parseEventTypeColor } from "@calcom/platform-libraries/event-types";
 import {
  TransformFutureBookingsLimitSchema_2024_06_14,
  BookerLayoutsTransformedSchema,
@@ -38,8 +37,9 @@ type EventTypeRelations = {
  users: User[];
  schedule: Schedule | null;
  destinationCalendar?: DestinationCalendar | null;
+  calVideoSettings?: CalVideoSettings | null;
 };
-export type DatabaseEventType = EventType & EventTypeRelations;
+export type DatabaseEventType = Omit<EventType, "allowReschedulingCancelledBookings"> & EventTypeRelations;

 type Input = Pick<
  DatabaseEventType,
@@ -88,6 +88,7 @@ type Input = Pick<
  | "useEventTypeDestinationCalendarEmail"
  | "hideCalendarEventDetails"
  | "hideOrganizerEmail"
+  | "calVideoSettings"
 >;

@Injectable()
@@ -125,6 +126,7 @@ export class OutputEventTypesService_2024_06_14 {
      useEventTypeDestinationCalendarEmail,
      hideCalendarEventDetails,
      hideOrganizerEmail,
+      calVideoSettings,
    } = databaseEventType;

    const locations = this.transformLocations(databaseEventType.locations);
@@ -200,6 +202,7 @@ export class OutputEventTypesService_2024_06_14 {
      useDestinationCalendarEmail: useEventTypeDestinationCalendarEmail,
      hideCalendarEventDetails,
      hideOrganizerEmail,
+      calVideoSettings,
    };
  }

@@ -1,5 +1,3 @@
-import type { z } from "zod";
-
 import type {
  transformEventColorsApiToInternal,
  transformFutureBookingLimitsApiToInternal,
@@ -8,9 +6,13 @@ import type {
  transformSeatsApiToInternal,
  transformBookingFieldsApiToInternal,
  InternalLocationsSchema,
-} from "@calcom/lib/event-types/transformers";
+} from "@/ee/event-types/event-types_2024_06_14/transformers";
+import type { z } from "zod";

-import type { CreateEventTypeInput_2024_06_14, ConfirmationPolicyTransformedSchema } from "../inputs";
+import type {
+  CreateEventTypeInput_2024_06_14,
+  ConfirmationPolicyTransformedSchema,
+} from "@calcom/platform-types";

 export type InputEventTransformed_2024_06_14 = Omit<
  CreateEventTypeInput_2024_06_14,
@@ -1,12 +1,10 @@
-import { describe, expect, it } from "vitest";
-
 import {
  BookerLayoutsInputEnum_2024_06_14,
  BookerLayoutsOutputEnum_2024_06_14,
  ConfirmationPolicyEnum,
  NoticeThresholdUnitEnum,
  FrequencyInput,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import type {
  InputBookingField_2024_06_14,
  InputLocation_2024_06_14,
@@ -1,7 +1,7 @@
 import {
  BookerLayoutsInputEnum_2024_06_14,
  BookerLayoutsOutputEnum_2024_06_14,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import { type CreateEventTypeInput_2024_06_14 } from "@calcom/platform-types";

 export function transformBookerLayoutsApiToInternal(
@@ -1,4 +1,4 @@
-import { ConfirmationPolicyEnum } from "@calcom/platform-enums/monorepo";
+import { ConfirmationPolicyEnum } from "@calcom/platform-enums";
 import type {
  ConfirmationPolicyTransformedSchema,
  NoticeThresholdTransformedSchema,
@@ -1,7 +1,7 @@
 import {
  BookingWindowPeriodInputTypeEnum_2024_06_14,
  BookingWindowPeriodOutputTypeEnum_2024_06_14,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import {
  type CreateEventTypeInput_2024_06_14,
  type BusinessDaysWindow_2024_06_14,
@@ -1,4 +1,4 @@
-import { BookingLimitsEnum_2024_06_14 } from "@calcom/platform-enums/monorepo";
+import { BookingLimitsEnum_2024_06_14 } from "@calcom/platform-enums";
 import {
  type CreateEventTypeInput_2024_06_14,
  type BookingLimitsKeyOutputType_2024_06_14,
@@ -1,4 +1,4 @@
-import { Frequency } from "@calcom/platform-enums/monorepo";
+import { Frequency } from "@calcom/platform-enums";
 import type { Recurrence_2024_06_14 } from "@calcom/platform-types";
 import { type TransformRecurringEventSchema_2024_06_14 } from "@calcom/platform-types";

@@ -1,7 +1,7 @@
 import {
  BookerLayoutsInputEnum_2024_06_14,
  BookerLayoutsOutputEnum_2024_06_14,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import type { BookerLayoutsTransformedSchema } from "@calcom/platform-types";

 export function transformBookerLayoutsInternalToApi(
@@ -1,7 +1,7 @@
 import {
  BookingWindowPeriodInputTypeEnum_2024_06_14,
  BookingWindowPeriodOutputTypeEnum_2024_06_14,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import type {
  TransformFutureBookingsLimitSchema_2024_06_14,
  BookingWindow_2024_06_14,
@@ -1,11 +1,9 @@
-import { describe, expect, it } from "vitest";
-
 import {
  BookerLayoutsInputEnum_2024_06_14,
  BookerLayoutsOutputEnum_2024_06_14,
  ConfirmationPolicyEnum,
  NoticeThresholdUnitEnum,
-} from "@calcom/platform-enums/monorepo";
+} from "@calcom/platform-enums";
 import type {
  TransformBookingLimitsSchema_2024_06_14,
  TransformFutureBookingsLimitSchema_2024_06_14,
@@ -1,4 +1,4 @@
-import { BookingLimitsEnum_2024_06_14 } from "@calcom/platform-enums/monorepo";
+import { BookingLimitsEnum_2024_06_14 } from "@calcom/platform-enums";
 import type {
  BookingLimitsKeysInputType,
  TransformBookingLimitsSchema_2024_06_14,
@@ -1,4 +1,4 @@
-import { Frequency, FrequencyInput } from "@calcom/platform-enums/monorepo";
+import { Frequency, FrequencyInput } from "@calcom/platform-enums";
 import type { Recurrence_2024_06_14, TransformRecurringEventSchema_2024_06_14 } from "@calcom/platform-types";

 export function transformRecurrenceInternalToApi(
@@ -1,4 +1,4 @@
-import { ConfirmationPolicyEnum } from "@calcom/platform-enums/monorepo";
+import { ConfirmationPolicyEnum } from "@calcom/platform-enums";
 import type { NoticeThresholdTransformedSchema, ConfirmationPolicy_2024_06_14 } from "@calcom/platform-types";

 export function transformRequiresConfirmationInternalToApi(
@@ -46,11 +46,10 @@ export class SchedulesController_2024_04_15 {
    @Body() bodySchedule: CreateScheduleInput_2024_04_15
  ): Promise<CreateScheduleOutput_2024_04_15> {
    const schedule = await this.schedulesService.createUserSchedule(user.id, bodySchedule);
-    const scheduleFormatted = await this.schedulesService.formatScheduleForAtom(user, schedule);

    return {
      status: SUCCESS_STATUS,
-      data: scheduleFormatted,
+      data: schedule,
    };
  }

@@ -60,13 +59,10 @@ export class SchedulesController_2024_04_15 {
    @GetUser() user: UserWithProfile
  ): Promise<GetDefaultScheduleOutput_2024_04_15 | null> {
    const schedule = await this.schedulesService.getUserScheduleDefault(user.id);
-    const scheduleFormatted = schedule
-      ? await this.schedulesService.formatScheduleForAtom(user, schedule)
-      : null;

    return {
      status: SUCCESS_STATUS,
-      data: scheduleFormatted,
+      data: schedule,
    };
  }

@@ -77,23 +73,25 @@ export class SchedulesController_2024_04_15 {
    @Param("scheduleId") scheduleId: number
  ): Promise<GetScheduleOutput_2024_04_15> {
    const schedule = await this.schedulesService.getUserSchedule(user.id, scheduleId);
-    const scheduleFormatted = await this.schedulesService.formatScheduleForAtom(user, schedule);

    return {
      status: SUCCESS_STATUS,
-      data: scheduleFormatted,
+      data: schedule,
    };
  }

  @Get("/")
  @Permissions([SCHEDULE_READ])
  async getSchedules(@GetUser() user: UserWithProfile): Promise<GetSchedulesOutput_2024_04_15> {
-    const schedules = await this.schedulesService.getUserSchedules(user.id);
-    const schedulesFormatted = await this.schedulesService.formatSchedulesForAtom(user, schedules);
+    const schedules = await this.schedulesService.getUserSchedules(
+      user.id,
+      user.timeZone,
+      user.defaultScheduleId
+    );

    return {
      status: SUCCESS_STATUS,
-      data: schedulesFormatted,
+      data: schedules,
    };
  }

@@ -1,26 +1,22 @@
 import { CreateAvailabilityInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-availability.input";
 import { CreateScheduleInput_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/inputs/create-schedule.input";
-import { ScheduleOutput } from "@/ee/schedules/schedules_2024_04_15/outputs/schedule.output";
 import { SchedulesRepository_2024_04_15 } from "@/ee/schedules/schedules_2024_04_15/schedules.repository";
+import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";
 import { UserWithProfile, UsersRepository } from "@/modules/users/users.repository";
 import { BadRequestException, ForbiddenException, Injectable, NotFoundException } from "@nestjs/common";
 import { Schedule } from "@prisma/client";
-import { User } from "@prisma/client";

-import type { ScheduleWithAvailabilities } from "@calcom/platform-libraries-0.0.2";
-import { updateScheduleHandler } from "@calcom/platform-libraries-0.0.2";
-import {
-  transformWorkingHoursForClient,
-  transformAvailabilityForClient,
-  transformDateOverridesForClient,
-} from "@calcom/platform-libraries-0.0.2";
+import { updateSchedule } from "@calcom/platform-libraries/schedules";
+import { ScheduleRepository } from "@calcom/platform-libraries/schedules";
 import { UpdateScheduleInput_2024_04_15 } from "@calcom/platform-types";
+import { PrismaClient } from "@calcom/prisma";

@Injectable()
 export class SchedulesService_2024_04_15 {
  constructor(
    private readonly schedulesRepository: SchedulesRepository_2024_04_15,
-    private readonly usersRepository: UsersRepository
+    private readonly usersRepository: UsersRepository,
+    private readonly dbWrite: PrismaWriteService
  ) {}

  async createUserDefaultSchedule(userId: number, timeZone: string) {
@@ -48,7 +44,9 @@ export class SchedulesService_2024_04_15 {
      await this.usersRepository.setDefaultSchedule(userId, createdSchedule.id);
    }

-    return createdSchedule;
+    const formattedSchedule = await this.getUserSchedule(userId, createdSchedule.id);
+
+    return formattedSchedule;
  }

  async getUserScheduleDefault(userId: number) {
@@ -56,11 +54,29 @@ export class SchedulesService_2024_04_15 {

    if (!user?.defaultScheduleId) return null;

-    return this.schedulesRepository.getScheduleById(user.defaultScheduleId);
+    return await ScheduleRepository.findDetailedScheduleById({
+      scheduleId: user.defaultScheduleId,
+      isManagedEventType: undefined,
+      userId,
+      timeZone: user.timeZone,
+      defaultScheduleId: user.defaultScheduleId,
+    });
  }

  async getUserSchedule(userId: number, scheduleId: number) {
-    const existingSchedule = await this.schedulesRepository.getScheduleById(scheduleId);
+    const user = await this.usersRepository.findById(userId);
+
+    if (!user) {
+      throw new NotFoundException(`User with ID=${userId} does not exist.`);
+    }
+
+    const existingSchedule = await ScheduleRepository.findDetailedScheduleById({
+      scheduleId: scheduleId,
+      isManagedEventType: undefined,
+      userId,
+      timeZone: user.timeZone,
+      defaultScheduleId: user.defaultScheduleId,
+    });

    if (!existingSchedule) {
      throw new NotFoundException(`Schedule with ID=${scheduleId} does not exist.`);
@@ -71,8 +87,8 @@ export class SchedulesService_2024_04_15 {
    return existingSchedule;
  }

-  async getUserSchedules(userId: number) {
-    return this.schedulesRepository.getSchedulesByUserId(userId);
+  async getUserSchedules(userId: number, timeZone: string, defaultScheduleId: number | null) {
+    return ScheduleRepository.findManyDetailedScheduleByUserId({ userId, timeZone, defaultScheduleId });
  }

  async updateUserSchedule(
@@ -89,7 +105,6 @@ export class SchedulesService_2024_04_15 {
    this.checkUserOwnsSchedule(user.id, existingSchedule);

    const schedule = await this.getUserSchedule(user.id, Number(scheduleId));
-    const scheduleFormatted = await this.formatScheduleForAtom(user, schedule);

    if (!bodySchedule.schedule) {
      // note(Lauris): When updating an availability in cal web app, lets say only its name, also
@@ -97,12 +112,16 @@ export class SchedulesService_2024_04_15 {
      // and they have same shape, so to match shapes I attach "scheduleFormatted.availability" to reflect
      // schedule that would be passed by the web app. If we don't, then updating schedule name will erase
      // schedule.
-      bodySchedule.schedule = scheduleFormatted.availability;
+      bodySchedule.schedule = schedule.availability;
    }

-    return updateScheduleHandler({
-      input: { scheduleId: Number(scheduleId), ...bodySchedule },
-      ctx: { user },
+    return updateSchedule({
+      input: {
+        scheduleId: Number(scheduleId),
+        ...bodySchedule,
+      },
+      user,
+      prisma: this.dbWrite.prisma as unknown as PrismaClient,
    });
  }

@@ -118,44 +137,6 @@ export class SchedulesService_2024_04_15 {
    return this.schedulesRepository.deleteScheduleById(scheduleId);
  }

-  async formatScheduleForAtom(user: User, schedule: ScheduleWithAvailabilities): Promise<ScheduleOutput> {
-    const usersSchedulesCount = await this.schedulesRepository.getUserSchedulesCount(user.id);
-    return this.transformScheduleForAtom(schedule, usersSchedulesCount, user);
-  }
-
-  async formatSchedulesForAtom(
-    user: User,
-    schedules: ScheduleWithAvailabilities[]
-  ): Promise<ScheduleOutput[]> {
-    const usersSchedulesCount = await this.schedulesRepository.getUserSchedulesCount(user.id);
-    return Promise.all(
-      schedules.map((schedule) => this.transformScheduleForAtom(schedule, usersSchedulesCount, user))
-    );
-  }
-
-  async transformScheduleForAtom(
-    schedule: ScheduleWithAvailabilities,
-    userSchedulesCount: number,
-    user: Pick<User, "id" | "defaultScheduleId" | "timeZone">
-  ): Promise<ScheduleOutput> {
-    const timeZone = schedule.timeZone || user.timeZone;
-    const defaultSchedule = await this.getUserScheduleDefault(user.id);
-
-    return {
-      id: schedule.id,
-      name: schedule.name,
-      isManaged: schedule.userId !== user.id,
-      workingHours: transformWorkingHoursForClient(schedule),
-      schedule: schedule.availability,
-      availability: transformAvailabilityForClient(schedule),
-      timeZone,
-      dateOverrides: transformDateOverridesForClient(schedule, timeZone),
-      isDefault: defaultSchedule?.id === schedule.id,
-      isLastSchedule: userSchedulesCount <= 1,
-      readOnly: schedule.userId !== user.id,
-    };
-  }
-
  checkUserOwnsSchedule(userId: number, schedule: Pick<Schedule, "id" | "userId">) {
    if (userId !== schedule.userId) {
      throw new ForbiddenException(`User with ID=${userId} does not own schedule with ID=${schedule.id}`);
@@ -1,11 +1,7 @@
 import { Injectable } from "@nestjs/common";

-import {
-  transformApiScheduleOverrides,
-  transformApiScheduleAvailability,
-} from "@calcom/platform-libraries/schedules";
 import { CreateScheduleInput_2024_06_11, ScheduleAvailabilityInput_2024_06_11 } from "@calcom/platform-types";
-import { ScheduleOverrideInput_2024_06_11 } from "@calcom/platform-types";
+import { ScheduleOverrideInput_2024_06_11, WeekDay } from "@calcom/platform-types";

@Injectable()
 export class InputSchedulesService_2024_06_11 {
@@ -34,10 +30,52 @@ export class InputSchedulesService_2024_06_11 {
  }

  transformInputScheduleAvailability(inputAvailability: ScheduleAvailabilityInput_2024_06_11[]) {
-    return transformApiScheduleAvailability(inputAvailability);
+    return inputAvailability.map((availability) => ({
+      days: availability.days.map(this.transformDayToNumber),
+      startTime: this.createDateFromHoursMinutes(availability.startTime),
+      endTime: this.createDateFromHoursMinutes(availability.endTime),
+    }));
  }

  transformInputOverrides(inputOverrides: ScheduleOverrideInput_2024_06_11[]) {
-    return transformApiScheduleOverrides(inputOverrides);
+    return inputOverrides.map((override) => ({
+      date: new Date(override.date),
+      startTime: this.createDateFromHoursMinutes(override.startTime),
+      endTime: this.createDateFromHoursMinutes(override.endTime),
+    }));
+  }
+
+  createDateFromHoursMinutes(hoursMinutes: string): Date {
+    const parts = hoursMinutes.split(":");
+
+    if (parts.length < 2) {
+      throw new Error("Invalid time format. Please use 'hh:mm'.");
+    }
+
+    const hours = parseInt(parts[0], 10);
+    const minutes = parseInt(parts[1], 10);
+
+    if (isNaN(hours) || hours < 0 || hours > 23) {
+      throw new Error("Hours must be a number between 0 and 23.");
+    }
+    if (isNaN(minutes) || minutes < 0 || minutes > 59) {
+      throw new Error("Minutes must be a number between 0 and 59.");
+    }
+
+    const utcDate = new Date(Date.UTC(1970, 0, 1, hours, minutes));
+
+    return utcDate;
+  }
+  transformDayToNumber(day: WeekDay): number {
+    const weekMap: { [key in WeekDay]: number } = {
+      Sunday: 0,
+      Monday: 1,
+      Tuesday: 2,
+      Wednesday: 3,
+      Thursday: 4,
+      Friday: 5,
+      Saturday: 6,
+    };
+    return weekMap[day];
  }
 }
@@ -17,7 +17,7 @@ export type Environment = {
  STRIPE_API_KEY: string;
  STRIPE_WEBHOOK_SECRET: string;
  WEB_APP_URL: string;
-  IS_E2E: boolean;
+  IS_E2E: string;
  CALCOM_LICENSE_KEY: string;
  GET_LICENSE_KEY_URL: string;
  API_KEY_PREFIX: string;
@@ -32,6 +32,8 @@ export type Environment = {
  AXIOM_TOKEN: string;
  STRIPE_TEAM_MONTHLY_PRICE_ID: string;
  IS_TEAM_BILLING_ENABLED: boolean;
+  // Used to enable/disable the rewrite of /api/v2 to /v2, active by default.
+  REWRITE_API_V2_PREFIX: string;
 };

 export const getEnv = <K extends keyof Environment>(key: K, fallback?: Environment[K]): Environment[K] => {
@@ -1,3 +1,4 @@
+import { extractUserContext } from "@/lib/extract-user-context";
 import { filterReqHeaders } from "@/lib/filterReqHeaders";
 import { ArgumentsHost, Catch, ExceptionFilter, Logger } from "@nestjs/common";
 import { Request } from "express";
@@ -39,6 +40,7 @@ export class CalendarServiceExceptionFilter implements ExceptionFilter {
    const requestId = request.headers["X-Request-Id"] ?? "unknown-request-id";
    response.setHeader("X-Request-Id", requestId.toString());

+    const userContext = extractUserContext(request);
    this.logger.error(`Calendar Service Exception Filter: ${exception?.message}`, {
      exception,
      body: request.body,
@@ -46,6 +48,7 @@ export class CalendarServiceExceptionFilter implements ExceptionFilter {
      url: request.url,
      method: request.method,
      requestId,
+      ...userContext,
    });

    response.status(400).json({
@@ -1,3 +1,4 @@
+import { extractUserContext } from "@/lib/extract-user-context";
 import { filterReqHeaders } from "@/lib/filterReqHeaders";
 import { ArgumentsHost, Catch, ExceptionFilter, HttpException, Logger } from "@nestjs/common";
 import { Request } from "express";
@@ -16,6 +17,7 @@ export class HttpExceptionFilter implements ExceptionFilter<HttpException> {
    const statusCode = exception.getStatus();
    const requestId = request.headers["X-Request-Id"] ?? "unknown-request-id";
    response.setHeader("X-Request-Id", requestId.toString());
+    const userContext = extractUserContext(request);
    this.logger.error(`Http Exception Filter: ${exception?.message}`, {
      exception,
      body: request.body,
@@ -23,6 +25,7 @@ export class HttpExceptionFilter implements ExceptionFilter<HttpException> {
      url: request.url,
      method: request.method,
      requestId,
+      ...userContext,
    });

    response.status(statusCode).json({
@@ -1,3 +1,4 @@
+import { extractUserContext } from "@/lib/extract-user-context";
 import { filterReqHeaders } from "@/lib/filterReqHeaders";
 import type { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
 import { Catch, HttpStatus, Logger } from "@nestjs/common";
@@ -43,6 +44,7 @@ export class PrismaExceptionFilter implements ExceptionFilter {
    const requestId = request.headers["X-Request-Id"] ?? "unknown-request-id";
    response.setHeader("X-Request-Id", requestId.toString());

+    const userContext = extractUserContext(request);
    this.logger.error(`PrismaError: ${error.message}`, {
      error,
      body: request.body,
@@ -50,6 +52,7 @@ export class PrismaExceptionFilter implements ExceptionFilter {
      url: request.url,
      method: request.method,
      requestId,
+      ...userContext,
    });

    let message = "There was an error, please try again later.";
@@ -1,3 +1,4 @@
+import { extractUserContext } from "@/lib/extract-user-context";
 import { filterReqHeaders } from "@/lib/filterReqHeaders";
 import { ArgumentsHost, Catch, ExceptionFilter, Logger } from "@nestjs/common";
 import { Request } from "express";
@@ -6,6 +7,100 @@ import { ERROR_STATUS } from "@calcom/platform-constants";
 import { TRPCError } from "@calcom/platform-libraries";
 import { Response } from "@calcom/platform-types";

+export type TRPCErrorCode = TRPCError["code"];
+
+export interface ErrorDefinition {
+  statusCode: number;
+  message: string;
+}
+
+// Define the specific TRPC error codes
+export const TRPC_ERROR_CODE = {
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  NOT_FOUND: "NOT_FOUND",
+  INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
+  BAD_REQUEST: "BAD_REQUEST",
+  CONFLICT: "CONFLICT",
+  TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
+  PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE",
+  CLIENT_CLOSED_REQUEST: "CLIENT_CLOSED_REQUEST",
+  METHOD_NOT_SUPPORTED: "METHOD_NOT_SUPPORTED",
+  NOT_IMPLEMENTED: "NOT_IMPLEMENTED",
+  PRECONDITION_FAILED: "PRECONDITION_FAILED",
+  TIMEOUT: "TIMEOUT",
+  UNPROCESSABLE_CONTENT: "UNPROCESSABLE_CONTENT",
+  PARSE_ERROR: "PARSE_ERROR",
+} as const; // `as const` ensures literal types, improving type inference
+
+// Map TRPC error codes to their HTTP status codes and default messages
+export const TRPC_ERROR_MAP: Record<(typeof TRPC_ERROR_CODE)[keyof typeof TRPC_ERROR_CODE], ErrorDefinition> =
+  {
+    [TRPC_ERROR_CODE.UNAUTHORIZED]: {
+      statusCode: 401,
+      message: "You are not authorized to access this resource",
+    },
+    [TRPC_ERROR_CODE.FORBIDDEN]: {
+      statusCode: 403,
+      message: "You don't have necessary permissions to access this resource",
+    },
+    [TRPC_ERROR_CODE.NOT_FOUND]: {
+      statusCode: 404,
+      message: "The requested resource was not found",
+    },
+    [TRPC_ERROR_CODE.INTERNAL_SERVER_ERROR]: {
+      statusCode: 500,
+      message: "An unexpected error occurred on the server. Please try again later",
+    },
+    [TRPC_ERROR_CODE.BAD_REQUEST]: {
+      statusCode: 400,
+      message: "Bad request: Please check your request data and try again",
+    },
+    [TRPC_ERROR_CODE.CONFLICT]: {
+      statusCode: 409,
+      message: "Could not process the request due to a resource conflict with the current state",
+    },
+    [TRPC_ERROR_CODE.TOO_MANY_REQUESTS]: {
+      statusCode: 429,
+      message: "You have exceeded the allowed number of requests",
+    },
+    [TRPC_ERROR_CODE.PAYLOAD_TOO_LARGE]: {
+      statusCode: 413,
+      message: "The request payload is too large",
+    },
+    [TRPC_ERROR_CODE.CLIENT_CLOSED_REQUEST]: {
+      statusCode: 499,
+      message: "The client closed the connection before the server could finish processing the request",
+    },
+    [TRPC_ERROR_CODE.METHOD_NOT_SUPPORTED]: {
+      statusCode: 405,
+      message: "The requested method is not supported for this resource",
+    },
+    [TRPC_ERROR_CODE.NOT_IMPLEMENTED]: {
+      statusCode: 501,
+      message: "The requested method is not implemented on the server",
+    },
+    [TRPC_ERROR_CODE.PRECONDITION_FAILED]: {
+      statusCode: 412,
+      message: "The server does not meet one of the preconditions that the requester put on the request",
+    },
+    [TRPC_ERROR_CODE.TIMEOUT]: {
+      statusCode: 408,
+      message: "The request took too long to complete. Please try again later",
+    },
+    [TRPC_ERROR_CODE.UNPROCESSABLE_CONTENT]: {
+      statusCode: 422,
+      message:
+        "The server was unable to process the request because the request payload is semantically incorrect or because the request is syntactically incorrect",
+    },
+    [TRPC_ERROR_CODE.PARSE_ERROR]: {
+      statusCode: 400,
+      message: "The request could not be parsed due to invalid syntax.",
+    },
+  };
+
+// --- TRPCExceptionFilter (updated) ---
+
@Catch(TRPCError)
 export class TRPCExceptionFilter implements ExceptionFilter {
  private readonly logger = new Logger("TRPCExceptionFilter");
@@ -15,81 +110,18 @@ export class TRPCExceptionFilter implements ExceptionFilter {
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();

-    let statusCode = 500;
-    let errorMessage = exception.message;
+    const errorDefinition = TRPC_ERROR_MAP[exception.code as keyof typeof TRPC_ERROR_CODE] || {
+      statusCode: 500,
+      message: exception.message,
+    };

-    switch (exception.code) {
-      case "UNAUTHORIZED":
-        statusCode = 401;
-        errorMessage = "You are not authorized to access this resource";
-        break;
-      case "FORBIDDEN":
-        statusCode = 403;
-        errorMessage = "You don't have necessary permissions to access this resource";
-        break;
-      case "NOT_FOUND":
-        statusCode = 404;
-        errorMessage = "The requested resource was not found";
-        break;
-      case "INTERNAL_SERVER_ERROR":
-        statusCode = 500;
-        errorMessage = "An unexpected error occurred on the server. Please try again later";
-        break;
-      case "BAD_REQUEST":
-        statusCode = 400;
-        errorMessage = "Bad request: Please check your request data and try again";
-        break;
-      case "CONFLICT":
-        statusCode = 409;
-        errorMessage = "Could not process the request due to a resource conflict with the current state";
-        break;
-      case "TOO_MANY_REQUESTS":
-        statusCode = 429;
-        errorMessage = "You have exceeded the allowed number of requests";
-        break;
-      case "PAYLOAD_TOO_LARGE":
-        statusCode = 413;
-        errorMessage = "The request payload is too large";
-        break;
-      case "CLIENT_CLOSED_REQUEST":
-        statusCode = 499;
-        errorMessage =
-          "The client closed the connection before the server could finish processing the request";
-        break;
-      case "METHOD_NOT_SUPPORTED":
-        statusCode = 405;
-        errorMessage = "The requested method is not supported for this resource";
-      case "NOT_IMPLEMENTED":
-        statusCode = 501;
-        errorMessage = "The requested method is not implemented on the server";
-        break;
-      case "PRECONDITION_FAILED":
-        statusCode = 412;
-        errorMessage =
-          "The server does not meet one of the preconditions that the requester put on the request";
-        break;
-      case "TIMEOUT":
-        statusCode = 408;
-        errorMessage = "The request took too long to complete. Please try again later";
-        break;
-      case "UNPROCESSABLE_CONTENT":
-        statusCode = 422;
-        errorMessage =
-          "The server was unable to process the request because the request payload is semantically incorrect or because the request is syntactically incorrect";
-        break;
-      case "PARSE_ERROR":
-        statusCode = 400;
-        errorMessage = "The request could not be parsed due to invalid syntax.";
-        break;
-      default:
-        statusCode = 500;
-        errorMessage = exception.message;
-        break;
-    }
+    const statusCode = errorDefinition.statusCode;
+    const errorMessage = errorDefinition.message;

    const requestId = request.headers["X-Request-Id"] ?? "unknown-request-id";
    response.setHeader("X-Request-Id", requestId.toString());

+    const userContext = extractUserContext(request);
    this.logger.error(`TRPC Exception Filter: ${exception?.message}`, {
      exception,
      body: request.body,
@@ -97,13 +129,14 @@ export class TRPCExceptionFilter implements ExceptionFilter {
      url: request.url,
      method: request.method,
      requestId,
+      ...userContext,
    });

    response.status(statusCode).json({
      status: ERROR_STATUS,
      timestamp: new Date().toISOString(),
      path: request.url,
-      error: { code: exception.name, message: errorMessage },
+      error: { code: exception.name, message: errorMessage }, // exception.name is usually "TRPCError"
    });
  }
 }
--- a/Show More
+++ b/Show More